src/Controller/WS/GiftCardPointController.php line 816

Open in your IDE?
  1. <?php
  3. namespace App\Controller\WS;
  5. use Symfony\Component\Console\Input\ArrayInput;
  6. use Symfony\Component\Console\Output\BufferedOutput;
  7. use Symfony\Bundle\FrameworkBundle\Console\Application;
  8. use Symfony\Component\HttpFoundation\Request;
  9. use Symfony\Component\HttpFoundation\Response;
  10. use Symfony\Component\HttpFoundation\JsonResponse;
  11. use App\Util\Util as Utilx;
  12. use App\Util\WS\Util;
  13. use App\Util\NewUtil;
  14. use App\Util\WS\PointsUtilPorcessor;
  15. use App\Entity\AccountLicense;
  16. use App\Entity\PointAcount;
  17. use App\Entity\PtsAdquiRedemRules;
  18. use App\Entity\TypePoint;
  19. use App\Entity\TypePointAcount;
  20. use App\Entity\OmtClient;
  21. use App\Entity\WebService;
  22. use App\Entity\PointRelatedRequest;
  23. use App\Entity\RabbitRelatedGenericEntity;
  24. use App\Entity\TypePtsGenericDefinitionRules;
  25. use App\Entity\RestaurantLoyaltyConfiguration;
  26. use App\Entity\ActionHistory;
  27. use App\Util\Paginator;
  28. use App\Util\UUIDGeneratorUtil;
  29. use App\Transformer\LicensorGenericTransformer;
  30. use App\Controller\Application\Service\ArmorService;
  31. use App\Controller\Application\Service\Log\Log;
  32. use App\Controller\Application\Service\Util\Encryptor;
  33. use App\Controller\WS\ClientController;
  34. use App\Form\RestaurantLoyaltyConfig;
  35. use App\Form\PointsAdquiRedemRules;
  36. use App\Structure\Dashboard;
  37. use App\Structure\Configuracion;
  38. use App\Structure\RegistActions;
  39. use App\Structure\ConfRangedelivery;
  40. use App\Structure\ValorEpiMerchant;
  41. use App\Form\MerchantAccountType;
  42. use App\Structure\ConfGeneralDelivery;
  43. use App\Structure\ConfMerchantAccount;
  44. use App\Util\WS\ForcedAsynchronousCommandsUtil;
  45. use App\Util\WS\Util as WsUtilx;
  46. use App\Structure\LoyaltyHistory;
  47. use App\Structure\MesaPedido;
  48. use DateTime;
  50. class GiftCardPointController extends ApiController {
  52.     /**
  53.      * @param \Symfony\Component\HttpFoundation\Request $request datos de la solicitud
  54.      * @return Response Json con la informacion de respuesta
  55.     */
  56.     public function createOmtClientRecord(Request $request) {
  58.         if ($request->getMethod() === WebService::REQUEST_METHOD_POST) {
  60.             $data = json_decode($request->getContent(), true);
  62.             if (!isset($data['uid'])) {
  63.                 return $this->errorWrongArgs('Wrong Arguments!', WebService::CODE_WRONG_ARGUMENTS);
  64.             }
  66.             $em = $this->getDoctrine()->getManager();
  68.             $nicknameDataSearch = ['alLicenseUsername' => $data['nickname']];
  69.             $accountLicData = $em->getRepository('App\Entity\AccountLicense')->findBy($nicknameDataSearch);
  71.             if (empty($accountLicData)) {
  72.                 return $this->setStatusCode(WebService::HTTP_CODE_UNAUTHORIZED)
  73.                                 ->respondWithError('Invalid nickname', WebService::CODE_COULD_NOT_AUTHENTICATE);
  74.             }
  76.             if ($accountLicData[0]->getDeviceUid() != $data['uid']) {
  77.                 $emLev = Util::emLicenseConnection($this->realContainer, $em, $accountLicData[0]);
  79.                 $registeredClientsByUID = $emLev->getRepository('App\Structure\Stations')->findBy(['staDeviceCode' => $data['uid']]);
  81.                 if (empty($registeredClientsByUID)) {
  82.                     $emLev->close();
  83.                     return $this->setStatusCode(WebService::HTTP_CODE_UNAUTHORIZED)
  84.                                     ->respondWithError('Unknown device', WebService::CODE_UNAUTHORIZED);
  85.                 } else {
  86.                     $emLev->close();
  87.                 }
  88.             }
  90.             if (strlen($data['id']) != 36) {
  91.                 return $this->setStatusCode(WebService::HTTP_CODE_UNAUTHORIZED)
  92.                                 ->respondWithError('Invalid Id', WebService::CODE_COULD_NOT_AUTHENTICATE);
  93.             }
  95.             if ($accountLicData[0]->getAlAccountLicense()->getDeleted()) {
  96.                 return $this->setStatusCode(WebService::HTTP_CODE_UNAUTHORIZED)
  97.                                 ->respondWithError('Account is inactive', WebService::CODE_ACCOUNT_SUSPENDED);
  98.             }
  100.             if ($accountLicData[0]->getAlLicenseStatus() != AccountLicense::LICENSE_STATUS_ACTIVE) {
  101.                 return $this->setStatusCode(WebService::HTTP_CODE_UNAUTHORIZED)
  102.                                 ->respondWithError('License is inactive', WebService::CODE_ACCOUNT_SUSPENDED);
  103.             }
  105.             $clientOmt = $em->getRepository('App\Entity\OmtClient')->find($data['id']);
  107.             $nicknameClientSearch = ['username' => $data['username']];
  108.             $nicknameCliData = $em->getRepository('App\Entity\OmtClient')->findBy($nicknameClientSearch);
  110.             $responseArr['status'] = WebService::CODE_SUCCESS;
  111.             $responseArr['msg'] = 'Omt User update successfully!';
  112.             $responseArr['url'] = '';
  113.             if (!$clientOmt) {
  115.                 if ($nicknameCliData) {
  116.                     return $this->setStatusCode(WebService::HTTP_CODE_UNAUTHORIZED)
  117.                                     ->respondWithError('Username invalid', WebService::CODE_ACCOUNT_SUSPENDED);
  118.                 }
  120.                 $clientOmt = new OmtClient();
  121.                 $clientOmt->setId($data['id']);
  122.                 $responseArr['msg'] = 'Omt User created successfully!';
  123.             }
  125.             if ($nicknameCliData && $clientOmt->getId() != $nicknameCliData[0]->getId()) {
  126.                 return $this->setStatusCode(WebService::HTTP_CODE_UNAUTHORIZED)
  127.                                 ->respondWithError('Username  invalid', WebService::CODE_ACCOUNT_SUSPENDED);
  128.             }
  130.             if (!checkdnsrr($data['email'], "MX")) {
  131.                 return $this->setStatusCode(WebService::HTTP_CODE_BAD_REQUEST)
  132.                     ->respondWithError("The email ". $data['email'] ." is not a valid", WebService::HTTP_CODE_BAD_REQUEST);
  133.             }
  135.             $clientOmt->setName($data['name']);
  136.             $clientOmt->setLastname($data['lastname']);
  137.             $clientOmt->setEmail($data['email']);
  138.             $clientOmt->setUsername($data['username']);
  139.             $clientOmt->setBirthdate(new \DateTime($data['birthdate']));
  140.             $clientOmt->setPhone(Utilx::clearEspecialCharactersFromPhone($data['phone']));
  141.             $clientOmt->setLangCode($data['langCode']);
  142.             $em->persist($clientOmt);
  143.             $em->flush();
  146.             $theUrlTrSt = new LicensorGenericTransformer($this->realContainer, $responseArr);
  147.             $xxArray = $theUrlTrSt->transform();
  149.             $jsonContent = json_encode($xxArray);
  151.             return $this->respondWithItem($jsonContent, $theUrlTrSt);
  152.         }
  153.     }
  155.     /**
  156.      * @param \Symfony\Component\HttpFoundation\Request $request datos de la solicitud
  157.      * @return Response Json con la informacion de respuesta
  158.     */
  159.     public function createPointAccountRecord(Request $request) {
  161.         if ($request->getMethod() === WebService::REQUEST_METHOD_POST) {
  163.             $data = json_decode($request->getContent(), true);
  165.             if (strlen($data['omtClientId']) != 36) {
  166.                 return $this->setStatusCode(WebService::HTTP_CODE_UNAUTHORIZED)
  167.                                 ->respondWithError('Invalid omtClientId', WebService::CODE_COULD_NOT_AUTHENTICATE);
  168.             }
  170.             if (strlen($data['id']) != 36) {
  171.                 return $this->setStatusCode(WebService::HTTP_CODE_UNAUTHORIZED)
  172.                                 ->respondWithError('Invalid id', WebService::CODE_COULD_NOT_AUTHENTICATE);
  173.             }
  175.             $em = $this->getDoctrine()->getManager();
  177.             $pointAccountData = $em->getRepository('App\Entity\PointAcount')->find($data['id']);
  179.             $clientOmt = $em->getRepository('App\Entity\OmtClient')->find($data['omtClientId']);
  181.             if (!$clientOmt) {
  182.                 return $this->setStatusCode(WebService::HTTP_CODE_UNAUTHORIZED)
  183.                                 ->respondWithError('Omt client not found', WebService::CODE_COULD_NOT_AUTHENTICATE);
  184.             }
  186.             $clientPointSearch = ['omtClient' => $data['omtClientId']];
  187.             $clientPointAccount = $em->getRepository('App\Entity\PointAcount')->findBy($clientPointSearch);
  189.             $basePointSearch = ['basePointacount' => $data['basePointacount']];
  190.             $basePointAccount = $em->getRepository('App\Entity\PointAcount')->findBy($basePointSearch);
  191.             if ($basePointAccount && $basePointAccount[0]->getId() != $data['id']) {
  192.                 return $this->setStatusCode(WebService::HTTP_CODE_UNAUTHORIZED)
  193.                                 ->respondWithError('Invalid account token', WebService::CODE_COULD_NOT_AUTHENTICATE);
  194.             }
  195.             $responseArr['status'] = WebService::CODE_SUCCESS;
  196.             $responseArr['msg'] = 'Point account update successfully!';
  198.             if (!$pointAccountData) {
  199.                 $pointAccountData = new PointAcount();
  200.                 $pointAccountData->setId($data['id']);
  201.                 $responseArr['msg'] = 'Point account created successfully!';
  202.             }
  203.             
  204.             $pointAccountData->setOmtClient($clientOmt->getId());
  205.             $pointAccountData->setBasePointacount($data['basePointacount']);
  206.             $pointAccountData->setActivationDate(new \DateTime($data['activationDate']));
  207.             $em->persist($pointAccountData);
  208.             $em->flush();
  210.             if ($clientPointAccount) {
  211.                 $responseArr['msg'] .= ' User already has point account!';
  212.             }
  214.             $theUrlTrSt = new LicensorGenericTransformer($this->realContainer, $responseArr);
  215.             $xxArray = $theUrlTrSt->transform();
  217.             $jsonContent = json_encode($xxArray);
  219.             return $this->respondWithItem($jsonContent, $theUrlTrSt);
  220.         }
  221.     }
  223.     /**
  224.      * @param \Symfony\Component\HttpFoundation\Request $request datos de la solicitud
  225.      * @return Response Json con la informacion de respuesta
  226.     */
  227.     public function createTypePointAccountRecord(Request $request) {
  229.         if ($request->getMethod() === WebService::REQUEST_METHOD_POST) {
  231.             $data = json_decode($request->getContent(), true);
  233.             if (strlen($data['typePoinId']) != 36) {
  234.                 return $this->setStatusCode(WebService::HTTP_CODE_UNAUTHORIZED)
  235.                                 ->respondWithError('Invalid typePoinId', WebService::CODE_COULD_NOT_AUTHENTICATE);
  236.             }
  238.             if (strlen($data['pointAccountId']) != 36) {
  239.                 return $this->setStatusCode(WebService::HTTP_CODE_UNAUTHORIZED)
  240.                                 ->respondWithError('Invalid pointAccountId', WebService::CODE_COULD_NOT_AUTHENTICATE);
  241.             }
  243.             if (strlen($data['id']) != 36) {
  244.                 return $this->setStatusCode(WebService::HTTP_CODE_UNAUTHORIZED)
  245.                                 ->respondWithError('Invalid id', WebService::CODE_COULD_NOT_AUTHENTICATE);
  246.             }
  248.             $em = $this->getDoctrine()->getManager();
  250.             $typePointAccountData = $em->getRepository('App\Entity\TypePointAcount')->find($data['id']);
  252.             $accountTokenSearch = ['acountToken' => $data['accountToken']];
  253.             $accountTokenData = $em->getRepository('App\Entity\TypePointAcount')->findBy($accountTokenSearch);
  254.             if ($accountTokenData && $accountTokenData[0]->getId() != $data['id']) {
  255.                 return $this->setStatusCode(WebService::HTTP_CODE_UNAUTHORIZED)
  256.                                 ->respondWithError('Invalid acountToken', WebService::CODE_COULD_NOT_AUTHENTICATE);
  257.             }
  258.             $typePointData = $em->getRepository('App\Entity\TypePoint')->find($data['typePoinId']);
  260.             $countrySearch = ['coVal' => $data['countryCode']];
  261.             $countryData = $em->getRepository('App\Entity\Country')->findBy($countrySearch);
  262.             if ($countryData) {
  263.                 $countryData = $em->getRepository('App\Entity\Country')->find($countryData[0]->getCoId());
  264.             }
  266.             $pointAccountData = $em->getRepository('App\Entity\PointAcount')->find($data['pointAccountId']);
  268.             if (isset($pointAccountData) && $pointAccountData == []) {
  269.                 return $this->setStatusCode(WebService::HTTP_CODE_UNAUTHORIZED)
  270.                                 ->respondWithError('pointAccountId not found', WebService::CODE_COULD_NOT_AUTHENTICATE);
  271.             }
  273.             $responseArr['status'] = WebService::CODE_SUCCESS;
  274.             $responseArr['msg'] = 'Type Point account update successfully!';
  277.             if (!$typePointAccountData) {
  278.                 $typePointAccountData = new TypePointAcount();
  279.                 $typePointAccountData->setId($data['id']);
  280.                 $responseArr['msg'] = 'Type Point account created successfully!';
  281.             }
  283.             $typePointAccountData->setTypePoint($typePointData);
  284.             $typePointAccountData->setPointAcount($pointAccountData);
  285.             $typePointAccountData->setCountryId($countryData);
  286.             $typePointAccountData->setAmount($data['ptAmount']);
  287.             $typePointAccountData->setPointArmAcount($data['pointArmAccount']);
  288.             $typePointAccountData->setStartingDate(new \DateTime($data['startingDate']));
  289.             $typePointAccountData->setAcountToken($data['accountToken']);
  290.             $em->persist($typePointAccountData);
  291.             $em->flush();
  293.             $theUrlTrSt = new LicensorGenericTransformer($this->realContainer, $responseArr);
  294.             $xxArray = $theUrlTrSt->transform();
  296.             $jsonContent = json_encode($xxArray);
  298.             return $this->respondWithItem($jsonContent, $theUrlTrSt);
  299.         }
  300.     }
  302.     /**
  303.      * Obtener los puntos acumulados por clientes
  304.      * @param Request $request
  305.      * @return type
  306.     */
  307.     public function getPointAccountByClient(Request $request, ArmorService $armor, Log $log) {
  309.         if ($request->getMethod() === WebService::REQUEST_METHOD_GET) {
  311.             $em = $this->getDoctrine()->getManager();
  313.             $path = Util::getValidActiveLogByBaseName($this->realContainer, 'getPointAccountByClient', 'getPointAccountByClient0.txt');
  314.             $this->createFileJson($path, "\r" . 'Hello Points: ' . $request->getContent() . "\r");
  316.             $indexSearch = ['idClient', 'nickname'];
  318.             $search = Paginator::filterParameters($indexSearch, $request, Paginator::REQUEST_TYPE_REQUEST);
  319.             $order = Paginator::filterPaginatorParameters([], $request, true);
  321.             $log->createChannel('getPointAccountByClient');
  323.             if (!isset($search['nickname'])) {
  325.                 return $this->setStatusCode(WebService::HTTP_CODE_UNAUTHORIZED)->respondWithError('Invalid nickname', WebService::CODE_COULD_NOT_AUTHENTICATE);
  326.             
  327.             }
  329.             if (!isset($search['idClient'])) {
  331.                 return $this->setStatusCode(WebService::HTTP_CODE_UNAUTHORIZED)->respondWithError('Invalid idClient', WebService::CODE_COULD_NOT_AUTHENTICATE);
  332.             
  333.             }
  335.             if (strlen($search['idClient']) != 36) {
  337.                 return $this->setStatusCode(WebService::HTTP_CODE_UNAUTHORIZED)->respondWithError('Invalid idClient', WebService::CODE_COULD_NOT_AUTHENTICATE);
  338.            
  339.             }
  341.             $search['client'] = $search['idClient'];
  343.             if (isset($search['nickname'])) {
  345.                 $dataNicknameSearch = ['alLicenseUsername' => $search['nickname']];
  346.                 $accountLicByNicknameData = $em->getRepository('App\Entity\AccountLicense')->findBy($dataNicknameSearch);
  348.                 if (!isset($accountLicByNicknameData[0])) {
  349.                     
  350.                     return $this->setStatusCode(WebService::HTTP_CODE_UNAUTHORIZED)->respondWithError('Invalid nickname 2', WebService::CODE_COULD_NOT_AUTHENTICATE);
  351.                 
  352.                 } else {
  354.                     $search['restaurant'] = $accountLicByNicknameData[0];
  355.                 }
  357.             }
  359.             $loyaltyConfiguration = $em->getRepository('App\Entity\RestaurantLoyaltyConfiguration')->findBy(['license' => $accountLicByNicknameData[0]->getId()]);
  360.             
  361.             if (isset($loyaltyConfiguration[0]) && (!$loyaltyConfiguration[0]->getUseLocalPoints() && !$loyaltyConfiguration[0]->getUseGlobalPoints())) {
  362.                 
  363.                 $this->createFileJson($path, 'Loyalty functions not configured yet o.O' . "\r");
  364.                 
  365.                 return $this->setStatusCode(WebService::HTTP_CODE_UNAUTHORIZED)
  366.                                 ->respondWithError('Loyalty functions not configured yet', WebService::CODE_ACCOUNT_SUSPENDED);
  367.             } elseif (!isset($loyaltyConfiguration[0])) {
  368.                 
  369.                 $this->createFileJson($path, 'Loyalty functions configuration record not found o.O' . "\r");
  370.                 
  371.                 return $this->setStatusCode(WebService::HTTP_CODE_UNAUTHORIZED)
  372.                                 ->respondWithError('Loyalty functions configuration record not found!', WebService::CODE_ACCOUNT_SUSPENDED);
  373.             }
  375.             $pointAccountByClientRepository = $em->getRepository('App\Entity\TypePointAcount');
  376.             $pointAccountByClient = $pointAccountByClientRepository->findTypePointAccountByRestaurant($request, $this->realContainer, $search, $order, $loyaltyConfiguration[0]->getMinimumPointAmountToExchange(), $accountLicByNicknameData[0], $armor, $log, $path);
  378.             if (isset($pointAccountByClient['accounts'][0])) {
  380.                 $responseArr['msg'] = 'List of points by client';
  381.                 $responseArr['status'] = WebService::CODE_SUCCESS;
  382.                 $responseArr['client'] = $pointAccountByClient['accounts'][0];
  383.                 $responseArr['bigbag'] = true;
  385.             } else {
  387.                 $responseArr['msg'] = 'No client found with the given data';
  388.                 $responseArr['status'] = WebService::CODE_SUCCESS;
  390.             }
  392.             $theUrlTrSt = new LicensorGenericTransformer($this->realContainer, $responseArr);
  393.             
  394.             $xxArray = $theUrlTrSt->transform();
  395.             $jsonContent = json_encode($xxArray);
  397.             return $this->respondWithItem($jsonContent, $theUrlTrSt);
  398.         }
  399.     }
  401.     
  402.     /**
  403.     * funcion encargada de obtener los puntos de una orden en OMT
  404.     * @param Request $request
  405.     * @return array - se retorna arreglo con los puntos obtenidos
  406.     **/
  407.     public function getPointsByOrder(Request $request) {
  409.         if ($request->getMethod() === WebService::REQUEST_METHOD_POST) {
  411.             $em = $this->getDoctrine()->getManager();
  413.             $params = json_decode($request->getContent(), true);
  414.             $response_array = $data_response = [];
  416.             if (isset($params['order_id']) && $params['order_id']) {
  418.                 // Se obtienen los datos mediante el order_id
  419.                 $points_data = $em->getRepository('App\Entity\PointDeal')->findOneBy([ 'order' => $params['order_id'] ]);
  421.                 if ($points_data) {
  422.                     
  423.                     $data_response = [
  424.                         "earned" => $points_data->getDealPtsAmount()
  425.                     ];
  427.                 }
  429.                 // Respuesta
  430.                 $response_array['msg'] = 'List of points by order';
  431.                 $response_array['status'] = WebService::CODE_SUCCESS;
  432.                 $response_array['data'] = $data_response;
  433.                 $response_array['bigbag'] = true;
  435.             } else {
  437.                 $response_array['msg'] = 'Invalid Params';
  438.                 $response_array['status'] = WebService::CODE_WRONG_ARGUMENTS;
  439.                 $response_array['data'] = false;
  440.                 $response_array['bigbag'] = false;
  442.             }
  444.             $theUrlTrSt = new LicensorGenericTransformer($this->realContainer, $response_array);
  445.             $transform_fnc = $theUrlTrSt->transform();
  446.             $json_content_data = json_encode($transform_fnc);
  448.             return $this->respondWithItem($json_content_data, $theUrlTrSt);
  450.         } else {
  452.             $response_array['msg'] = 'METHOD '. $request->getMethod() .' NOT ALLOWED';
  453.             $response_array['status'] = WebService::CODE_NOT_ALLOWED_METHOD;
  454.             $response_array['data'] = null;
  455.             $response_array['false'] = false;
  457.             $theUrlTrSt = new LicensorGenericTransformer($this->realContainer, $response_array);
  458.             $transform_fnc = $theUrlTrSt->transform();
  459.             $json_content_data = json_encode($transform_fnc);
  461.             return $this->respondWithItem($json_content_data, $theUrlTrSt);
  463.         }
  464.     }
  466.     /**
  467.      * @param Request $request
  468.      * @return type
  469.      */
  470.     public function createPtsAdquiRedemRules(Request $request) {
  472.         if ($request->getMethod() === WebService::REQUEST_METHOD_POST) {
  474.             $data = json_decode($request->getContent(), true);
  476.             if (strlen($data['id']) != 36) {
  477.                 return $this->setStatusCode(WebService::HTTP_CODE_UNAUTHORIZED)
  478.                                 ->respondWithError('Invalid id', WebService::CODE_COULD_NOT_AUTHENTICATE);
  479.             }
  481.             $em = $this->getDoctrine()->getManager();
  483.             $nicknameDataSearch = ['alLicenseUsername' => $data['nickname']];
  484.             $accountLicData = $em->getRepository('App\Entity\AccountLicense')->findBy($nicknameDataSearch);
  486.             if (empty($accountLicData)) {
  487.                 return $this->setStatusCode(WebService::HTTP_CODE_UNAUTHORIZED)
  488.                                 ->respondWithError('Invalid nickname', WebService::CODE_COULD_NOT_AUTHENTICATE);
  489.             }
  491.             if ($accountLicData[0]->getDeviceUid() != $data['uid']) {
  492.                 $emLev = Util::emLicenseConnection($this->realContainer, $em, $accountLicData[0]);
  494.                 $registeredClientsByUID = $emLev->getRepository('App\Structure\Stations')->findBy(['staDeviceCode' => $data['uid']]);
  496.                 if (empty($registeredClientsByUID)) {
  497.                     $emLev->close();
  498.                     return $this->setStatusCode(WebService::HTTP_CODE_UNAUTHORIZED)
  499.                                     ->respondWithError('Unknown device', WebService::CODE_UNAUTHORIZED);
  500.                 } else {
  501.                     $emLev->close();
  502.                 }
  503.             }
  505.             $typePointData = $em->getRepository('App\Entity\TypePoint')->find($data['PointType']);
  507.             if (!$typePointData) {
  508.                 return $this->setStatusCode(WebService::HTTP_CODE_UNAUTHORIZED)
  509.                                 ->respondWithError('Invalid PointType', WebService::CODE_COULD_NOT_AUTHENTICATE);
  510.             }
  512.             $basicDefinitionData = $em->getRepository('App\Entity\TypePtsGenericDefinitionRules')->find($data['BasicDefinition']);
  514.             if (!$basicDefinitionData) {
  515.                 return $this->setStatusCode(WebService::HTTP_CODE_UNAUTHORIZED)
  516.                                 ->respondWithError('Invalid BasicDefinition', WebService::CODE_COULD_NOT_AUTHENTICATE);
  517.             }
  519.             $ptsAdquiRedemRulesData = $em->getRepository('App\Entity\PtsAdquiRedemRules')->find($data['id']);
  522.             $responseArr['status'] = WebService::CODE_SUCCESS;
  523.             $responseArr['msg'] = 'Pts Adqui Redem Rules  update successfully!';
  525.             if (!$ptsAdquiRedemRulesData) {
  526.                 $ptsAdquiRedemRulesData = new PtsAdquiRedemRules;
  527.                 $ptsAdquiRedemRulesData->setId($data['id']);
  529.                 $responseArr['msg'] = 'Pts Adqui Redem Rules created successfully!';
  530.             }
  532.             if ($data['minimumPurchase'] == "") {
  533.                 $data['minimumPurchase'] = null;
  534.             }
  536.             if ($data['QuantityPurchase'] == "") {
  537.                 $data['QuantityPurchase'] = null;
  538.             }
  540.             $ptsAdquiRedemRulesData->setName($data['Name']);
  541.             $ptsAdquiRedemRulesData->setPtsRate($data['PtsRate']);
  542.             $ptsAdquiRedemRulesData->setBasicDefinition($basicDefinitionData);
  543.             $ptsAdquiRedemRulesData->setPointType($typePointData);
  544.             $ptsAdquiRedemRulesData->setCreationDate(new \DateTime($data['CreationDate']));
  545.             $ptsAdquiRedemRulesData->setInitialActivationDate(new \DateTime($data['InitialActivationDate']));
  546.             $ptsAdquiRedemRulesData->setJustClaimOnce($data['JustClaimOnce']);
  547.             $ptsAdquiRedemRulesData->setApplyToSpecificRecord($data['ApplyToSpecificRecord']);
  548.             $ptsAdquiRedemRulesData->setWatchableObject($data['WatchableObject']);
  549.             $ptsAdquiRedemRulesData->setLicense($data['License']);
  550.             $ptsAdquiRedemRulesData->setMinimumPurchase($data['minimumPurchase']);
  551.             $ptsAdquiRedemRulesData->setMinimumQuantityPurchase($data['QuantityPurchase']);
  553.             $em->persist($ptsAdquiRedemRulesData);
  554.             $em->flush();
  556.             $theUrlTrSt = new LicensorGenericTransformer($this->realContainer, $responseArr);
  557.             $xxArray = $theUrlTrSt->transform();
  559.             $jsonContent = json_encode($xxArray);
  561.             return $this->respondWithItem($jsonContent, $theUrlTrSt);
  562.         }
  563.     }
  565.     /**
  566.      * @param Request $request
  567.      * @return type
  568.      */
  569.     public function listTypePoint(Request $request) {
  571.         if ($request->getMethod() === WebService::REQUEST_METHOD_GET) {
  573.             $em = $this->getDoctrine()->getManager();
  575.             $indexSearch = ['typePoint'];
  577.             $search = Paginator::filterParameters($indexSearch, $request, Paginator::REQUEST_TYPE_REQUEST);
  579.             if ($search) {
  580.                 $dataSearch = ['type' => $search['typePoint']];
  581.                 $typePointData = $em->getRepository('App\Entity\TypePoint')->findBy($dataSearch);
  582.             } else {
  583.                 $typePointData = $em->getRepository('App\Entity\TypePoint')->findAll();
  584.             }
  585.             $arrayTypePoint = [];
  586.             foreach ($typePointData as $datos) {
  587.                 $tpData = $datos->showEverything();
  588.                 array_push($arrayTypePoint, $tpData);
  589.             }
  590.             $responseArr['msg'] = 'List of points types';
  591.             $responseArr['status'] = WebService::CODE_SUCCESS;
  593.             $responseArr['listTypePoint'] = $arrayTypePoint;
  595.             $responseArr['bigbag'] = true;
  597.             $theUrlTrSt = new LicensorGenericTransformer($this->realContainer, $responseArr);
  598.             $xxArray = $theUrlTrSt->transform();
  600.             $jsonContent = json_encode($xxArray);
  601.             return $this->respondWithItem($jsonContent, $theUrlTrSt);
  602.         }
  603.     }
  605.     /**
  606.      * @param Request $request
  607.      * @return type
  608.      */
  609.     public function listTypePtsGenericRules(Request $request) {
  611.         if ($request->getMethod() === WebService::REQUEST_METHOD_GET) {
  613.             $em = $this->getDoctrine()->getManager();
  615.             $indexSearch = ['BasicType', 'Type'];
  617.             $search = Paginator::filterParameters($indexSearch, $request, Paginator::REQUEST_TYPE_REQUEST);
  619.             if (isset($search['BasicType']) && !isset($search['Type'])) {
  620.                 $dataSearch = ['basicType' => $search['BasicType']];
  621.                 $ptsGenericRule = $em->getRepository('App\Entity\TypePtsGenericDefinitionRules')->findBy($dataSearch);
  622.             }
  624.             if (isset($search['Type']) && !isset($search['BasicType'])) {
  625.                 $dataSearch = ['type' => $search['Type']];
  626.                 $ptsGenericRule = $em->getRepository('App\Entity\TypePtsGenericDefinitionRules')->findBy($dataSearch);
  627.             }
  629.             if (isset($search['Type']) && isset($search['BasicType'])) {
  630.                 $ptsGenericRule = $em->getRepository('App\Entity\TypePtsGenericDefinitionRules')->listPtsgenericDefinitionRules($search);
  631.             }
  633.             $arrayPtsGenericRule = [];
  634.             if (isset($ptsGenericRule)) {
  635.                 foreach ($ptsGenericRule as $datos) {
  636.                     if (is_object($datos)) {
  637.                         $pgrData = $datos->showEverything();
  638.                         array_push($arrayPtsGenericRule, $pgrData);
  639.                     } else {
  640.                         array_push($arrayPtsGenericRule, $datos);
  641.                     }
  642.                 }
  643.             }
  645.             $responseArr['msg'] = 'List of point types with generic rules';
  646.             $responseArr['status'] = WebService::CODE_SUCCESS;
  648.             $responseArr['listTypePoint'] = $arrayPtsGenericRule;
  650.             $responseArr['bigbag'] = true;
  652.             $theUrlTrSt = new LicensorGenericTransformer($this->realContainer, $responseArr);
  653.             $xxArray = $theUrlTrSt->transform();
  654.             $jsonContent = json_encode($xxArray);
  655.             return $this->respondWithItem($jsonContent, $theUrlTrSt);
  656.         }
  657.     }
  659.     /**
  660.      * @param Request $request
  661.      * @return type
  662.      */
  663.     public function listProductRestaurant(Request $request) {
  665.         if ($request->getMethod() === WebService::REQUEST_METHOD_GET) {
  667.             $em = $this->getDoctrine()->getManager();
  669.             $indexSearch = ['uid', 'nickname', 'type'];
  671.             $search = Paginator::filterParameters($indexSearch, $request, Paginator::REQUEST_TYPE_REQUEST);
  673.             if (!isset($search['uid'])) {
  674.                 return $this->errorWrongArgs('Uid undefined!', WebService::CODE_WRONG_ARGUMENTS);
  675.             }
  677.             if (!isset($search['nickname'])) {
  678.                 return $this->errorWrongArgs('Nickname undefined!', WebService::CODE_WRONG_ARGUMENTS);
  679.             }
  681.             if (!isset($search['type'])) {
  682.                 return $this->errorWrongArgs('type undefined!', WebService::CODE_WRONG_ARGUMENTS);
  683.             }
  685.             $dataSearch = ['alLicenseUsername' => $search['nickname']];
  686.             $accountLicByUidData = $em->getRepository('App\Entity\AccountLicense')->findBy($dataSearch);
  688.             if (!$accountLicByUidData) {
  689.                 return $this->setStatusCode(WebService::HTTP_CODE_UNAUTHORIZED)
  690.                                 ->respondWithError('Invalid Nickname', WebService::CODE_COULD_NOT_AUTHENTICATE);
  691.             }
  693.             if ($accountLicByUidData[0]->getAlAccountLicense()->getDeleted()) {
  694.                 return $this->setStatusCode(WebService::HTTP_CODE_UNAUTHORIZED)
  695.                                 ->respondWithError('Account is inactive', WebService::CODE_ACCOUNT_SUSPENDED);
  696.             }
  698.             if ($accountLicByUidData[0]->getAlLicenseStatus() != AccountLicense::LICENSE_STATUS_ACTIVE) {
  699.                 return $this->setStatusCode(WebService::HTTP_CODE_UNAUTHORIZED)
  700.                                 ->respondWithError('License is inactive', WebService::CODE_ACCOUNT_SUSPENDED);
  701.             }
  703.             if ($accountLicByUidData[0]->getDeviceUid() != $search['uid']) {
  704.                 $emLev = Util::emLicenseConnection($this->realContainer, $em, $accountLicByUidData[0]);
  706.                 $registeredClientsByUID = $emLev->getRepository('App\Structure\Stations')->findBy(['staDeviceCode' => $search['uid']]);
  708.                 if (empty($registeredClientsByUID)) {
  709.                     $emLev->close();
  710.                     return $this->setStatusCode(WebService::HTTP_CODE_UNAUTHORIZED)
  711.                                     ->respondWithError('Unknown device', WebService::CODE_UNAUTHORIZED);
  712.                 } else {
  713.                     $emLev->close();
  714.                 }
  715.             }
  717.             if ($search['type'] == "category" || $search['type'] == "product" || $search['type'] == "product_modifier_map") {
  718.                 $repository = Util::getStructureEntityDir($search['type']);
  719.             } else {
  720.                 return $this->setStatusCode(WebService::HTTP_CODE_UNAUTHORIZED)
  721.                                 ->respondWithError('Invalid type', WebService::CODE_COULD_NOT_AUTHENTICATE);
  722.             }
  724.             $arrayListCategory = [];
  726.             if (isset($repository)) {
  727.                 $auxLevEm = Util::emLicenseConnection($this->realContainer, $em, $accountLicByUidData[0]);
  728.                 $configuracionForAll = $auxLevEm->getRepository($repository)->findAll();
  730.                 foreach ($configuracionForAll as $datos) {
  731.                     if (is_object($datos)) {
  732.                         $pgrData = $datos->showEverything();
  733.                         array_push($arrayListCategory, $pgrData);
  734.                     } else {
  735.                         array_push($arrayListCategory, $datos);
  736.                     }
  737.                 }
  738.             }
  740.             if ($search['type'] == 'product_modifier_map') {
  741.                 $search['type'] = "'product modifier'";
  742.             } else if ($search['type'] == 'product') {
  743.                 $search['type'] = "'product'";
  744.             } else if ($search['type'] == 'category') {
  745.                 $search['type'] = "'category'";
  746.             }
  748.             $responseArr['msg'] = 'List of ' . $search['type'] . ' of the restaurant: ' . $accountLicByUidData[0]->getAlRestaurantName();
  750.             $responseArr['status'] = WebService::CODE_SUCCESS;
  752.             $responseArr['dataList'] = $arrayListCategory;
  754.             $responseArr['bigbag'] = true;
  756.             $theUrlTrSt = new LicensorGenericTransformer($this->realContainer, $responseArr);
  757.             $xxArray = $theUrlTrSt->transform();
  758.             $jsonContent = json_encode($xxArray);
  759.             return $this->respondWithItem($jsonContent, $theUrlTrSt);
  760.         }
  761.     }
  763.     /**
  764.      * @param Request $request
  765.      * @return type
  766.      */
  767.     public function pointDealTransition(Request $request) {
  769.         if ($request->getMethod() === WebService::REQUEST_METHOD_GET) {
  771.             $em = $this->getDoctrine()->getManager();
  773.             $indexSearch = ['idClient'];
  775.             $search = Paginator::filterParameters($indexSearch, $request, Paginator::REQUEST_TYPE_REQUEST);
  777.             if (isset($search['idClient'])) {
  779.                 $client = $em->getRepository('App\Entity\OmtClient')->find($search['idClient']);
  781.                 if (!$client) {
  782.                     return $this->setStatusCode(WebService::HTTP_CODE_UNAUTHORIZED)
  783.                                     ->respondWithError('Invalid id', WebService::CODE_COULD_NOT_AUTHENTICATE);
  784.                 }
  786.                 $responseArr['dataList']['id'] = $client->getId();
  787.                 $responseArr['dataList']['name'] = $client->getName();
  788.                 $responseArr['dataList']['lastname'] = $client->getLastname();
  789.                 $responseArr['dataList']['phone'] = $client->getPhone();
  791.             }
  793.             $listRules = $em->getRepository('App\Entity\PointDeal')->listOfPointDeal($search);
  795.             $responseArr['msg'] = 'List of rules';
  797.             $responseArr['status'] = WebService::CODE_SUCCESS;
  799.             $responseArr['dataList']['pointDeal'] = $listRules;
  801.             $responseArr['bigbag'] = true;
  803.             $theUrlTrSt = new LicensorGenericTransformer($this->realContainer, $responseArr);
  804.             $xxArray = $theUrlTrSt->transform();
  805.             $jsonContent = json_encode($xxArray);
  806.             return $this->respondWithItem($jsonContent, $theUrlTrSt);
  807.         }
  808.     }
  810.     /**
  811.      * WS generico para que el servidor andorid responda una pregunta realizada en un push
  812.      * @author Aealan Z <lrobledo@kijho.com> 15/06/16
  813.      * @param \Symfony\Component\HttpFoundation\Request $request datos de la solicitud
  814.      * @return Response Json con la informacion de respuesta
  815.      */
  816.     public function evaluateCustomerPurchaseForPointsOrElse(Request $request, ArmorService $armor, Log $log) {
  817.         
  818.         if ($request->getMethod() !== WebService::REQUEST_METHOD_POST && $request->getMethod() !== WebService::REQUEST_METHOD_OPTIONS) {
  819.             return $this->errorNotAllowedMethod('Method not allowed. Use ' . WebService::REQUEST_METHOD_POST . " method");
  820.         }
  821.         
  822.         if ($request->getMethod() === WebService::REQUEST_METHOD_OPTIONS) {
  823.             $responseArrayAux1['status'] = WebService::CODE_SUCCESS;
  824.             $responseArrayAux1['msg'] = 'OPTIONS detected, good to go!';
  826.             $theUrlTrSt = new LicensorGenericTransformer($this->realContainer, $responseArrayAux1);
  827.             $jsonTransform = $theUrlTrSt->transform();
  829.             $jsonContent = json_encode($jsonTransform);
  831.             return $this->respondWithItem($jsonContent, $theUrlTrSt);
  832.         }
  834.         if (0 == !strpos($request->headers->get('Content-Type'), WebService::CONTENT_TYPE_TEXT) && 0 == !strpos($request->headers->get('Content-Type'), WebService::CONTENT_TYPE_STRUCTURE)) {
  835.             return $this->errorWrongArgs('Wrong content', WebService::CODE_WRONG_ARGUMENTS);
  836.         }
  838.         $path = Util::getValidActiveLogByBaseName($this->realContainer, 'evaluateCustomerPurchaseForPointsOrElse', 'evaluateCustomerPurchaseForPointsOrElse0.txt');
  839.         $this->createFileJson($path, "\r" . 'Hello Points: ' . $request->getContent() . "\r");
  841.         // try {
  843.             $arrayEncryptResult = Util::decryptDataForAndroid($this->realContainer, $request->getContent());
  844.             $params = json_decode($arrayEncryptResult['data'], true);
  846.             $this->createFileJson($path, 'Decode params: ' . $arrayEncryptResult['data'] . "\r");
  848.             $customerId="";
  849.             $flagAndroid = false;
  851.             if(isset($params['requestFrom'])){
  853.                 if (!isset($params['nickname']) || !isset($params['dealType']) || !isset($params['omtCustomerId']) || !isset($params['totalAmount'])) {
  855.                     $this->createFileJson($path, "\r" . 'Wrong arguments!' . WebService::CODE_WRONG_ARGUMENTS . "\r");
  856.                     return $this->errorWrongArgs('Wrong arguments!', WebService::CODE_WRONG_ARGUMENTS);
  858.                 } else {
  860.                     $customerId = $params['omtCustomerId'];
  861.                 }
  863.             } elseif (!isset($params['nickname']) || !isset($params['uid']) || !isset($params['dealType']) || !isset($params['customerId']) || !isset($params['totalAmount'])) {
  865.                 $this->createFileJson($path, "\r" . 'Wrong arguments!' . WebService::CODE_WRONG_ARGUMENTS . "\r");
  866.                 return $this->errorWrongArgs('Wrong arguments!', WebService::CODE_WRONG_ARGUMENTS);
  868.             } else {
  869.                 $customerId = $params['customerId'];
  870.                 $flagAndroid = true;
  871.             }
  873.             $em = $this->getDoctrine()->getManager();
  875.             $data = ['alLicenseUsername' => $params['nickname']];
  877.             $accountLicenseData = $em->getRepository('App\Entity\AccountLicense')->findByAlLicenseUsername($data);
  878.             $countResult = count($accountLicenseData);
  880.             $validate = $this->validateLicense($countResult, $path, $accountLicenseData);
  882.             if (!$validate["status"]) {
  884.                 $this->createFileJson($path, 'licencia no eliminada logicamente' . "\r");
  886.                 return $this->setStatusCode($validate["status"])->respondWithError($validate["message"], $validate["code"]);
  888.             }
  891.             $clientReposiroty = $em->getRepository('App\Entity\OmtClient');
  893.             if($flagAndroid){
  895.                 $this->createFileJson($path, "\r" . 'Request Android' . "\r");
  897.                 if ($accountLicenseData[0]->getDeviceUid() != $params['uid']) {
  899.                     $emLev = Util::emLicenseConnection($this->realContainer, $em, $accountLicenseData[0]);
  900.                     
  901.                     $registeredClientsByUID = $emLev->getRepository('App\Structure\Stations')->findBy(['staDeviceCode' => $params['uid']]);
  902.                     
  903.                     if (empty($registeredClientsByUID)) {
  905.                         $emLev->close();
  907.                         $this->createFileJson($path, 'UID diferente! o.O' . "\r");
  909.                         return $this->setStatusCode(WebService::HTTP_CODE_UNAUTHORIZED)->respondWithError('Unknown device', WebService::CODE_UNAUTHORIZED);
  910.                     
  911.                     } else {
  913.                         $emLev->close();
  914.                     }
  915.                 }
  916.                 
  917.                 $clientToGetPoint = $clientReposiroty->find($customerId);
  919.             }else{
  920.                 $clientToGetPoint = $clientReposiroty->findOneBy(["omtUserId"=>$customerId]);
  921.                 $params['customerId'] = !is_null($clientToGetPoint) && is_object($clientToGetPoint) ? $clientToGetPoint->getId() : null;
  922.             }
  923.             
  924.             if (!$clientToGetPoint) {
  925.                 $this->createFileJson($path, 'Unknown customer' . WebService::CODE_ACCOUNT_SUSPENDED . "\r");
  926.                 
  927.                 return $this->setStatusCode(WebService::HTTP_CODE_UNAUTHORIZED)
  928.                                 ->respondWithError('Unknown customer', WebService::CODE_ACCOUNT_SUSPENDED);
  929.             }
  930.             
  931.             $log->createChannel('gift_card');
  933.             $armorPack = [
  934.                 'request' => $request,
  935.                 'service' => $armor,
  936.                 'log' => $log
  937.             ];
  939.             if (isset($params['debug']) && $params['debug']) {
  940.                 dump("Parametros de entrada",$params);
  941.             }
  943.             if ($params['totalAmount'] > 0) {
  945.                 if (isset($params['debug']) && $params['debug']) {
  947.                     dump('Total amount', $params['totalAmount']);
  949.                 }
  950.                 
  951.                 $this->createFileJson($path, 'Points evaluation' . "\r");
  953.                 $pointEvaluationResult = PointsUtilPorcessor::analyzePointTransaction($this->realContainer, $em, $accountLicenseData[0], $params, $armorPack);
  954.             
  955.                 if (isset($params['debug']) && $params['debug']) {
  957.                     dump("Point evaluation result", $pointEvaluationResult);
  959.                 }
  960.                 
  962.                 if (empty($pointEvaluationResult) && isset($params['omtCustomerId'])) {
  964.                     $this->createFileJson($path, 'create automatic' . "\r");
  966.                     $typePointAccountData = $this->saveNewTypePointAccount($em, $clientToGetPoint,$params, $path);
  967.                     
  968.                     $aux = ($typePointAccountData instanceof TypePointAcount) ? 'YES' : 'NO';
  969.                     $this->createFileJson($path, '$typePointAccountData is TypePointAcount ' .$aux. "\r");
  970.                     
  971.                     $aux = gettype($typePointAccountData);
  972.                     $this->createFileJson($path, '$typePointAccountData is ' .$aux. "\r");
  974.                      //  save on armor 
  975.                     if (isset($params['debug']) && $params['debug']) {
  976.                         dump("Create typePointAccount", $typePointAccountData);die;
  977.                     }
  979.                     if ($typePointAccountData instanceof TypePointAcount){
  981.                         $arrayTypePointAccountTokenToArmor = PointsUtilPorcessor::createArrayForPostPutArmorPointRequest($typePointAccountData, $typePointAccountData->getAmount(), $path);
  982.                         $encodeBase = Encryptor::encodeInfo(json_encode($arrayTypePointAccountTokenToArmor));
  983.                         
  984.                         $request = $armor->duplicateRequestWithOverwritedContentForArmorServer($request, ['token' => $encodeBase]);
  985.                         $pointEvaluationResult = PointsUtilPorcessor::analyzePointTransaction($this->realContainer, $em, $accountLicenseData[0], $params, $armorPack);
  986.                     }
  987.                 }
  989.             } else {
  991.                 if (isset($params['debug']) && $params['debug']) {
  992.                     dump('No es mayor que 0? o.O!');
  993.                     dump($params['totalAmount'] > 0);
  994.                 }
  996.                 $pointEvaluationResult = [];
  997.             }
  999.             $responseArrayAux1['status'] = WebService::CODE_SUCCESS;
  1000.             $responseArrayAux1['msg'] = 'Point transactions processed successfully!';
  1001.             $responseArrayAux1['bigbag'] = true;
  1003.             $responseArrayAux2 = $this->processEvaluatedTransactionResponse($pointEvaluationResult, $params);  
  1005.             $responseArray = array_merge($responseArrayAux1, $responseArrayAux2);
  1007.             if (isset($params['debug']) && $params['debug']) {
  1008.                 dump("Response",$responseArray);die;
  1009.             }
  1011.             $theUrlTrSt = new LicensorGenericTransformer($this->realContainer, $responseArray);
  1012.             $jsonTransform = $theUrlTrSt->transform();
  1013.             
  1014.             $jsonContent = json_encode($jsonTransform);
  1015.             
  1016.             $this->createFileJson($path, 'Response' .$jsonContent. "\r");
  1018.             return $this->respondWithItem($jsonContent, $theUrlTrSt);
  1020.         // } catch (\Throwable $th) {
  1021.         //     $err = json_encode(['Error Message' => $th->getMessage(), 'Error Line' => $th->getLine(), 'Error File' => $th->getFile(), 'Error Trace' => $th->getTrace()]);
  1022.         //     $this->createFileJson($path, "\r Alert Error => $err \r");
  1024.         //     return $this->setStatusCode(WebService::HTTP_CODE_INTERNAL_ERROR)->respondWithError($err, WebService::HTTP_CODE_INTERNAL_ERROR);
  1025.         // }
  1026.     }
  1028.     /**
  1029.      * @param type $em
  1030.      * @param type $userTypePointAccount
  1031.      */
  1032.     public function markAsNoOtherTransactionInProgress($em, $userTypePointAccount) {
  1034.         $userTypePointAccount = $em->getRepository('App\Entity\PointAcount')->find($userTypePointAccount->getId());
  1035.         $userTypePointAccount->setIsBlockedByOtherTransaction(false);
  1037.         $em->persist($userTypePointAccount);
  1038.         $em->flush();
  1040.     }
  1042.     /**
  1043.      * @param type $em
  1044.      * @param type $userTypePointAccount
  1045.      * @return type
  1046.      */
  1047.     public function vaidateIfAnotherTransactionIsInProgress($em, $userTypePointAccount, $params) {
  1049.         if (!isset($userTypePointAccount[0])) {
  1051.             return 'No point account found for customer!';
  1053.         } else {
  1054.             $userTypePointAccount = $userTypePointAccount[0];
  1055.         }
  1057.         if ($userTypePointAccount->getIsBlockedByOtherTransaction()) {
  1058.             $responseArray['status'] = WebService::CODE_SUCCESS;
  1059.             $responseArray['msg'] = '';
  1061.             $processedArrayResponse = $this->processEvaluatedTransactionResponse('other point transaction is being processed for this account, please wait a few minutes..', $params);
  1063.             $responseArray = array_merge($responseArray, $processedArrayResponse);
  1065.             return $responseArray;
  1067.         } else {
  1069.             $userTypePointAccount->setIsBlockedByOtherTransaction(true);
  1071.             $em->persist($userTypePointAccount);
  1072.             $em->flush();
  1073.         }
  1075.         return $userTypePointAccount;
  1076.     }
  1078.     /**
  1079.      * @param PointRelatedRequest $pointCreatedResult
  1080.      * @return type
  1081.      */
  1082.     public function startAllTheCommandToRabbitTransactionProcess($pointCreatedResult, $path) {
  1084.         if ($pointCreatedResult instanceof PointRelatedRequest) {
  1086.             $kernel = $this->get('real_kernel');
  1087.             $application = new Application($kernel);
  1088.             $application->setAutoExit(false);
  1090.             $input = new ArrayInput([
  1091.                 'command' => 'level:duce:point_transaction',
  1092.                 'pointRequestId' => $pointCreatedResult->getId()
  1093.             ]);
  1095.             // You can use NullOutput() if you don't need the output
  1096.             $output = new BufferedOutput();
  1097.             $application->run($input, $output);
  1099.             // return the output, don't use if you used NullOutput()
  1100.             $content = $output->fetch();
  1102.             $this->createFileJson($path, 'Producer command response: ' . $content . "\r");
  1104.             sleep(1);
  1106.             $input2 = new ArrayInput([
  1107.                 'command' => 'level:nsume:point_transaction',
  1108.                 'pointRequestId' => $pointCreatedResult->getId()
  1109.             ]);
  1111.             // You can use NullOutput() if you don't need the output
  1112.             $output2 = new BufferedOutput();
  1113.             $application->run($input2, $output2);
  1115.             // return the output, don't use if you used NullOutput()
  1116.             $content2 = $output->fetch();
  1118.             $this->createFileJson($path, 'Consumer command response: ' . $content2 . "\r");
  1120.         } else {
  1122.             return $pointCreatedResult;
  1124.         }
  1126.         return true;
  1127.     }
  1129.     /**
  1130.      * @param type $em
  1131.      * @param type $theTransactionToCheck
  1132.      * @param type $path
  1133.      * @return boolean
  1134.      */
  1135.     public function pollingAskingIfPointTransactionWasProcessed($em, $theTransactionToCheck, $path) {
  1137.         $responseToPolling = [];
  1139.         $auxCounter = 0;
  1140.         $keepInWhile = true;
  1142.         $this->createFileJson($path, 'Checking if point transaction was concluded....' . "\r");
  1143.         $this->createFileJson($path, 'Checking -> ' . $theTransactionToCheck->getId() . "\r");
  1145.         do {
  1147.             sleep(4);
  1149.             ++$auxCounter;
  1150.             $theTransactionToCheck = $em->getRepository('App\Entity\PointRelatedRequest')->find($theTransactionToCheck->getId());
  1151.             $responseToPolling['theTransaction'] = $theTransactionToCheck;
  1153.             if ($theTransactionToCheck->getStatus() == RabbitRelatedGenericEntity::STATUS_PROCCESSED) {
  1155.                 $keepInWhile = false;
  1156.                 $responseToPolling['msg'] = 'Transaction processed.. going forward whith the delivery!';
  1157.                 $this->createFileJson($path, 'Transaction processed.. going forward whith the delivery!' . "\r");
  1158.                 
  1159.                 $responseToPolling['wasProcessed'] = true;
  1161.             } elseif ($auxCounter > 7) {
  1163.                 $keepInWhile = false;
  1165.                 if ($theTransactionToCheck->getStatus() < RabbitRelatedGenericEntity::STATUS_PROCCESSED) {
  1167.                     $responseToPolling['msg'] = 'Maximum waiting reached for a processed point transaction, aborting!';
  1168.                     $this->createFileJson($path, 'Maximum waiting reached for a processed point transaction, aborting!' . "\r");
  1169.                     $responseToPolling['wasProcessed'] = false;
  1171.                 }
  1173.             } else {
  1174.                 
  1175.                 $responseToPolling['msg'] = 'Waiting for transaction to be processed..';
  1176.                 $responseToPolling['wasProcessed'] = false;
  1178.                 $this->createFileJson($path, "$auxCounter try, asking again..." . "\r");
  1180.             }
  1182.         } while ($keepInWhile);
  1184.         return $responseToPolling;
  1185.     }
  1187.     /**
  1188.      * @param \Symfony\Component\HttpFoundation\Request $request datos de la solicitud
  1189.      * @return Response Json con la informacion de respuesta
  1190.      */
  1191.     public function createOmtClientAndPointsAccountsRecord(Request $request, ArmorService $armor, Log $log) { 
  1193.         if (0 !== strpos($request->headers->get('Content-Type'), WebService::CONTENT_TYPE_TEXT)) {
  1194.             if (0 !== strpos($request->headers->get('Content-Type'), WebService::CONTENT_TYPE_STRUCTURE)) {
  1195.                 return $this->errorWrongArgs('Wrong content');
  1196.             }
  1197.         }
  1199.         $path = Util::getValidActiveLogByBaseName($this->realContainer, 'omtClientAndPointsAccountsRecord', 'omtClientAndPointsAccountsRecord0.txt');
  1200.         $this->createFileJson($path, "\r" . 'omtClient Ask: ' . $request->getContent() . "\r");
  1202.         $arrayEncryptResult = Util::decryptDataForAndroid($this->realContainer, $request->getContent());
  1203.         $params = json_decode($arrayEncryptResult['data'], true);
  1205.         $this->createFileJson($path, 'Push Responded decode params: ' . $arrayEncryptResult['data'] . "\r");
  1207.         if (!isset($params['nickname']) || !isset($params['uid']) || !isset($params['countryCode'])) {
  1208.             $this->createFileJson($path, 'posiblement falte parametro nickname, uid o countryCode' . "\r");
  1209.             return $this->errorWrongArgs('Wrong Arguments');
  1210.         }
  1212.         $em = $this->getDoctrine()->getManager();
  1214.         $countryData = $em->getRepository('App\Entity\Country')->findBy(['coVal' => $params['countryCode']]);
  1215.         
  1216.         if (!isset($countryData[0])) {
  1217.             $this->createFileJson($path, 'Contry code not found!' . "\r");
  1218.             return $this->setStatusCode(WebService::HTTP_CODE_UNAUTHORIZED)
  1219.                             ->respondWithError('Contry code not found!', WebService::CODE_ACCOUNT_SUSPENDED);
  1220.         } else {
  1221.             $this->createFileJson($path, 'Contry code exist!' . "\r");
  1222.             $countryData = $countryData[0];
  1223.         }
  1225.         $data = ['alLicenseUsername' => $params['nickname']];
  1226.         $accountLicenseData = $em->getRepository('App\Entity\AccountLicense')->findByAlLicenseUsername($data);
  1227.         $countResult = count($accountLicenseData);
  1229.         $this->createFileJson($path, 'busqueda del restaurante por nickname' . "\r");
  1231.         $validate = $this->validateLicense($countResult, $path, $accountLicenseData);
  1233.         if(!$validate["status"]) {
  1234.             
  1235.             $this->createFileJson($path, 'licencia no eliminada logicamente' . "\r");
  1237.             return $this->setStatusCode($validate["status"])
  1238.                             ->respondWithError($validate["message"], $validate["code"]);
  1239.         }
  1243.         $this->createFileJson($path, 'licencia activa' . "\r");
  1245.         if ($accountLicenseData[0]->getDeviceUid() != $params['uid']) {
  1247.             $emLev = Util::emLicenseConnection($this->realContainer, $em, $accountLicenseData[0]);
  1249.             $registeredClientsByUID = $emLev->getRepository('App\Structure\Stations')->findBy(['staDeviceCode' => $params['uid']]);
  1251.             if (empty($registeredClientsByUID)) {
  1253.                 $emLev->close();
  1255.                 $this->createFileJson($path, 'UID diferente! o.O' . "\r");
  1257.                 return $this->setStatusCode(WebService::HTTP_CODE_UNAUTHORIZED)
  1258.                                 ->respondWithError('Unknown device', WebService::CODE_UNAUTHORIZED);
  1259.             
  1260.             } else {
  1261.                 $emLev->close();
  1262.             }
  1263.         }
  1265.         if(isset($params['phone'])){
  1267.             $this->createFileJson($path, 'special characters removed in phone' . "\r");
  1269.             $tmpPhoneClient = preg_replace('/[^0-9]/', "", $params['phone']);
  1270.             $tmpPhoneClient = Utilx::clearEspecialCharactersFromPhone($tmpPhoneClient);
  1271.             $this->createFileJson($path, 'before ' .$params['phone']. ' ,after '.$tmpPhoneClient. "\r");
  1272.             
  1273.             $params['phone'] = $tmpPhoneClient;
  1274.         }
  1276.         $this->createFileJson($path, 'validacion metodo put' . "\r");
  1278.         if ($request->getMethod() === WebService::REQUEST_METHOD_PUT) {
  1279.             $params['alLicenseUsername'] = $params['nickname'];
  1281.             return $this->updateDataOmtClient($params, $path);
  1282.         }
  1284.         $this->createFileJson($path, 'ya termino... sigue ..' . "\r");
  1286.         if ($request->getMethod() !== WebService::REQUEST_METHOD_POST) {
  1287.             return $this->errorNotAllowedMethod('Method not allowed. Use ' . WebService::REQUEST_METHOD_POST . " method");
  1288.         }
  1290.         $uniqueValidationArray = [];
  1292.         $this->createFileJson($path, 'consulta en RestaurantLoyaltyConfiguration' . "\r");
  1294.         $loyaltyConfiguration = $em->getRepository('App\Entity\RestaurantLoyaltyConfiguration')->findOneBy(['license' => $accountLicenseData[0]->getId()]);
  1295.         
  1296.         if (is_null($loyaltyConfiguration)) {
  1298.             $loyaltyConfiguration = new RestaurantLoyaltyConfiguration();
  1300.             $loyaltyConfiguration->setDateCreated(new \DateTime('now'));
  1301.             $loyaltyConfiguration->setUseLocalPoints(false);
  1302.             $loyaltyConfiguration->setUseGlobalPoints(false);
  1303.             $loyaltyConfiguration->setMinimumPointAmountToExchange(1);
  1304.             $loyaltyConfiguration->setLicense($accountLicenseData[0]);
  1306.             $em->persist($loyaltyConfiguration);
  1307.             $em->flush();
  1309.         }
  1311.         $this->createFileJson($path, 'Entering into the pit...1 o.O!' . "\r");
  1313.         if (isset($params['lastFour'])) {
  1315.             $requiredFields = [
  1316.                 "nameOnCard",
  1317.                 "franchise",
  1318.                 "lastFour"
  1319.             ];
  1321.             $fieldValidations = $this->validateParams($request, $requiredFields);
  1322.             $params = $this->getContentInRequest($request);
  1324.             if(isset($params['phone'])){
  1326.                 $this->createFileJson($path, 'special characters removed ' . "\r");
  1327.     
  1328.                 $tmpPhoneClient = preg_replace('/[^0-9]/', "", $params['phone']);
  1329.                 $tmpPhoneClient = Utilx::clearEspecialCharactersFromPhone($tmpPhoneClient);
  1330.                 $this->createFileJson($path, 'before ' .$params['phone']. ' ,after '.$tmpPhoneClient. "\r");
  1331.                 
  1332.                 $params['phone'] = $tmpPhoneClient;
  1334.             }
  1335.             
  1336.             // Validamos que se envien lios campos requeridos
  1337.             if ($fieldValidations !== true) {
  1338.                 return $this->setStatusCode(WebService::HTTP_CODE_BAD_REQUEST)
  1339.                 ->respondWithError($fieldValidations, WebService::CODE_WRONG_ARGUMENTS);
  1340.             }
  1342.             $perhapsUniqueUserName = str_replace(' ', '_', strtolower(explode(' ', $params['nameOnCard'])[0] . '_' . $params['franchise'] . '_' . $params['lastFour']));
  1344.             $uniqueValidationArray = ['username'];
  1345.             $params['username'] = $perhapsUniqueUserName;
  1347.         } else {
  1349.             $requiredFields = [
  1350.                 "phone"
  1351.             ];
  1353.             $fieldValidations = $this->validateParams($request, $requiredFields);
  1354.             $params = $this->getContentInRequest($request);
  1356.             if(isset($params['phone'])){
  1358.                 $this->createFileJson($path, 'special characters removed ' . "\r");
  1359.     
  1360.                 $tmpPhoneClient = preg_replace('/[^0-9]/', "", $params['phone']);
  1361.                 $tmpPhoneClient = Utilx::clearEspecialCharactersFromPhone($tmpPhoneClient);
  1362.                 $this->createFileJson($path, 'before ' .$params['phone']. ' ,after '.$tmpPhoneClient. "\r");
  1363.                 
  1364.                 $params['phone'] = $tmpPhoneClient;
  1365.             }
  1367.             /**
  1368.              * Validamos que se envien lios campos requeridos
  1369.              */
  1370.             if ($fieldValidations !== true) {
  1371.                 return $this->setStatusCode(WebService::HTTP_CODE_BAD_REQUEST)
  1372.                                 ->respondWithError($fieldValidations
  1373.                                         , WebService::CODE_WRONG_ARGUMENTS);
  1374.             }
  1376.             $uniqueValidationArray = ['username', 'email', 'phone'];
  1378.             if (!isset($params['username'])) {
  1380.                 if (isset($params['name'])) {
  1382.                     // se reemplaza los espacios en blanco del nombre por guion bajo
  1383.                     $usernamesufix = str_replace(' ', '_', $params['name']) . '_' . Utilx::randomPassword(3);
  1384.                 
  1385.                 } else {
  1386.                     $usernamesufix = 'NoName_' . Utilx::randomPassword(5);
  1387.                 }
  1389.                 $params['username'] = $usernamesufix;
  1390.             }
  1391.         }
  1393.         $this->createFileJson($path, 'Entering into the pit...2 o.O!' . "\r");
  1395.         $clientController = new ClientController($this->realContainer);
  1396.     
  1397.         $nickUsername = Utilx::replaceCharactersEspecials($params['name']);
  1398.         $nickUsername = strtolower(substr($nickUsername, 0, 8) . '_');
  1400.         $repositoryClients = $em->getRepository('App\Entity\OmtClient');
  1401.         $countClients = $repositoryClients->counting();
  1402.         $this->createFileJson($path, 'number of OMTClient records ' .$countClients. "\r");
  1404.         $nickUsername .= uniqid() ."_". $countClients;
  1406.         $lastParamsNotSend = $params;
  1408.         if (!isset($params['lastname']) || $params['lastname'] == '') {
  1409.             $params['lastname'] = "(temporal lastname)";
  1410.         }
  1412.         if (!isset($params['username']) || $params['username'] == '') {
  1413.             $params['username'] = $nickUsername;
  1414.         }
  1416.         if (!isset($params['email']) || $params['email'] == '') {
  1417.             $email = NewUtil::generateEmailGeneric($params['name'], $repositoryClients, $path);
  1418.             // $nickUsername . "@gmail.com";
  1419.             $params['email'] = $email; 
  1420.             $lastParamsNotSend['email'] = $email;
  1421.         }
  1422.         
  1423.         unset($params['uid'], $params['countryCode']);
  1424.         
  1425.         if (isset($params['clientId'])) {
  1426.             $auxOmtClient = $em->getRepository('App\Entity\OmtClient')->find($params['clientId']);
  1427.             if($auxOmtClient && $auxOmtClient->getOmtUserId()){
  1428.                 $params['omtClientId'] = $auxOmtClient->getOmtUserId();
  1429.             }
  1430.         }
  1432.         // debido a que dos funciones que crean usuario loyalty se agregan parametros para que haya igualdad en el body de ambos webservices
  1433.         $params['alLicenseUsername'] = $params['nickname'];
  1434.         $params['companyName'] = 'omt';
  1435.         $params['phone_2'] = '';
  1436.         $params['fromLicensor'] = true;
  1438.         unset($params['clientId']);
  1439.         unset($params['nickname']);
  1440.         unset($params['langCode']);
  1442.         // se valida que el teléfono y el email no este utilizados por un cliente en OMTWS
  1443.         $this->createFileJson($path, "\r" . 'parameters to send to isPhoneAndEmailUsingAtOMT => ' . json_encode(['phone' => $params['phone'], 'email' => $params['email']]) . "\r");
  1444.         $tmpValidOMT = $clientController->isPhoneAndEmailUsingAtOMT($this->realContainer, $params['phone'], $params['email']);
  1445.         $this->createFileJson($path, "\r" . 'isPhoneAndEmailUsingAtOMT => ' . json_encode($tmpValidOMT) . "\r");
  1447.         if (isset($tmpValidOMT['data']['message'])){
  1448.             return $this->setStatusCode(WebService::HTTP_CODE_UNAUTHORIZED)
  1449.                         ->respondWithError($tmpValidOMT['data']['message'], WebService::CODE_COULD_NOT_AUTHENTICATE);
  1450.         }
  1452.         // se envia la peticion para crear el usuario a OMTWS
  1453.         $responseCreationUserOmt = $clientController->createNewUserLoyaltyInOmtWsFromAndroid($this->realContainer, $params);
  1454.         
  1455.         $this->createFileJson($path, 'Creation from omtws, response => '. json_encode($responseCreationUserOmt) . "\r");
  1457.         $existErrorCreationUserOmt = $clientController->existErrorsWhenCreateUserLoyaltyInOmtWs($responseCreationUserOmt);
  1458.         
  1459.         if (isset($existErrorCreationUserOmt['error']) && $existErrorCreationUserOmt['error']){
  1460.             return $this->setStatusCode(WebService::HTTP_CODE_BAD_REQUEST)
  1461.             ->respondWithError($existErrorCreationUserOmt['message'], WebService::HTTP_CODE_BAD_REQUEST);
  1462.         }
  1464.         $params = $lastParamsNotSend;
  1466.         $clientOmt = null;
  1467.         $omtClientRepo = $em->getRepository('App\Entity\OmtClient');
  1469.         $clientToUpdateDirect = null;
  1471.         if (isset($params['clientId'])) {
  1472.             $clientToUpdateDirect = $omtClientRepo->find($params['clientId']);
  1473.         }
  1475.         if (is_null($clientToUpdateDirect) && isset($params['email']) && $params['email'] != '') {
  1476.             $clientToUpdateDirect = $omtClientRepo->findOneBy(['email' => $params['email']]);
  1477.         }
  1479.         $this->createFileJson($path, 'Entering into the pit...3 o.O!' . "\r");
  1481.         $nicknameCliData = null;
  1483.         foreach ($uniqueValidationArray as $uniqueFieldToValidate) {
  1485.             if (isset($params[$uniqueFieldToValidate])) {
  1487.                 $nicknameClientSearch = [$uniqueFieldToValidate => $params[$uniqueFieldToValidate]];
  1488.                 $nicknameCliData = $omtClientRepo->findBy($nicknameClientSearch);
  1490.                 $this->createFileJson($path, 'checking if user exists ' .json_encode($nicknameClientSearch). "\r");
  1492.                 if (isset($nicknameCliData[0])) {
  1494.                     $clientOmt = $nicknameCliData[0];
  1495.                     $this->createFileJson($path, 'yes, the customer exists with the ID '. $clientOmt->getId().' ' .$clientOmt. "\r");
  1496.                     break;
  1497.                 }
  1498.             }
  1499.         }
  1501.         $unexpectedEditFlag = false;
  1503.         /**
  1504.          * Esta condicion permite validar si el cliente que va a ser creado 
  1505.          * tiene el  email y el telefono valido lo deja crear de lo contrario
  1506.          * le retorna un mensaje con su respectivo error
  1507.          */
  1508.         if ((!isset($params['clientId']) || (isset($params['clientId']) && $params['clientId'] == "" ) ) && ((isset($params['email']) && $params['email'] !== null && $params['email'] !== "") || (isset($params['phone']) && $params['phone'] !== null && $params['phone'] !== ""))) {
  1510.             if (isset($params['email'])) {
  1511.                 $existClientByEmail = $omtClientRepo->findBy(['email' => $params['email']]);
  1512.             }
  1514.             if (isset($params['phone'])) {
  1515.                 $existClientByPhone = $omtClientRepo->findBy(['phone' => $params['phone']]);
  1516.             }
  1517.             
  1518.             if (isset($existClientByEmail[0]) && $existClientByEmail[0]->getLastname() == 'Default GiftCard Customer') {
  1519.                 $this->createFileJson($path, 'Invalid email' . "\r");
  1520.                 return $this->setStatusCode(WebService::HTTP_CODE_UNAUTHORIZED)
  1521.                             ->respondWithError('Invalid email', WebService::CODE_ERR_CONFLICT);
  1522.             }
  1523.             
  1524.             if (isset($existClientByPhone[0]) && $existClientByPhone[0]->getLastname() == 'Default GiftCard Customer') {
  1525.                 $this->createFileJson($path, 'Invalid phone number' . "\r");
  1526.                 return $this->setStatusCode(WebService::HTTP_CODE_UNAUTHORIZED)
  1527.                             ->respondWithError('Invalid phone number', WebService::CODE_ERR_CONFLICT);
  1528.             }
  1531.             if (isset($existClientByEmail[0]) && isset($existClientByPhone[0]) && $existClientByPhone[0]->getId() != $existClientByEmail[0]->getId()) {
  1532.                 unset($params['email']);
  1533.             }
  1535.             if (isset($existClientByPhone[0])) {
  1537.                 $typePointAccountByClient = $em->getRepository('App\Entity\TypePointAcount')->findUserPtAccount($existClientByPhone[0]->getId(), TypePoint::WORK_AS_LOCAL, $accountLicenseData[0]->getId());
  1539.                 if (!$clientOmt) {
  1540.                     $clientOmt = $existClientByPhone[0];
  1541.                 }
  1543.                 if (!isset($typePointAccountByClient[0])) {
  1545.                     $unexpectedEditFlag = true;
  1547.                 } else {
  1549.                     if (isset($existClientByEmail[0])) {
  1551.                         $responseArr['status'] = WebService::CODE_WRONG_ARGUMENTS;
  1553.                         if (isset($existClientByEmail[0]) && isset($params['omtUserId']) && $existClientByEmail[0]->getOmtUserId() == $params['omtUserId'] && isset($params['omtUserUsername']) && $existClientByEmail[0]->getOmtUserUsername() == null) {
  1554.                             
  1555.                             $existClientByEmail[0]->setOmtUserUsername($params['omtUserUsername']);
  1556.                             
  1557.                             $em->persist($existClientByEmail[0]);
  1558.                             $em->flush();
  1559.                         }
  1561.                         $responseArr['msg'] = 'Email is already in use!';
  1563.                         $this->createFileJson($path, 'Email is already in use!' . "\r");
  1565.                         $responseArr['idClient'] = $existClientByEmail[0]->getId();
  1567.                     } elseif (isset($existClientByPhone[0])) {
  1569.                         if (isset($existClientByPhone[0]) && isset($params['omtUserId']) && $existClientByPhone[0]->getOmtUserId() == $params['omtUserId'] && isset($params['omtUserUsername']) && $existClientByPhone[0]->getOmtUserUsername() == null) {
  1570.                             
  1571.                             $existClientByPhone[0]->setOmtUserUsername($params['omtUserUsername']);
  1572.                             $em->persist($existClientByPhone[0]);
  1574.                             $em->flush();
  1575.                         }
  1577.                         $responseArr['status'] = WebService::CODE_ERR_CONFLICT;
  1578.                         $responseArr['msg'] = 'The user could not be created!';
  1580.                         $this->createFileJson($path, 'The user could not be created!' . "\r");
  1582.                         return $this->setStatusCode($responseArr['status'])
  1583.                         ->respondWithError($responseArr['msg'], WebService::CODE_ERR_CONFLICT);
  1585.                     }
  1587.                     if (isset($existClientByEmail) && $existClientByEmail !== []) {
  1589.                         $responseArr['bigbag'] = true;
  1591.                         $theUrlTrSt = new LicensorGenericTransformer($this->realContainer, $responseArr);
  1592.                         
  1593.                         $xxArray = $theUrlTrSt->transform();
  1594.                         $jsonContent = json_encode($xxArray);
  1596.                         return $this->respondWithItem($jsonContent, $theUrlTrSt);
  1597.                     }
  1598.                 }
  1600.             } else {
  1602.                 if (isset($existClientByEmail[0])) {
  1604.                     $responseArr['status'] = WebService::CODE_WRONG_ARGUMENTS;
  1605.                     $responseArr['msg'] = 'Email is already in use!';
  1607.                     $this->createFileJson($path, 'Email is already in use!' . "\r");
  1609.                     $responseArr['idClient'] = $existClientByEmail[0]->getId();
  1611.                 }
  1613.                 if (isset($existClientByEmail) && $existClientByEmail !== []) {
  1615.                     $responseArr['bigbag'] = true;
  1617.                     $theUrlTrSt = new LicensorGenericTransformer($this->realContainer, $responseArr);
  1618.                     
  1619.                     $xxArray = $theUrlTrSt->transform();
  1620.                     $jsonContent = json_encode($xxArray);
  1621.                     
  1622.                     return $this->respondWithItem($jsonContent, $theUrlTrSt);
  1623.                 }
  1624.             }
  1625.         }
  1627.         $copyLoyaltyUserIntoOMT = false;
  1629.         $this->createFileJson($path, '!$clientOmt'. !$clientOmt . "\r");
  1631.         if (!$clientOmt) {
  1633.             if ($nicknameCliData) {
  1635.                 $this->createFileJson($path, 'Username invalid' . "\r");
  1636.                 return $this->setStatusCode(WebService::HTTP_CODE_UNAUTHORIZED)
  1637.                 ->respondWithError('Username invalid', WebService::CODE_ACCOUNT_SUSPENDED);
  1639.             }
  1641.             $copyLoyaltyUserIntoOMT = true;
  1642.             $clientOmt = new OmtClient();
  1643.             
  1644.             //$params['id'] = UUIDGeneratorUtil::getUUIDv4();
  1645.             // se le asigna la llave primaria del usuario de omtws
  1646.             $params['id'] = $responseCreationUserOmt['data']['id'];
  1647.             $this->createFileJson($path, 'UUID generated!: ' .$params['id']. "\r");
  1648.             
  1649.             $clientOmt->setId($params['id']);
  1650.             if (isset($params['omtUserId'])) {
  1651.                 $clientOmt->setOmtUserId($params['omtUserId']);
  1652.             }
  1653.             if (isset($params['omtUserUsername'])) {
  1654.                 $clientOmt->setOmtUserUsername($params['omtUserUsername']);
  1655.             }
  1657.             $responseArr['msg'] = 'Omt User created successfully!';
  1658.             $this->createFileJson($path, 'Omt User created successfully!' . "\r");
  1660.         } else {
  1662.             $this->createFileJson($path, 'the customer already exists debuger'. "\r");
  1664.             if ($unexpectedEditFlag) {
  1666.                 $responseArr['status'] = WebService::CODE_SUCCESS;
  1667.                 $responseArr['msg'] = 'Omt client created for restaurant successfully!';
  1669.                 $this->createFileJson($path, 'Omt client created for restaurant successfully!' . "\r");
  1671.             } else {
  1673.                 $responseArr['status'] = WebService::CODE_SUCCESS;
  1674.                 $responseArr['msg'] = 'Omt client update successfully!';
  1676.                 $this->createFileJson($path, 'Omt client update successfully!' . "\r");
  1677.             }
  1678.         }
  1680.         $indexExistenceToValidate = ['lastFour', 'expirationDate', 'nameOnCard', 'franchise'];
  1681.         $indexInexistenceToValidate = ['name', 'lastname', 'email', 'birthdate', 'phone'];
  1683.         $isCardParams = $this->paramsArrayIndexValidator($params, $indexExistenceToValidate);
  1684.         $isCustomerParams = $this->paramsArrayIndexValidator($params, $indexInexistenceToValidate, false);
  1686.         $newCardAsClient = false;
  1688.         if ($isCardParams[0] && $isCustomerParams[0]) {
  1690.             $this->createFileJson($path, 'entered into ($isCardParams[0] and $isCustomerParams[0]) debug' . "\r");
  1691.             
  1692.             $fullCombined = $params['nameOnCard'] . '_' . $params['lastFour'] . '_' . $params['franchise'] . '_' . $params['expirationDate'];
  1693.             $fullCombined = str_replace(' ', '_', strtolower(str_replace('/', '-', $fullCombined)));
  1695.             $cardAsClienteRecord = $em->getRepository('App\Entity\CardAsClient')->findBy(['uniqueCombined' => $fullCombined]);
  1697.             if (isset($cardAsClienteRecord[0])) {
  1699.                 $this->createFileJson($path, 'exist $cardAsClienteRecord[0] debug' . "\r");
  1700.                 $responseArr['msg'] = 'Omt User updated successfully!';
  1702.                 $clientOmt = $em->find('App\Entity\OmtClient', $cardAsClienteRecord[0]->getClient());
  1703.             
  1704.             } else {
  1706.                 $this->createFileJson($path, 'not exist $cardAsClienteRecord[0] debug' . "\r");
  1707.                 
  1708.                 $newCardAsClient = true;
  1709.                 $params['theCombined'] = $fullCombined;
  1711.                 $perhapsUniqueUserName = str_replace(' ', '_', strtolower(explode(' ', $params['nameOnCard'])[0] . '_' . $params['franchise'] . '_' . $params['lastFour']));
  1713.                 $clientOmt->setName($params['nameOnCard']);
  1714.                 $clientOmt->setUsername($perhapsUniqueUserName);
  1715.                 $clientOmt->setBirthdate(\DateTime::createFromFormat('d/m/Y', '01/' . $params['expirationDate']));
  1716.             }
  1718.         } else {
  1720.             $this->createFileJson($path, 'not entered into ($isCardParams[0] and $isCustomerParams[0]) elde debug' . "\r");
  1721.             
  1722.             if (isset($params['name'])) {
  1723.                 $clientOmt->setName($params['name']);
  1724.             }
  1726.             if (isset($params['lastname'])) {
  1727.                 $clientOmt->setLastname($params['lastname']);
  1728.             }
  1730.             if (isset($params['email']) && $params['email'] !== "") {
  1731.                 
  1732.                 // Se valida que el correo tenga un dominio valido y se agrega la excepción del dominio por defecto
  1733.                 if (!NewUtil::emailContainsGenericDomain($params['email'], $path) && !$this->validateFullEmail($params['email'])) {
  1734.                     return $this->setStatusCode(WebService::HTTP_CODE_BAD_REQUEST)
  1735.                         ->respondWithError("The email ". $params['email'] ." is not a valid", WebService::HTTP_CODE_BAD_REQUEST);
  1736.                 }
  1738.                 $clientOmt->setEmail($params['email']);
  1740.             } else {
  1741.                 $clientOmt->setEmail(null);
  1742.             }
  1744.             if (isset($params['username']) && $params['username'] != '') {
  1745.                 
  1746.                 $clientOmt->setUsername($params['username']);
  1747.             
  1748.             } else {
  1750.                 $clientOmt->setUsername(null);
  1751.             }
  1753.             if (!isset($params['birthdate'])) {
  1754.                
  1755.                 $params['birthdate'] = Util::getCurrentDate()->format('d/m/Y');
  1756.             }
  1757.             
  1758.             $clientOmt->setBirthdate(\DateTime::createFromFormat('d/m/Y', $params['birthdate']));
  1759.             
  1760.             if (isset($params['phone']) && !isset($existClientByPhone[0])) {
  1761.                 
  1762.                 $phoneClient = preg_replace('/[^0-9]/', "", $params['phone']);
  1763.                 $phoneClient = Utilx::clearEspecialCharactersFromPhone($phoneClient);
  1765.                 $clientOmt->setPhone($phoneClient);
  1766.             }
  1767.         }
  1768.         
  1769.         
  1771.         if (isset($params['userPhoneOrder']) && $clientOmt->getUserPhoneOrder() == null) {
  1772.             $clientOmt->setUserPhoneOrder($params['userPhoneOrder']);
  1773.         }
  1774.         
  1775.         if (isset($params['langCode']) && $params['langCode'] != ''){
  1776.             $clientOmt->setLangCode($params['langCode']);
  1777.         }else{
  1778.             $clientOmt->setLangCode(null);
  1779.         }
  1781.         $clientOmt->setOmtUserId($responseCreationUserOmt['data']['id']);
  1782.         $clientOmt->setDefaultEmail(isset($params['defaultEmail']) && $params['defaultEmail'] != '' ? $params['defaultEmail'] : 0 );
  1784.         $this->createFileJson($path, 'before of create client_omt debug' . "\r");
  1786.         $em->persist($clientOmt);
  1787.         $em->flush();
  1789.         $this->createFileJson($path, 'after of create client_omt debug' . "\r");
  1791.         if ($newCardAsClient) {
  1792.             $this->createFileJson($path, 'entered into $newCardAsClient debug' . "\r");
  1793.             Utilx::createCardAsLoyalClientRecord($em, $params, $clientOmt, $path);
  1794.         }
  1796.         $clientPointSearch = ['omtClient' => $clientOmt->getId()];
  1797.         $clientPointAccount = $em->getRepository('App\Entity\PointAcount')->findBy($clientPointSearch);
  1799.         if (!isset($clientPointAccount[0])) {
  1800.             $this->createFileJson($path, 'exist $cardAsClienteRecord[0] debug' . "\r");
  1801.             $pointAccountData = new PointAcount();
  1802.             $pointAccountData->setId($clientOmt->getId());
  1804.             $baseToken = ['food' => '123'];
  1805.             while (!empty($baseToken)) {
  1806.                 $this->createFileJson($path, 'generating new token for PointAcount debug' . "\r");
  1807.                 $token = Utilx::randomPassword(32);
  1808.                 $baseToken = $em->getRepository('App\Entity\PointAcount')->findBy(['basePointacount' => $token]);
  1809.             }
  1811.             $pointAccountData->setBasePointacount($token);
  1812.             $pointAccountData->setActivationDate(new \DateTime('now'));
  1814.             $clientPointAccount[0] = $pointAccountData;
  1815.         } else {
  1816.             $this->createFileJson($path, 'not exist $cardAsClienteRecord[0] debug' . "\r");
  1817.             $pointAccountData = $clientPointAccount[0];
  1818.         }
  1820.         $pointAccountData->setOmtClient($clientOmt->getId());
  1822.         $this->createFileJson($path, 'before of create PointAcount debug'. "\r");
  1823.         $em->persist($pointAccountData);
  1824.         $em->flush();
  1825.         $this->createFileJson($path, 'after of create PointAcount debug'. "\r");
  1826.                 
  1827.         if (isset($params['email']) && isset($params['copyAsOMTClient']) && $copyLoyaltyUserIntoOMT) {
  1828.             $this->createFileJson($path, 'Ready to make loyalty user cUrl request to OMT!' . "\r");
  1829.             $randomOmtDashboardUserRawPass = Utilx::randomPassword(7);
  1830.             $clientOmt->setTemporalOMTPass($randomOmtDashboardUserRawPass);
  1831.             $requestResult = Util::copyLoyaltyUserToOMT($this->realContainer, $em, $clientOmt, $params['countryCode'], $path);
  1832.             $this->createFileJson($path, 'Loyalty user to OMT request response -> ' . json_encode($requestResult) . "\r");
  1833.         }
  1835.         $typePointData = $em->getRepository('App\Entity\TypePoint')->findTypePointDefault();
  1837.         foreach ($typePointData AS $typePoint) {
  1839.             $tpData = $em->getRepository('App\Entity\TypePoint')->find($typePoint['id']);
  1841.             if ($typePoint['type'] == TypePoint::TYPE_GLOBAL) {
  1842.                 $typePointAccountArray = $em->getRepository('App\Entity\TypePointAcount')->findBy(['typePoint' => $typePoint['id'], 'pointAcount' => $pointAccountData->getId()]);
  1843.             } else {
  1844.                 $typePointAccountArray = $em->getRepository('App\Entity\TypePointAcount')->findBy(['typePoint' => $typePoint['id'], 'pointAcount' => $pointAccountData->getId(), 'license' => $accountLicenseData[0]->getId()]);
  1845.             }
  1847.             if (isset($typePointAccountArray[0])) {
  1848.                 $typePointAccountData = $typePointAccountArray[0];
  1849.             } else {
  1850.                 $typePointAccountData = new TypePointAcount();
  1852.                 $acountToken = ['food' => '123'];
  1853.                 while (!empty($acountToken)) {
  1854.                     $tokenAcount = Encryptor::encodeInfo(Utilx::randomPassword(32), 5);
  1855.                     $acountToken = $em->getRepository('App\Entity\TypePointAcount')->findBy(['acountToken' => $tokenAcount]);
  1856.                 }
  1858.                 $typePointAccountData->setAmount(0);
  1859.                 $typePointAccountData->setAcountToken($tokenAcount);
  1860.                 $typePointAccountData->setStartingDate(new \DateTime('now'));
  1861.                 $typePointAccountData->setPointArmAcount('Pepito Habla Ingles!');
  1862.             }
  1864.             $typePointAccountData->setTypePoint($tpData);
  1865.             $typePointAccountData->setPointAcount($pointAccountData);
  1866.             $typePointAccountData->setCountryId($countryData);
  1868.             if ($typePoint['type'] != TypePoint::TYPE_GLOBAL) {
  1869.                 $typePointAccountData->setLicense($accountLicenseData[0]);
  1870.             }
  1872.             $this->createFileJson($path, 'before of create TypePointAcount debug'. "\r");
  1873.             $em->persist($typePointAccountData);
  1874.             $em->flush();
  1875.             $this->createFileJson($path, 'after of create TypePointAcount debug'. "\r");
  1877.             $log->createChannel('gift_card');
  1879.             $arrayTypePointAccountTokenToArmor = PointsUtilPorcessor::createArrayForPostPutArmorPointRequest($typePointAccountData);
  1880.             // dump($arrayTypePointAccountTokenToArmor);
  1881.             // die;
  1883.             $encodeBase = Encryptor::encodeInfo(json_encode($arrayTypePointAccountTokenToArmor));
  1884.             
  1885.             $request = $armor->duplicateRequestWithOverwritedContentForArmorServer($request, ['token' => $encodeBase]);
  1887.             $this->createFileJson($path, 'Armor request send: ' . $request . "\r");
  1889.             $url = $this->realContainer->getParameter('armor_host') . 'point/add-points';
  1890.             $this->createFileJson($path, 'Armor URL: ' . $url . "\r");
  1891.             $dataResponse = $armor->armorPost($request, $url, $log);
  1893.             if ($dataResponse instanceof Response) {
  1894.                 $jsonResponse = $dataResponse->getContent();
  1896.                 $this->createFileJson($path, 'Armor response instance: ' . $jsonResponse . "\r");
  1898.                 $decodedResponse = json_decode($jsonResponse, true);
  1900.                 if (isset($decodedResponse['data'])) {
  1901.                     $neededArmorId = $decodedResponse['data']['points_id'];
  1903.                     $typePointAccountData->setArmIdentifier($neededArmorId);
  1905.                     $em->persist($typePointAccountData);
  1906.                     $em->flush();
  1907.                 }
  1908.             } else {
  1909.                 $this->createFileJson($path, 'Armor response: ' . $dataResponse . "\r");
  1910.             }
  1912.             /*
  1913.              * 
  1914.               {
  1915.               "type_point": "5555aaaa-aaaa-5555-aaaa-bdbca33ee555",
  1916.               "starting_date": "1409175049",
  1917.               "country": "US",
  1918.               "account_token": "411dfg111114444",
  1919.               "amount": "1200",
  1920.               "identifier": "b06b66b6-6ad6-6666-6af6-bdbca66ee66"
  1921.               }
  1922.              * 
  1923.              */
  1924.         }
  1926.         $pointAccountByClientRepository = $em->getRepository('App\Entity\TypePointAcount');
  1928.         //dump($loyaltyConfiguration[0]->getMinimumPointAmountToExchange());
  1929.         //die;
  1930.         //if ($loyaltyConfiguration[0]->getUseGlobalPoints()) {
  1931.         $pointAccountByClient = $pointAccountByClientRepository->findTypePointAccountByClient(['idClient' => $clientOmt->getId(), 'restaurant' => $accountLicenseData[0]->getId()], [], true, $loyaltyConfiguration->getMinimumPointAmountToExchange());
  1932.         //} else {
  1933.         //   $pointAccountByClient = $pointAccountByClientRepository->findTypePointAccountByClient(['idClient' => $clientOmt->getId(), 'restaurant' => $accountLicenseData[0]->getId()], []);
  1934.         //}
  1936.         //  if (!isset($pointAccountByClient['name'])) {
  1937.         //     return $this->setStatusCode(WebService::HTTP_CODE_UNAUTHORIZED)
  1938.         //    ->respondWithError('customer not found', WebService::CODE_COULD_NOT_AUTHENTICATE);
  1939.         //  }
  1940.         // $responseAddAddressNewUser = $clientController->createAddressDummyInOmtWs($this->realContainer, $responseCreationUserOmt['data']['id'], [], $clientOmt->getId());
  1942.         // if (isset($responseAddAddressNewUser['errors'])) {
  1943.         //     return $this->setStatusCode(WebService::HTTP_CODE_BAD_REQUEST)
  1944.         //         ->respondWithError($responseAddAddressNewUser['errors']['message'], WebService::HTTP_CODE_BAD_REQUEST);
  1945.         // }
  1947.         if (isset($pointAccountByClient['accounts'][0])) {
  1948.             $responseArr['msg'] .= ', list of points by client';
  1949.             $this->createFileJson($path, 'list of points by client' . "\r");
  1950.             $responseArr['status'] = WebService::CODE_SUCCESS;
  1951.             $responseArr['client'] = $pointAccountByClient['accounts'][0];
  1952.             $responseArr['bigbag'] = true;
  1953.         } else {
  1954.             $responseArr['msg'] = 'No client found with the given data';
  1955.             $this->createFileJson($path, 'No client found with the given data' . "\r");
  1956.             $responseArr['status'] = WebService::CODE_SUCCESS;
  1957.         }
  1959.         $theUrlTrSt = new LicensorGenericTransformer($this->realContainer, $responseArr);
  1960.         $xxArray = $theUrlTrSt->transform();
  1961.         $jsonContent = json_encode($xxArray);
  1963.         $this->createFileJson($path, 'WS ends' . "\r");
  1964.         return $this->respondWithItem($jsonContent, $theUrlTrSt);
  1965.     }
  1967.     private function updateDataOmtClient($params, $path){
  1968.         $em = $this->getDoctrine()->getManager();
  1970.         $omtClientRepo = $em->getRepository('App\Entity\OmtClient');
  1972.         $clientToUpdateDirect = null;
  1973.         if (isset($params['clientId'])) {
  1974.             $clientToUpdateDirect = $omtClientRepo->find($params['clientId']);
  1975.         }
  1977.         if (is_null($clientToUpdateDirect) && isset($params['email']) && $params['email'] != '') {
  1978.             $clientToUpdateDirect = $omtClientRepo->findOneBy(['email' => $params['email']]);
  1979.         }
  1981.         if (!is_null($clientToUpdateDirect)) {
  1982.             $params['userId'] = $clientToUpdateDirect->getId();
  1983.             
  1984.             $url = $this->realContainer->getParameter('level_scheme') . '://' . $this->realContainer->getParameter('level_host') . $this->generateUrl('data_users_loyalty_update');
  1985.             //  . '?'. http_build_query($params);
  1987.             $paramsToSend = json_encode($params);
  1989.             $this->createFileJson($path, 'data before to send' . "\r");
  1991.             $this->createFileJson($path, 'params => '. $paramsToSend . "\r");
  1992.             $this->createFileJson($path, 'url => '. $url ."\r");
  1993.             
  1994.             $ch = curl_init();
  1995.             curl_setopt($ch, CURLOPT_URL, $url);
  1996.             curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
  1997.             curl_setopt($ch, CURLOPT_CUSTOMREQUEST, WebService::REQUEST_METHOD_PUT);
  1998.             curl_setopt($ch, CURLOPT_POSTFIELDS, $paramsToSend);
  2000.             $result = curl_exec($ch);
  2001.             $this->createFileJson($path, 'result of curl the function updateDataOmtClient => '. $result ."\r");
  2003.             $decodeResult = json_decode($result, true);
  2004.             
  2005.             return $this->respondJsonAjax($decodeResult);
  2006.         }else{
  2007.             return $this->setStatusCode(WebService::CODE_ERR_CONFLICT)
  2008.                 ->respondWithError('Client not located to update', WebService::HTTP_CODE_BAD_REQUEST);
  2009.         }
  2011.     }
  2013.     /**
  2014.      * @param Request $request
  2015.      * @return type
  2016.      */
  2017.     public function chingoFuncionParaJhonier(Request $request, ArmorService $armor, Log $log) {
  2018.         if ($request->getMethod() === WebService::REQUEST_METHOD_GET) {
  2019.             $path = Util::getValidActiveLogByBaseName($this->realContainer, 'chingoFuncionParaJhonier', 'chingoFuncionParaJhonier0.txt');
  2020.             $this->createFileJson($path, "\r" . 'omtClient Ask: ' . json_encode($request->query->all()) . "\r");
  2022.             $em = $this->getDoctrine()->getManager();
  2024.             $indexSearch = ['nickname','phone', 'email'];
  2026.             $search = Paginator::filterParameters($indexSearch, $request, Paginator::REQUEST_TYPE_REQUEST);
  2027.             $order = Paginator::filterPaginatorParameters([], $request, true);
  2029.             // dd($search, $order);
  2030.             $debug = $request->query->get('debug');
  2032.             if ($debug) {
  2033.                 dump($search);
  2034.             }
  2036.             if (empty($search)) {
  2037.                 $this->createFileJson($path, "\r" . "invalid parameter name" . "\r");
  2039.                 return $this->setStatusCode(WebService::HTTP_CODE_UNAUTHORIZED)
  2040.                                 ->respondWithError('Invalid parameter name', WebService::CODE_COULD_NOT_AUTHENTICATE);
  2041.             }
  2043.             $data = ['alLicenseUsername' => $search['nickname']];
  2044.             $accountLicenseData = $em->getRepository('App\Entity\AccountLicense')->findByAlLicenseUsername($data);
  2046.             if (empty($accountLicenseData[0]))
  2047.                 return $this->setStatusCode(WebService::HTTP_CODE_UNAUTHORIZED)
  2048.                             ->respondWithError('Coulnt find any license', WebService::CODE_COULD_NOT_AUTHENTICATE);
  2050.             $countResult = count($accountLicenseData);
  2052.             $validate = $this->validateLicense($countResult, $path, $accountLicenseData);
  2053.             if(!$validate["status"]){
  2054.                 return $this->setStatusCode($validate["status"])
  2055.                                 ->respondWithError($validate["message"], $validate["code"]);
  2056.             }
  2057.             
  2058.             // if ($countResult <= 0) {
  2059.             //     $this->createFileJson($path, "\r" . "Invalid nickname or channelname" . "\r");
  2060.             //     return $this->setStatusCode(WebService::HTTP_CODE_UNAUTHORIZED)
  2061.             //                     ->respondWithError('Invalid nickname or channelname', WebService::CODE_COULD_NOT_AUTHENTICATE);
  2062.             // }
  2064.             // $this->createFileJson($path, "\r" . "license found => ". $search['nickname'] . "\r");
  2066.             // if ($accountLicenseData[0]->getAlAccountLicense()->getDeleted()) {
  2067.             //     $this->createFileJson($path, "\r" . "Account is inactive" . "\r");
  2068.             //     return $this->setStatusCode(WebService::HTTP_CODE_UNAUTHORIZED)
  2069.             //                     ->respondWithError('Account is inactive', WebService::CODE_ACCOUNT_SUSPENDED);
  2070.             // }
  2072.             // if ($accountLicenseData[0]->getAlLicenseStatus() == AccountLicense::LICENSE_STATUS_INACTIVE) {
  2073.             //     $this->createFileJson($path, "\r" . "Inactive License" . "\r");
  2074.             //     return $this->setStatusCode(WebService::HTTP_CODE_UNAUTHORIZED)
  2075.             //                     ->respondWithError('Inactive License', WebService::CODE_ACCOUNT_SUSPENDED);
  2076.             // }
  2078.             $loyaltyConfiguration = $em->getRepository('App\Entity\RestaurantLoyaltyConfiguration')->findBy(['license' => $accountLicenseData[0]->getId()]);
  2079.             $this->createFileJson($path, "\r" . "searching loyalty configuration with license id => ". $accountLicenseData[0]->getId() . "\r");
  2081.             // if (isset($loyaltyConfiguration[0]) && (!$loyaltyConfiguration[0]->getUseLocalPoints() && !$loyaltyConfiguration[0]->getUseGlobalPoints())) {
  2082.             //     $this->createFileJson($path, 'Loyalty functions not configured yet o.O' . "\r");
  2083.             //     return $this->setStatusCode(WebService::HTTP_CODE_UNAUTHORIZED)
  2084.             //                     ->respondWithError('Loyalty functions not configured yet', WebService::CODE_ACCOUNT_SUSPENDED);
  2085.             // } else
  2086.             if (!isset($loyaltyConfiguration[0])) {
  2087.                 $this->createFileJson($path, 'Loyalty functions configuration record not found o.O' . "\r");
  2088.                 return $this->setStatusCode(WebService::HTTP_CODE_UNAUTHORIZED)
  2089.                                 ->respondWithError('Loyalty functions configuration record not found!', WebService::CODE_ACCOUNT_SUSPENDED);
  2090.             }
  2092.             $log->createChannel('local_point_automatic_creation_log');
  2094.             $search['restaurant'] = $accountLicenseData[0]->getId();
  2096.             $responseArr = [];
  2098.             if ($debug) {
  2099.                 dump($search, $order, $loyaltyConfiguration[0]->getMinimumPointAmountToExchange());
  2100.             }
  2102.             $pointAccountByClientRepository = $em->getRepository('App\Entity\TypePointAcount');
  2103.             $typePointRepository = $em->getRepository('App\Entity\TypePoint');
  2104.             $pointAccountByClient = $pointAccountByClientRepository->findTypePointAccountByRestaurant($request, $this->realContainer, $search, $order, $loyaltyConfiguration[0]->getMinimumPointAmountToExchange(), $accountLicenseData[0], $armor, $log, $path, false, $debug);
  2105.             $this->createFileJson($path, "\r" . "validate and build paginator data" . "\r");
  2106.             $paginatorFormatedData = $this->validateAndBuildPaginatorData($order, $pointAccountByClient);
  2108.             // dump($paginatorFormatedData);
  2110.             $info = $typePointRepository->getRatioPoints();
  2112.             $this->createFileJson($path, "\r" . "pagination for data response" . "\r");
  2113.             $responseArrWithPagination = $this->paginationForDataResponse($paginatorFormatedData['response'], $paginatorFormatedData['paginator']);
  2115.             // dump($responseArrWithPagination);
  2117.             $responseArrWithPagination['msg'] = "List of point accounts by '$accountLicenseData[0]' restaurant";
  2118.             $responseArrWithPagination['status'] = WebService::CODE_SUCCESS;
  2119.             $responseArrWithPagination['clients'] = $pointAccountByClient['accounts'];
  2120.             $responseArrWithPagination['info'] = $info;
  2121.             $responseArrWithPagination['bigbag'] = true;
  2122.             
  2123.             if(isset($search['restaurant']) && $search['restaurant'] != ''){
  2124.                 $loyaltyConfiguration = $em->getRepository('App\Entity\RestaurantLoyaltyConfiguration')->getStatusLoyaltyByRestaurand($search['restaurant']);
  2125.                 $responseArrWithPagination['loyaltyPoints'] = (boolean)$loyaltyConfiguration;
  2126.             }
  2127.             // dump(count($responseArrWithPagination['accounts']));
  2128.             // dump(count($responseArrWithPagination['clients']));
  2129.             // die;        
  2131.             if (isset($responseArrWithPagination['accounts'])) {
  2132.                 unset($responseArrWithPagination['accounts']);
  2133.             }
  2135.             if ($debug) {
  2136.                 die;
  2137.             }
  2139.             // $theUrlTrSt = new LicensorGenericTransformer($this->realContainer, $responseArrWithPagination);
  2140.             // $xxArray = $theUrlTrSt->transform();
  2142.             // $jsonContent = json_encode($xxArray);
  2143.             
  2145.             // 1. Crear el transformer y procesar datos base
  2146.             $theUrlTrSt = new LicensorGenericTransformer($this->realContainer, $responseArrWithPagination);
  2147.             $xxArray = $theUrlTrSt->transform();
  2149.             // 2. Obtener tokens solo si hay clientId válido
  2150.             $baseUrl = $this->realContainer->getParameter('omt_ws_url') . "common/getTokenForUser";
  2151.             $tokensData = null;
  2152.             // dd($xxArray);
  2153.             if (isset($xxArray['clients'][0]['clientId']) && !empty($xxArray['clients'][0]['clientId'])) {
  2154.                 $omtClient = $em->getRepository('App\Entity\OmtClient')->find($xxArray['clients'][0]['clientId']);
  2155.                 $this->createFileJson($path, "\r" . 'Token detectado: ' . json_encode(['clientd' => $xxArray['clients'][0]['clientId']]) . "\r");
  2156.                 
  2157.                 if ($omtClient) {
  2158.                     $url = $baseUrl . '?loyaltyClientId=' . urlencode($omtClient->getOmtUserId());
  2159.                     $this->createFileJson($path, "\r" . 'Token detectado: '. "\r");
  2160.                     $this->createFileJson($path, "\r" . 'Usuario: ' . json_encode(['clientd' => $xxArray['clients'][0]['clientId'], 'omt_user' => $omtClient->getOmtUserId()]) . "\r");
  2162.                     $this->createFileJson($path, "\r" . 'Send request to omt ' . "\r");
  2164.                     $ch = curl_init();
  2165.                     curl_setopt($ch, CURLOPT_URL, $url);
  2166.                     curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
  2167.                     curl_setopt($ch, CURLOPT_HTTPHEADER, ['Content-Type: application/json']);
  2168.                     $result = curl_exec($ch);
  2169.                     $httpCode = curl_getinfo($ch, CURLINFO_HTTP_CODE);
  2170.                     curl_close($ch);
  2172.                     if ($result !== false && $httpCode === 200) {
  2173.                         $this->createFileJson($path, "\r" . 'Armor response Ok: ' . $result . "\r");
  2174.                         $responseData = json_decode($result, true);
  2175.                         if (isset($responseData['data'])) {
  2176.                             $tokensData = $responseData['data'];
  2177.                         }
  2178.                     }
  2180.                     $this->createFileJson($path, "\r" . 'Armor Failed: ' . $result . "\r");
  2181.                 }
  2182.             } else {
  2183.                 $this->createFileJson($path, "\r" . 'No token detected '  . "\r");
  2184.             }
  2186.             // 3. Construir respuesta final
  2187.             $finalResponse = [
  2188.                 'data' => $xxArray  // Datos base transformados
  2189.             ];
  2190.             
  2191.             // Añadir tokens solo si existen
  2192.             if ($tokensData !== null) {
  2193.                 $finalResponse['data']['clients'][0]['tokens'] = $tokensData;
  2194.             }
  2196.             // 4. Retornar respuesta
  2197.             return $this->respondWithArray($finalResponse);
  2198.         }
  2200.         if ($request->getMethod() === WebService::REQUEST_METHOD_OPTIONS) {
  2201.             $responseArrWithPagination['msg'] = "Good to go!";
  2202.             $responseArrWithPagination['status'] = WebService::CODE_SUCCESS;
  2203.             $responseArrWithPagination['bigbag'] = false;
  2205.             $theUrlTrSt = new LicensorGenericTransformer($this->realContainer, $responseArrWithPagination);
  2206.             $xxArray = $theUrlTrSt->transform();
  2207.             $jsonContent = json_encode($xxArray);
  2208.             return $this->respondWithItem($jsonContent, $theUrlTrSt);
  2209.         }
  2210.     }
  2212.     /**
  2213.      * 
  2214.      * @param \Symfony\Component\HttpFoundation\Request $request datos de la solicitud
  2215.      * @return Response Json con la informacion de respuesta
  2216.      */
  2217.     public function createPointAccount(Request $request) {
  2219.         if ($request->getMethod() === WebService::REQUEST_METHOD_POST) {
  2221.             $data = json_decode($request->getContent(), true);
  2223.             if (strlen($data['omtClientId']) != 36) {
  2224.                 return $this->setStatusCode(WebService::HTTP_CODE_UNAUTHORIZED)
  2225.                                 ->respondWithError('Invalid omtClientId', WebService::CODE_COULD_NOT_AUTHENTICATE);
  2226.             }
  2228.             if (strlen($data['id']) != 36) {
  2229.                 return $this->setStatusCode(WebService::HTTP_CODE_UNAUTHORIZED)
  2230.                                 ->respondWithError('Invalid id', WebService::CODE_COULD_NOT_AUTHENTICATE);
  2231.             }
  2233.             $em = $this->getDoctrine()->getManager();
  2235.             $pointAccountData = $em->getRepository('App\Entity\PointAcount')->find($data['id']);
  2237.             $clientOmt = $em->getRepository('App\Entity\OmtClient')->find($data['omtClientId']);
  2239.             if (!$clientOmt) {
  2240.                 return $this->setStatusCode(WebService::HTTP_CODE_UNAUTHORIZED)
  2241.                                 ->respondWithError('Omt client not found', WebService::CODE_COULD_NOT_AUTHENTICATE);
  2242.             }
  2244.             $clientPointSearch = ['omtClient' => $data['omtClientId']];
  2245.             $clientPointAccount = $em->getRepository('App\Entity\PointAcount')->findBy($clientPointSearch);
  2247.             $basePointSearch = ['basePointacount' => $data['basePointacount']];
  2248.             $basePointAccount = $em->getRepository('App\Entity\PointAcount')->findBy($basePointSearch);
  2249.             if ($basePointAccount && $basePointAccount[0]->getId() != $data['id']) {
  2250.                 return $this->setStatusCode(WebService::HTTP_CODE_UNAUTHORIZED)
  2251.                                 ->respondWithError('Invalid basePointAcount', WebService::CODE_COULD_NOT_AUTHENTICATE);
  2252.             }
  2253.             $responseArr['status'] = WebService::CODE_SUCCESS;
  2254.             $responseArr['msg'] = 'Point account update successfully!';
  2256.             if (!$pointAccountData) {
  2257.                 $pointAccountData = new PointAcount();
  2258.                 $pointAccountData->setId($data['id']);
  2259.                 $responseArr['msg'] = 'Point account created successfully!';
  2260.             }
  2262.             $pointAccountData->setOmtClient($clientOmt->getId());
  2263.             $pointAccountData->setBasePointacount($data['basePointacount']);
  2264.             $pointAccountData->setActivationDate(new \DateTime($data['activationDate']));
  2265.             $em->persist($pointAccountData);
  2266.             $em->flush();
  2268.             if ($clientPointAccount) {
  2269.                 $responseArr['msg'] .= ' User already has point account!';
  2270.             }
  2272.             $theUrlTrSt = new LicensorGenericTransformer($this->realContainer, $responseArr);
  2273.             $xxArray = $theUrlTrSt->transform();
  2275.             $jsonContent = json_encode($xxArray);
  2277.             return $this->respondWithItem($jsonContent, $theUrlTrSt);
  2278.         }
  2279.     }
  2281.     /**
  2282.      * 
  2283.      * @param \Symfony\Component\HttpFoundation\Request $request datos de la solicitud
  2284.      * @return Response Json con la informacion de respuesta
  2285.      */
  2286.     public function createTypePointAccount(Request $request) {
  2287.         if ($request->getMethod() === WebService::REQUEST_METHOD_POST) {
  2289.             $data = json_decode($request->getContent(), true);
  2291.             if (strlen($data['typePoinId']) != 36) {
  2292.                 return $this->setStatusCode(WebService::HTTP_CODE_UNAUTHORIZED)
  2293.                                 ->respondWithError('Invalid typePoinId', WebService::CODE_COULD_NOT_AUTHENTICATE);
  2294.             }
  2296.             if (strlen($data['pointAccountId']) != 36) {
  2297.                 return $this->setStatusCode(WebService::HTTP_CODE_UNAUTHORIZED)
  2298.                                 ->respondWithError('Invalid pointAccountId', WebService::CODE_COULD_NOT_AUTHENTICATE);
  2299.             }
  2301.             if (strlen($data['id']) != 36) {
  2302.                 return $this->setStatusCode(WebService::HTTP_CODE_UNAUTHORIZED)
  2303.                                 ->respondWithError('Invalid id', WebService::CODE_COULD_NOT_AUTHENTICATE);
  2304.             }
  2306.             $em = $this->getDoctrine()->getManager();
  2308.             $typePointAccountData = $em->getRepository('App\Entity\TypePointAcount')->find($data['id']);
  2310.             $accountTokenSearch = ['acountToken' => $data['accountToken']];
  2311.             $accountTokenData = $em->getRepository('App\Entity\TypePointAcount')->findBy($accountTokenSearch);
  2312.             if ($accountTokenData && $accountTokenData[0]->getId() != $data['id']) {
  2313.                 return $this->setStatusCode(WebService::HTTP_CODE_UNAUTHORIZED)
  2314.                                 ->respondWithError('Invalid acountToken', WebService::CODE_COULD_NOT_AUTHENTICATE);
  2315.             }
  2316.             $typePointData = $em->getRepository('App\Entity\TypePoint')->find($data['typePoinId']);
  2318.             $countrySearch = ['coVal' => $data['countryCode']];
  2319.             $countryData = $em->getRepository('App\Entity\Country')->findBy($countrySearch);
  2320.             if ($countryData) {
  2321.                 $countryData = $em->getRepository('App\Entity\Country')->find($countryData[0]->getCoId());
  2322.             }
  2324.             $pointAccountData = $em->getRepository('App\Entity\PointAcount')->find($data['pointAccountId']);
  2326.             $responseArr['status'] = WebService::CODE_SUCCESS;
  2327.             $responseArr['msg'] = 'Type Point account update successfully!';
  2329.             if (!$typePointAccountData) {
  2330.                 $typePointAccountData = new TypePointAcount();
  2331.                 $typePointAccountData->setId($data['id']);
  2332.                 $responseArr['msg'] = 'Type Point account created successfully!';
  2333.             }
  2335.             $typePointAccountData->setTypePoint($typePointData);
  2336.             $typePointAccountData->setPointAcount($pointAccountData);
  2337.             $typePointAccountData->setCountryId($countryData);
  2338.             $typePointAccountData->setAmount($data['ptAmount']);
  2339.             $typePointAccountData->setPointArmAcount($data['pointArmAccount']);
  2340.             $typePointAccountData->setStartingDate(new \DateTime($data['startingDate']));
  2341.             $typePointAccountData->setAcountToken($data['accountToken']);
  2342.             $em->persist($typePointAccountData);
  2343.             $em->flush();
  2345.             $theUrlTrSt = new LicensorGenericTransformer($this->realContainer, $responseArr);
  2346.             $xxArray = $theUrlTrSt->transform();
  2348.             $jsonContent = json_encode($xxArray);
  2350.             return $this->respondWithItem($jsonContent, $theUrlTrSt);
  2351.         }
  2352.     }
  2354.     /**
  2355.      * @param Request $request
  2356.      * @return type
  2357.      */
  2358.     public function listOfRules(Request $request) {
  2360.         if ($request->getMethod() === WebService::REQUEST_METHOD_GET) {
  2362.             $em = $this->getDoctrine()->getManager();
  2364.             $indexSearch = ['uid', 'nickname'];
  2366.             $search = Paginator::filterParameters($indexSearch, $request, Paginator::REQUEST_TYPE_REQUEST);
  2368.             if (isset($search['uid']) && isset($search['nickname'])) {
  2369.                 $dataSearch = ['deviceUid' => $search['uid']];
  2370.                 $accountLicByUidData = $em->getRepository('App\Entity\AccountLicense')->findBy($dataSearch);
  2372.                 if (!$accountLicByUidData) {
  2373.                     return $this->setStatusCode(WebService::HTTP_CODE_UNAUTHORIZED)
  2374.                                     ->respondWithError('Invalid UID', WebService::CODE_COULD_NOT_AUTHENTICATE);
  2375.                 }
  2377.                 $dataSearch = ['alLicenseUsername' => $search['nickname']];
  2378.                 $accountLicByNicknameData = $em->getRepository('App\Entity\AccountLicense')->findBy($dataSearch);
  2380.                 if (!$accountLicByNicknameData) {
  2381.                     return $this->setStatusCode(WebService::HTTP_CODE_UNAUTHORIZED)
  2382.                                     ->respondWithError('Invalid nickname', WebService::CODE_COULD_NOT_AUTHENTICATE);
  2383.                 }
  2385.                 if ($accountLicByNicknameData[0]->getId() != $accountLicByUidData[0]->getId()) {
  2386.                     return $this->setStatusCode(WebService::HTTP_CODE_UNAUTHORIZED)
  2387.                                     ->respondWithError('Invalid nickname or uid', WebService::CODE_COULD_NOT_AUTHENTICATE);
  2388.                 }
  2389.                 if ($accountLicByUidData[0]) {
  2390.                     $search['id'] = $accountLicByUidData[0]->getId();
  2391.                 }
  2392.             }
  2394.             $listRules = $em->getRepository('App\Entity\PtsAdquiRedemRules')->listRules($search);
  2396.             $responseArr['msg'] = 'List of rules';
  2398.             $responseArr['status'] = WebService::CODE_SUCCESS;
  2400.             $responseArr['dataList'] = $listRules;
  2402.             $responseArr['bigbag'] = true;
  2404.             $theUrlTrSt = new LicensorGenericTransformer($this->realContainer, $responseArr);
  2405.             $xxArray = $theUrlTrSt->transform();
  2406.             $jsonContent = json_encode($xxArray);
  2407.             return $this->respondWithItem($jsonContent, $theUrlTrSt);
  2408.         }
  2409.     }
  2411.     /**
  2412.      * WS generico para consultar el historial de transacciones punto central el cliente 
  2413.      * @author Felipe Bautista <aarango@kijho.com> 19/02/19
  2414.      * @param Request $request
  2415.      * @return type 
  2416.      */
  2417.     public function historyTransactionPoints(Request $request) {
  2419.         if ($request->getMethod() === WebService::REQUEST_METHOD_GET) {
  2421.             $em = $this->getDoctrine()->getManager();
  2423.             $indexSearch = ['nickname', 'accountNickname', 'initialDate', 'endDate', 'typePoints', 'typeOfPurchase', 'page', 'limit'];
  2425.             $search = Paginator::filterParameters($indexSearch, $request, Paginator::REQUEST_TYPE_REQUEST);
  2427.             $historyTransaction = $em->getRepository('App\Entity\PointDeal')->searchHistoryTransation(null, $search);
  2429.             $responseArr['msg'] = 'Transaction History';
  2431.             $responseArr['status'] = WebService::CODE_SUCCESS;
  2433.             $responseArr['dataList'] = $historyTransaction;
  2435.             $responseArr['bigbag'] = true;
  2437.             $theUrlTrSt = new LicensorGenericTransformer($this->realContainer, $responseArr);
  2438.             $xxArray = $theUrlTrSt->transform();
  2439.             $jsonContent = json_encode($xxArray);
  2440.             return $this->respondWithItem($jsonContent, $theUrlTrSt);
  2441.         }
  2442.     }
  2444.     /**
  2445.      * WS generico para consultar el historial de transacciones punto central el restaurante 
  2446.      * @author Felipe Bautista <aarango@kijho.com> 19/02/19
  2447.      * @param Request $request
  2448.      * @return type 
  2449.      */
  2450.     public function historyTransactionPointsByRestaurant(Request $request) {
  2452.         if ($request->getMethod() === WebService::REQUEST_METHOD_GET) {
  2453.             
  2454.             $em = $this->getDoctrine()->getManager();
  2456.             $indexSearch = ['nickname', 'accountNickname', 'initialDate', 'endDate', 'typePoints', 'typeOfPurchase', 'page', 'limit'];
  2458.             $search = Paginator::filterParameters($indexSearch, $request, Paginator::REQUEST_TYPE_REQUEST);
  2460.             $restaurant = $em->getRepository('App\Entity\AccountLicense')->searchRestaurant($search);
  2462.             $historyTransaction = $em->getRepository('App\Entity\PointDeal')->searchHistoryTransationByRestaurant($restaurant, $search);
  2464.             $responseArr['msg'] = 'Transaction History By Restaurants';
  2465.             $responseArr['status'] = WebService::CODE_SUCCESS;
  2466.             $responseArr['dataList'] = $historyTransaction;
  2467.             $responseArr['bigbag'] = true;
  2469.             $theUrlTrSt = new LicensorGenericTransformer($this->realContainer, $responseArr);
  2470.             $xxArray = $theUrlTrSt->transform();
  2471.             $jsonContent = json_encode($xxArray);
  2472.             return $this->respondWithItem($jsonContent, $theUrlTrSt);
  2473.         }
  2474.     }
  2476.     /**
  2477.      * @author Felipe Bautista <aarango@kijho.com> 21/02/19
  2478.      * @param Request $request
  2479.      * @return type 
  2480.      */
  2481.     public function checkCards(Request $request) {
  2483.         if ($request->getMethod() === WebService::REQUEST_METHOD_GET) {
  2485.             $em = $this->getDoctrine()->getManager();
  2487.             $indexSearch = ['uid', 'nickname', 'lastFour', 'expirationDate', 'nameOnCard', 'franchise', 'langCode', 'countryCode', 'page', 'limit'];
  2489.             $data = Paginator::filterParameters($indexSearch, $request, Paginator::REQUEST_TYPE_REQUEST);
  2490.             $cards = [];
  2491.             if (!isset($data['nickname']) || !isset($data['uid']) || !isset($data['countryCode'])) {
  2492.                 return $this->errorWrongArgs('Wrong Arguments', WebService::CODE_WRONG_ARGUMENTS);
  2493.             }
  2495.             $nickname = $em->getRepository('App\Entity\AccountLicense')->findBy(['alLicenseUsername' => $data['nickname']]);
  2496.             if (!isset($nickname) || $nickname == []) {
  2497.                 return $this->errorWrongArgs('nickname not found', WebService::CODE_WRONG_ARGUMENTS);
  2498.             }
  2500.             $uid = $em->getRepository('App\Entity\AccountLicense')->findBy(['deviceUid' => $data['uid']]);
  2501.             if (!isset($uid) || $uid == []) {
  2502.                 return $this->errorWrongArgs('uid not found', WebService::CODE_WRONG_ARGUMENTS);
  2503.             }
  2505.             if ($uid[0]->getId() !== $nickname[0]->getId()) {
  2506.                 return $this->errorWrongArgs('Wrong Arguments', WebService::CODE_WRONG_ARGUMENTS);
  2507.             }
  2509.             $fullCombined = $data['nameOnCard'] . '_' . $data['lastFour'] . '_' . $data['franchise'] . '_' . $data['expirationDate'];
  2510.             $fullCombined = str_replace(' ', '_', strtolower(str_replace('/', '-', $fullCombined)));
  2512.             $cardClient = $em->getRepository('App\Entity\CardAsClient')->findBy(['uniqueCombined' => $fullCombined]);
  2513.             if ($cardClient) {
  2514.                 $cards = $em->getRepository('App\Entity\CardAsClient')->searchForCardMatches($data, $fullCombined);
  2515.             }
  2517.             $responseArr['msg'] = 'Cards clients';
  2518.             $responseArr['status'] = WebService::CODE_SUCCESS;
  2519.             $responseArr['cards'] = $cards;
  2520.             $responseArr['bigbag'] = true;
  2522.             $theUrlTrSt = new LicensorGenericTransformer($this->realContainer, $responseArr);
  2523.             $xxArray = $theUrlTrSt->transform();
  2524.             $jsonContent = json_encode($xxArray);
  2526.             return $this->respondWithItem($jsonContent, $theUrlTrSt);
  2527.         }
  2528.     }
  2530.     /**
  2531.      * @param Request $request
  2532.      * @return type
  2533.      */
  2534.     public function adjustRefundPointsOrElse(Request $request, ArmorService $armor, Log $log) {
  2535.         if ($request->getMethod() !== WebService::REQUEST_METHOD_POST) {
  2536.             return $this->errorNotAllowedMethod('Method not allowed. Use ' . WebService::REQUEST_METHOD_POST . " method");
  2537.         }
  2539.         if (!(0 === strpos($request->headers->get('Content-Type'), WebService::CONTENT_TYPE_STRUCTURE) || 0 === strpos($request->headers->get('Content-Type'), WebService::CONTENT_TYPE_TEXT))) {
  2540.             return $this->errorWrongArgs('Wrong Content.', WebService::CODE_WRONG_ARGUMENTS);
  2541.         }
  2543.         $path = Util::getValidActiveLogByBaseName($this->realContainer, 'AdjustRefundPointsOrElse', 'AdjustRefundPointsOrElse0.txt');
  2544.         $this->createFileJson($path, "\r" . 'adjustRefundPointsOrElse fever XD ' . $request->getContent() . "\r");
  2546.         $data = json_decode($request->getContent(), true);
  2548.         if (!isset($data['nickname']) || !isset($data['uid']) || !isset($data['transactionCodes'])) {
  2549.             return $this->errorWrongArgs('Wrong Arguments', WebService::CODE_WRONG_ARGUMENTS);
  2550.         }
  2552.         $em = $this->getDoctrine()->getManager();
  2554.         $nicknameDataSearch = ['alLicenseUsername' => $data['nickname']];
  2555.         $nicknameLicData = $em->getRepository('App\Entity\AccountLicense')->findBy($nicknameDataSearch);
  2557.         if (empty($nicknameLicData)) {
  2558.             return $this->setStatusCode(WebService::HTTP_CODE_UNAUTHORIZED)
  2559.                             ->respondWithError('Invalid nickname', WebService::CODE_COULD_NOT_AUTHENTICATE);
  2560.         }
  2562.         if ($nicknameLicData[0]->getDeviceUid() != $data['uid']) {
  2563.             $emLev = Util::emLicenseConnection($this->realContainer, $em, $nicknameLicData[0]);
  2565.             $registeredClientsByUID = $emLev->getRepository('App\Structure\Stations')->findBy(['staDeviceCode' => $data['uid']]);
  2567.             if (empty($registeredClientsByUID)) {
  2568.                 $emLev->close();
  2569.                 $this->createFileJson($path, 'UID diferente! o.O' . "\r");
  2570.                 return $this->setStatusCode(WebService::HTTP_CODE_UNAUTHORIZED)
  2571.                                 ->respondWithError('Unknown device', WebService::CODE_UNAUTHORIZED);
  2572.             } else {
  2573.                 $emLev->close();
  2574.             }
  2575.         }
  2577.         if ($nicknameLicData[0]->getAlAccountLicense()->getDeleted()) {
  2578.             return $this->setStatusCode(WebService::HTTP_CODE_UNAUTHORIZED)
  2579.                             ->respondWithError('Inactive Account', WebService::CODE_ACCOUNT_SUSPENDED);
  2580.         }
  2582.         if ($nicknameLicData[0]->getAlLicenseStatus() == AccountLicense::LICENSE_STATUS_INACTIVE) {
  2583.             return $this->setStatusCode(WebService::HTTP_CODE_UNAUTHORIZED)
  2584.                             ->respondWithError('Inactive License', WebService::CODE_ACCOUNT_SUSPENDED);
  2585.         }
  2587.         $responseArrayAux1['msg'] = '';
  2588.         $responseArrayAux1['status'] = WebService::CODE_SUCCESS;
  2589.         $responseArrayAux1['bigbag'] = true;
  2591.         /////////
  2592.         $armorPack = [
  2593.             'request' => $request,
  2594.             'service' => $armor,
  2595.             'log' => $log
  2596.         ];
  2598.         $isCancelationOfCanceledRecords = false;
  2599.         if (strpos($request->getUri(), 'cancelOfCancelationPoint')) {
  2600.             $isCancelationOfCanceledRecords = true;
  2601.         }
  2603.         $data['license'] = $nicknameLicData[0];
  2604.         $data['isReopenCancelation'] = $isCancelationOfCanceledRecords;
  2605.         $armorPack['isReopenCancelation'] = $isCancelationOfCanceledRecords;
  2606.         if (isset($data['customerId'])) {
  2607.             $armorPack['customerId'] = $data['customerId'];
  2608.         }
  2609.         //        dump($request->getUri());
  2610.         //        dump($isCancelationOfCanceledRecords);
  2611.         //        die;
  2613.         $isAdjustTransaction = false;
  2614.         if (isset($data['transactionCodes']) && !empty($data['transactionCodes'])) {
  2615.             $cancelationResponse = PointsUtilPorcessor::proccessBasicTypeCancel($this->realContainer, $em, $data, $armorPack, $path);
  2616.         } else {
  2617.             return $this->errorWrongArgs('Error in transactions parameter', WebService::CODE_WRONG_ARGUMENTS);
  2618.         }
  2620.         //        dump($cancelationResponse);
  2621.         //        die;
  2623.         /*
  2624.           "nickname": "mauricet_311",
  2625.           "uid": "d7ee572cd137dfb7",
  2626.           "dealType": 4,
  2627.           "customerId": "bc328962-4e8a-4437-a43d-59945b82d885",
  2628.           "totalAmount": "33.90",
  2629.           "watchedTime": "2018-01-24 16:48:14"
  2630.          */
  2632.         $indexExistenceToValidate = ['transactionCodes', 'dealType', 'totalAmount', 'watchedTime', 'customerId'];
  2633.         $isCardParams = $this->paramsArrayIndexValidator($data, $indexExistenceToValidate);
  2635.             //        dump($isCardParams);
  2637.         if (isset($isCardParams[0]) && $isCardParams[0]) {
  2638.             $isAdjustTransaction = true;
  2640.             unset($data['transactionCodes']);
  2641.             $responseArrayAux1['msg'] = 'Point transactions processed successfully!';
  2642.             $pointEvaluationResult = PointsUtilPorcessor::analyzePointTransaction($this->realContainer, $em, $nicknameLicData[0], $data, $armorPack);
  2644.             //            dump($pointEvaluationResult);
  2645.             //            die;
  2647.             $responseArrayAux2 = $this->processEvaluatedTransactionResponse($pointEvaluationResult, $data);
  2649.             //            dump($responseArrayAux2);
  2651.             $responseArr = array_merge($responseArrayAux1, $responseArrayAux2);
  2653.             //            dump($responseArr);
  2654.             //            die;
  2655.         } else {
  2656.             //            dump($cancelationResponse);
  2657.             //            die;
  2659.             if (isset($cancelationResponse[0]) && is_string($cancelationResponse[0])) {
  2660.                 $responseArr['msg'] = $cancelationResponse[0];
  2661.                 $responseArr['status'] = WebService::CODE_SUCCESS_NOT_MODIFIED;
  2662.                 $responseArr['bigbag'] = true;
  2663.             } else {
  2664.                 $responseArr['msg'] = $cancelationResponse[0]['msg'];
  2665.                 $responseArr['status'] = WebService::CODE_SUCCESS;
  2666.                 $responseArr['bigbag'] = true;
  2667.                 unset($cancelationResponse[0]['msg']);
  2668.                 $responseArr['transactionsProcessed'] = $cancelationResponse[0];
  2669.             }
  2671.             //            dump($responseArr);
  2672.         }
  2674.         //        if (isset($data['customerId'])) {
  2675.         //            $userTypePointAccount = $em->getRepository('App\Entity\PointAcount')->findBy(['omtClient' => $data['customerId']]);
  2676.         //
  2677.         //            $validationResponse = $this->vaidateIfAnotherTransactionIsInProgress($em, $userTypePointAccount, $data);
  2678.         //
  2679.         //            if (is_array($validationResponse)) {
  2680.         //                $theUrlTrSt = new LicensorGenericTransformer($this->realContainer, $validationResponse);
  2681.         //                $jsonTransform = $theUrlTrSt->transform();
  2682.         //
  2683.         //                $jsonContent = json_encode($jsonTransform);
  2684.         //
  2685.         //                return $this->respondWithItem($jsonContent, $theUrlTrSt);
  2686.         //            } elseif (is_string($validationResponse)) {
  2687.         //                return $this->setStatusCode(WebService::HTTP_CODE_UNAUTHORIZED)
  2688.         //                                ->respondWithError($validationResponse, WebService::CODE_ACCOUNT_SUSPENDED);
  2689.         //            }
  2690.         //        }
  2691.         //        $newIncomingPointTransaction = new PointRelatedRequest();
  2692.         //        if ($isAdjustTransaction) {
  2693.         //            $newIncomingPointTransaction->setType(PointRelatedRequest::TYPE_TRANSACTION_ADJUST);
  2694.         //        } else {
  2695.         //            $newIncomingPointTransaction->setType(PointRelatedRequest::TYPE_TRANSACTION_CANCEL);
  2696.         //        }
  2697.         //        dump($newIncomingPointTransaction);
  2698.         //        die;
  2699.         //        $pointCreatedResult = PointsUtilPorcessor::persistArrayForRequestCopy($em, $request, $nicknameLicData[0], $newIncomingPointTransaction, $data);
  2700.         //
  2701.         //        $fullCommandCallFor = $this->startAllTheCommandToRabbitTransactionProcess($pointCreatedResult, $path);
  2702.         //
  2703.         //        if (is_string($fullCommandCallFor)) {
  2704.         //            return $this->setStatusCode(WebService::HTTP_CODE_INTERNAL_ERROR)
  2705.         //                            ->respondWithError($fullCommandCallFor, WebService::CODE_ERR_UNPROCESSABLE);
  2706.         //        }
  2707.         //
  2708.         //        $pollingResult = $this->pollingAskingIfPointTransactionWasProcessed($em, $pointCreatedResult, $path);
  2709.         //        $this->createFileJson($path, 'The polling json result -> ' . json_encode($pollingResult) . "\r");
  2710.         //        if (isset($pollingResult['wasProcessed']) && $pollingResult['wasProcessed']) {
  2711.         //            $cancelationResponse = json_decode($pollingResult['theTransaction']->getJsonResponse(), true);
  2712.         //        } else {
  2713.         //            $cancelationResponse = [];
  2714.         //        }
  2716.         $loyaltyConfiguration = $em->getRepository('App\Entity\RestaurantLoyaltyConfiguration')->findBy(['license' => $nicknameLicData[0]->getId()]);
  2718.         if (isset($loyaltyConfiguration[0]) && (!$loyaltyConfiguration[0]->getUseLocalPoints() && !$loyaltyConfiguration[0]->getUseGlobalPoints())) {
  2719.             $this->createFileJson($path, 'Loyalty functions not configured yet o.O' . "\r");
  2720.             return $this->setStatusCode(WebService::HTTP_CODE_UNAUTHORIZED)
  2721.                             ->respondWithError('Loyalty functions not configured yet', WebService::CODE_ACCOUNT_SUSPENDED);
  2722.         } elseif (!isset($loyaltyConfiguration[0])) {
  2723.             $this->createFileJson($path, 'Loyalty functions configuration record not found o.O' . "\r");
  2724.             return $this->setStatusCode(WebService::HTTP_CODE_UNAUTHORIZED)
  2725.                             ->respondWithError('Loyalty functions configuration record not found!', WebService::CODE_ACCOUNT_SUSPENDED);
  2726.         }
  2728.         if (!$isAdjustTransaction && isset($cancelationResponse[1]) && $cancelationResponse[1]) {
  2729.             $this->createFileJson($path, 'Processgin cacelation result!' . "\r");
  2730.         } elseif ($isAdjustTransaction) {
  2731.             $this->createFileJson($path, 'Processgin adjust result!' . "\r");
  2732.             $responseArrayAux1['status'] = WebService::CODE_SUCCESS;
  2733.             $responseArrayAux1['msg'] = 'Point transactions adjust processed successfully!';
  2735.             //            $responseArrayAux2 = $this->processEvaluatedTransactionResponse($cancelationResponse, $data);
  2737.             $responseArr = array_merge($responseArrayAux1, $responseArrayAux2);
  2738.         }
  2740.         //        dump($responseArr);
  2741.         //        die;
  2743.         $order = Paginator::filterPaginatorParameters([], $request, true);
  2745.         $pointAccountByClientRepository = $em->getRepository('App\Entity\TypePointAcount');
  2746.         $pointAccountByClient = $pointAccountByClientRepository->findTypePointAccountByRestaurant(
  2747.                 $request, $this->realContainer, [
  2748.             'restaurant' => $nicknameLicData[0]->getId(),
  2749.             'client' => $cancelationResponse[1]
  2750.                 ], $order, $loyaltyConfiguration[0]->getMinimumPointAmountToExchange(), $nicknameLicData[0]->getId(), $armor, $log, $path);
  2752.         $responseArr['bigbag'] = true;
  2753.         //            $responseArr['status'] = WebService::CODE_SUCCESS;
  2754.         //            $responseArr['msg'] = $cancelationResponse[0]['msg'];
  2755.         //            unset($cancelationResponse[0]['msg']);
  2756.         //            $responseArr['transactionsProcessed'] = $cancelationResponse[0];
  2757.         $responseArr['client'] = $pointAccountByClient['accounts'][0];
  2759.         $this->createFileJson($path, 'The response array -> ' . json_encode($responseArr) . "\r");
  2761.         $theUrlTrSt = new LicensorGenericTransformer($this->realContainer, $responseArr);
  2762.         $xxArray = $theUrlTrSt->transform();
  2764.         $jsonContent = json_encode($xxArray);
  2766.         //        if (isset($validationResponse)) {
  2767.         //            $this->markAsNoOtherTransactionInProgress($em, $validationResponse);
  2768.         //        }
  2769.         //        $this->closePointTransactionProcessInRabbit($em, $pollingResult['theTransaction'], $path);
  2771.         return $this->respondWithItem($jsonContent, $theUrlTrSt);
  2772.     }
  2774.     /**
  2775.      * @param type $em
  2776.      * @param type $transactionRecord
  2777.      * @param type $path
  2778.      * @return boolean
  2779.      */
  2780.     public function closePointTransactionProcessInRabbit($em, $transactionRecord, $path) {
  2781.         try {
  2782.             $transactionRecord->setDateDelivered(Util::getCurrentDate());
  2783.             $transactionRecord->setStatus(RabbitRelatedGenericEntity::STATUS_DELIVERED);
  2785.             $em->persist($transactionRecord);
  2786.             $em->flush();
  2788.             $this->createFileJson($path, 'Transaction status updated!' . "\r");
  2789.             return true;
  2790.         } catch (\Exception $ex) {
  2791.             Utilx::updateSyncRecordError($this->em, $this->thePointTransactionRecord, $ex->getMessage());
  2793.             $this->createFileJson($path, 'Error updating transaction record! ' . $ex->getMessage() . "\r");
  2794.             return false;
  2795.         }
  2796.     }
  2798.     /**
  2799.      * @param string $pointEvaluationResult
  2800.      * @param type $params
  2801.      * @return type
  2802.      */
  2803.     public function processEvaluatedTransactionResponse($pointEvaluationResult, $params) {
  2804.         if (is_array($pointEvaluationResult)) {
  2805.             if (isset($pointEvaluationResult[0]) && count($pointEvaluationResult) == 1 && isset($pointEvaluationResult[0]['nonAplicationMsg'])) {
  2806.                 if ($pointEvaluationResult[0]['nonAplicationMsg'] == 'Little remaining amount to proccess') {
  2807.                     $responseArray['msg'] = 'No point achieved with the remaining amount.. ';
  2808.                     $responseArray['status'] = WebService::CODE_SUCCESS;
  2809.                     $responseArray['approvedPointsTransactions'] = [];
  2810.                 } elseif (strpos($pointEvaluationResult[0]['nonAplicationMsg'], 'inumum amount purchase')) {
  2811.                     $responseArray['msg'] = 'No point achieved because minimum purchase amount not reached.. ';
  2812.                     $responseArray['status'] = WebService::CODE_SUCCESS;
  2813.                     $responseArray['approvedPointsTransactions'] = [];
  2814.                 } else {
  2815.                     if (strpos($pointEvaluationResult[0]['nonAplicationMsg'], 'enough points!')) {
  2816.                         $responseArray['msg'] = $pointEvaluationResult[0]['nonAplicationMsg'];
  2817.                         $responseArray['status'] = WebService::HTTP_CODE_PAYMENT_REQUIRED;
  2818.                     } else {
  2819.                         $responseArray['msg'] = $pointEvaluationResult[0]['nonAplicationMsg'];
  2820.                         $responseArray['status'] = WebService::CODE_SUCCESS_NOT_MODIFIED;
  2821.                     }
  2822.                 }
  2823.             } elseif (isset($pointEvaluationResult[0]) && count($pointEvaluationResult) == 1 && ($params['dealType'] == TypePtsGenericDefinitionRules::TYPE_PURCHASE_WITH_LOCAL_PTS || $params['dealType'] == TypePtsGenericDefinitionRules::TYPE_PURCHASE_WITH_GLOBAL_PTS)) {
  2824.                 $responseArray['approvedPointsTransactions'] = $pointEvaluationResult[0];
  2825.             } elseif (empty($pointEvaluationResult)) {
  2826.                 $responseArray['msg'] = 'No point transactions were made.. ';
  2827.                 $responseArray['status'] = WebService::CODE_SUCCESS_NOT_MODIFIED;
  2828.             } else {
  2829.                 $responseArray['approvedPointsTransactions'] = $pointEvaluationResult;
  2830.             }
  2831.         } else {
  2832.             if (strpos($pointEvaluationResult, 'please try again later')) {
  2833.                 $responseArray['msg'] = 'Insufficient Loyalty Cash balance to redeem the order.. ' . $pointEvaluationResult;
  2834.                 $responseArray['status'] = WebService::CODE_ERR_NOT_FOUND;
  2835.             } else {
  2836.                 $responseArray['msg'] = 'Insufficient Loyalty Cash balance to redeem the order.. ' . $pointEvaluationResult;
  2837.                 $responseArray['status'] = WebService::CODE_SUCCESS_NOT_MODIFIED;
  2838.             }
  2839.         }
  2841.         $responseArray['bigbag'] = true;
  2843.         return $responseArray;
  2844.     }
  2846.     /**
  2847.      * @author Felipe Bautista <aarango@kijho.com> 22/02/19
  2848.      * @param Request $request
  2849.      * @return type 
  2850.      */
  2851.     public function linkingAccounts(Request $request) {
  2852.         if ($request->getMethod() !== WebService::REQUEST_METHOD_POST) {
  2853.             return $this->errorNotAllowedMethod('Method not allowed. Use ' . WebService::REQUEST_METHOD_POST . " method");
  2854.         }
  2856.         if (!(0 === strpos($request->headers->get('Content-Type'), WebService::CONTENT_TYPE_STRUCTURE) || 0 === strpos($request->headers->get('Content-Type'), WebService::CONTENT_TYPE_TEXT))) {
  2857.             return $this->errorWrongArgs('Wrong Content.', WebService::CODE_WRONG_ARGUMENTS);
  2858.         }
  2859.         $em = $this->getDoctrine()->getManager();
  2861.         $data = json_decode($request->getContent(), true);
  2862.         if (!isset($data['nickname']) || !isset($data['uid'])) {
  2863.             return $this->errorWrongArgs('Wrong Arguments', WebService::CODE_WRONG_ARGUMENTS);
  2864.         }
  2866.         $nickname = $em->getRepository('App\Entity\AccountLicense')->findBy(['alLicenseUsername' => $data['nickname']]);
  2867.         if (!isset($nickname) || $nickname == []) {
  2868.             return $this->errorWrongArgs('nickname not found', WebService::CODE_WRONG_ARGUMENTS);
  2869.         }
  2871.         if ($nickname[0]->getDeviceUid() != $data['uid']) {
  2872.             $emLev = Util::emLicenseConnection($this->realContainer, $em, $nickname[0]);
  2874.             $registeredClientsByUID = $emLev->getRepository('App\Structure\Stations')->findBy(['staDeviceCode' => $data['uid']]);
  2876.             if (empty($registeredClientsByUID)) {
  2877.                 $emLev->close();
  2878.                 return $this->setStatusCode(WebService::HTTP_CODE_UNAUTHORIZED)
  2879.                                 ->respondWithError('Unknown device', WebService::CODE_UNAUTHORIZED);
  2880.             } else {
  2881.                 $emLev->close();
  2882.             }
  2883.         }
  2885.         $uid = $em->getRepository('App\Entity\AccountLicense')->findBy(['deviceUid' => $data['uid']]);
  2886.         if (!isset($uid) || $uid == []) {
  2887.             return $this->errorWrongArgs('uid not found', WebService::CODE_WRONG_ARGUMENTS);
  2888.         }
  2890.         $omtClients = $em->getRepository('App\Entity\OmtClient')->searchClientToLinking($data);
  2892.         if (count($omtClients) == 2) {
  2893.             $pointsByClients = $em->getRepository('App\Entity\PointAcount')->searchCustomerPointsAccountsToLink($omtClients);
  2896.             $targetCustomer = $pointsByClients[0];
  2897.             $originalCustomer = $pointsByClients[1];
  2899.             $targetClient = $em->getRepository('App\Entity\OmtClient')->find($targetCustomer['client']);
  2900.             $originalClient = $em->getRepository('App\Entity\OmtClient')->find($originalCustomer['client']);
  2902.             if ($targetClient->getEmail() === null && $originalClient->getEmail() !== null) {
  2903.                 $email = $originalClient->getEmail();
  2904.                 $originalClient->setEmail(null);
  2905.                 $em->persist($originalClient);
  2906.                 $em->flush();
  2907.                 $targetClient->setEmail($email);
  2908.                 $em->persist($targetClient);
  2909.                 $em->flush();
  2910.             }
  2912.             if ($targetClient->getPhone() === null && $originalClient->getPhone() !== null) {
  2913.                 $phone = $originalClient->getPhone();
  2914.                 $originalClient->setPhone(null);
  2915.                 $em->persist($originalClient);
  2916.                 $em->flush();
  2917.                 $targetClient->setPhone($phone);
  2918.                 $em->persist($targetClient);
  2919.                 $em->flush();
  2920.             }
  2922.             $typePointDataOriginalCustomer = $em->getRepository('App\Entity\TypePointAcount')->findPointsToTransfer($originalCustomer['id']);
  2923.             $typePointDataTargetCustomer = $em->getRepository('App\Entity\TypePointAcount')->findPointsToTransfer($targetCustomer['id']);
  2925.             foreach ($typePointDataTargetCustomer AS $key1 => $pointTargetCustomer) {
  2926.                 foreach ($typePointDataOriginalCustomer AS $key2 => $pointOriginalCustomer) {
  2927.                     if ($pointOriginalCustomer['license'] == $pointTargetCustomer['license'] && $pointOriginalCustomer['typePoint'] == $pointTargetCustomer['typePoint']) {
  2929.                         $amount = $pointOriginalCustomer['amount'] + $pointTargetCustomer['amount'];
  2931.                         $targetLink = $em->getRepository('App\Entity\TypePointAcount')->find($pointTargetCustomer['id']);
  2932.                         $homeLink = $em->getRepository('App\Entity\TypePointAcount')->find($pointOriginalCustomer['id']);
  2934.                         $targetLink->setAmount($amount);
  2935.                         $em->persist($targetLink);
  2937.                         $homeLink->setAmount(0);
  2938.                         $em->persist($homeLink);
  2939.                         $em->flush();
  2941.                         $linkingTransactionOfPoints = $this->linkingOfTransactionOfPoints($em, $homeLink, $targetLink);
  2942.                     } else {
  2943.                         $homeLink = $em->getRepository('App\Entity\TypePointAcount')->findBy(["typePoint" => $pointOriginalCustomer['typePoint'], "pointAcount" => $pointTargetCustomer['pointAcount'], "license" => $pointOriginalCustomer['license']]);
  2944.                         if (!$homeLink) {
  2946.                             $homeLink = $em->getRepository('App\Entity\TypePointAcount')->find($pointOriginalCustomer['id']);
  2947.                             $homeLink->setAmount(0);
  2948.                             $em->persist($homeLink);
  2950.                             $typePointData = $em->getRepository('App\Entity\TypePoint')->find($pointOriginalCustomer['typePoint']);
  2951.                             $pointAccountData = $em->getRepository('App\Entity\PointAcount')->find($pointTargetCustomer['pointAcount']);
  2952.                             if (isset($pointOriginalCustomer['license'])) {
  2953.                                 $accountLicenseData = $em->getRepository('App\Entity\AccountLicense')->find($pointOriginalCustomer['license']);
  2954.                             } else {
  2955.                                 $accountLicenseData = null;
  2956.                             }
  2957.                             $country = $em->getRepository('App\Entity\Country')->find($pointOriginalCustomer['countryId']);
  2959.                             $acountToken = ['food' => '123'];
  2960.                             while (!empty($acountToken)) {
  2961.                                 $tokenAcount = Encryptor::encodeInfo(Utilx::randomPassword(32), 5);
  2962.                                 $acountToken = $em->getRepository('App\Entity\TypePointAcount')->findBy(['acountToken' => $tokenAcount]);
  2963.                             }
  2965.                             $targetLink = new TypePointAcount();
  2966.                             $targetLink->setTypePoint($typePointData);
  2967.                             $targetLink->setPointAcount($pointAccountData);
  2968.                             $targetLink->setAmount($pointOriginalCustomer['amount']);
  2969.                             $targetLink->setStartingDate($pointOriginalCustomer['startingDate']);
  2970.                             $targetLink->setCountryId($country);
  2971.                             $targetLink->setPointArmAcount($pointOriginalCustomer['pointArmAcount']);
  2972.                             $targetLink->setAcountToken($tokenAcount);
  2973.                             $targetLink->setArmIdentifier($pointOriginalCustomer['armIdentifier']);
  2974.                             $targetLink->setLicense($accountLicenseData);
  2975.                             $em->persist($targetLink);
  2976.                             $em->flush();
  2977.                             $linkingTransactionOfPoints = $this->linkingOfTransactionOfPoints($em, $homeLink, $targetLink);
  2978.                         }
  2979.                     }
  2980.                 }
  2981.             }
  2982.             $linkingCard = $this->linkingOfCards($em, $originalClient->getId(), $targetClient->getId());
  2983.         }
  2985.         $responseArr['msg'] = 'Successful account linking';
  2986.         $responseArr['status'] = WebService::CODE_SUCCESS;
  2987.         $responseArr['bigbag'] = true;
  2989.         $theUrlTrSt = new LicensorGenericTransformer($this->realContainer, $responseArr);
  2990.         $xxArray = $theUrlTrSt->transform();
  2991.         $jsonContent = json_encode($xxArray);
  2992.         return $this->respondWithItem($jsonContent, $theUrlTrSt);
  2993.     }
  2995.     /**
  2996.      * Permite vincular las tarjetas de un cliente origen  a un cliente destino
  2997.      */
  2998.     public function linkingOfCards($em, $idClientHome, $idClientLink) {
  2999.         $cards = $em->getRepository('App\Entity\CardAsClient')->findBy(['client' => $idClientHome]);
  3000.         if ($cards) {
  3001.             $clientLink = $em->getRepository('App\Entity\OmtClient')->find($idClientLink);
  3002.             foreach ($cards as $key => $value) {
  3003.                 $value->setClient($clientLink->getId());
  3004.                 $value->setValidateCard(2);
  3005.                 $em->persist($value);
  3006.                 $em->flush();
  3007.             }
  3008.         }
  3009.         return true;
  3010.     }
  3012.     /**
  3013.      * Permite vincular los point deal de un point account a otro point account
  3014.      * los parametros que recibe son type point accounts
  3015.      */
  3016.     public function linkingOfTransactionOfPoints($em, $typePointAccountHome, $typePointAccountTarget) {
  3017.         $pointDealLinking = $em->getRepository('App\Entity\PointDeal')->findBy(['pointAcount' => $typePointAccountHome->getPointAcount(), 'typePointAcount' => $typePointAccountHome->getId()]);
  3018.         if ($pointDealLinking) {
  3019.             $typePointAccountData = $em->getRepository('App\Entity\TypePointAcount')->find($typePointAccountTarget->getId());
  3020.             $pointAccountData = $em->getRepository('App\Entity\PointAcount')->find($typePointAccountTarget->getPointAcount());
  3021.             foreach ($pointDealLinking as $key => $value) {
  3022.                 $value->setPointAcount($pointAccountData);
  3023.                 $value->setTypePointAcount($typePointAccountData);
  3024.                 $em->persist($value);
  3025.                 $em->flush();
  3026.             }
  3027.         }
  3028.         return true;
  3029.     }
  3031.     public function updateLoyaltyConfig(Request $request, $id, $type, $toClose = null) {
  3032.         // if ($request->getMethod() !== WebService::REQUEST_METHOD_GET) {
  3033.         //     return $this->errorNotAllowedMethod('Method not allowed. Use ' . WebService::REQUEST_METHOD_POST . " method");
  3034.         // }
  3035.         $user = $this->get('security.token_storage')->getToken()->getUser();
  3036.         $em = $this->getDoctrine()->getManager();
  3037.         $localRatio = 0;
  3038.         $globalRatio = 0;
  3039.         
  3040.         // obtenemos los parametros de la peticion
  3041.         $params = $request->request->all();
  3042.         if (isset($params['points_adqui_redem_rules'])){
  3043.             $params = $params['points_adqui_redem_rules'];
  3044.             // dump($params);die;
  3045.         }
  3046.         // $params = isset($params['points_adqui_redem_rules'])$params['points_adqui_redem_rules'];
  3047.         // dump($params);die;
  3048.         $path = Util::getValidActiveLogByBaseName($this->realContainer, 'updateRestaurantLoyaltyConfig', 'updateRestaurantLoyaltyConfig0.txt');
  3049.         $this->createFileJson($path, "\r" . 'updateRestaurantLoyaltyConfig fever XD ' . $request->getContent() . "\r");
  3051.         $accountLicense = $em->getRepository('App\Entity\AccountLicense')->find($id);
  3052.         // consultamos si existe la configuracion para el restaurante si no creamos una nueva
  3053.         $entities = $em->getRepository('App\Entity\RestaurantLoyaltyConfiguration')->findBy(["license" => $id]);
  3055.         if (!isset($entities) || empty($entities)) {
  3056.             $entities = new RestaurantLoyaltyConfiguration();
  3057.             $entities->setDateCreated(new \DateTime('now'));
  3058.             $entities->setUseLocalPoints(isset($params['minimumPointAmountToExchange']) && $params['loyalty'] != ""?(boolean)$params['loyalty']:false);
  3059.             $accountLicense->setCaptivePortalStatus(isset($params['minimumPointAmountToExchange']) && $params['loyalty'] != ""?(boolean)$params['loyalty']:false);
  3060.             $entities->setUseGlobalPoints(false);
  3061.             $entities->setMinimumPointAmountToExchange(isset($params['minimumPointAmountToExchange']) && $params['minimumPointAmountToExchange'] != ""?$params['minimumPointAmountToExchange']:1);
  3062.             $entities->setLicense($accountLicense);
  3063.             $em->persist($entities);
  3064.             $em->persist($accountLicense);
  3065.             $em->flush();
  3067.             $saveLevel = $this->saveSyncLoyalty($em, $accountLicense,$params);
  3068.             
  3069.             if (isset($params['captivePortalStatus']) && $params['captivePortalStatus']) {
  3070.                 // Solo captive portal está siendo activado
  3071.                 Util::logAction(
  3072.                     $em, 'RestaurantLoyaltyConfiguration', 
  3073.                     $id, ActionHistory::ENABLE_CAPTIVE_PORTAL, $user->getUsName().' '.$user->getUsLastName(), [
  3074.                         'msg' => 'Enabled captive portal',
  3075.                         'userId' => $user->getId()
  3076.                 ]);
  3077.             } else if (isset($params['loyalty']) && $params['loyalty']) {
  3078.                 // Solo loyalty está siendo activado
  3079.                 Util::logAction(
  3080.                     $em, 'RestaurantLoyaltyConfiguration', 
  3081.                     $id, ActionHistory::ENABLE_LOYALTY, $user->getUsName().' '.$user->getUsLastName(), [
  3082.                         'new_status' => ActionHistory::ACTION_CREATE,
  3083.                         'userId' => $user->getId()
  3084.                 ]);
  3085.             } else if (isset($params['loyalty']) && !$params['loyalty']) {
  3086.                 // Solo loyalty está siendo desactivado
  3087.                 Util::logAction(
  3088.                     $em, 'RestaurantLoyaltyConfiguration', 
  3089.                     $id, ActionHistory::DISABLE_LOYALTY, $user->getUsName().' '.$user->getUsLastName(), [
  3090.                         'new_status' => ActionHistory::ACTION_DISABLED,
  3091.                         'userId' => $user->getId()
  3092.                 ]);
  3093.             }
  3094.         } else {
  3095.             $entities = $entities[0];
  3096.             $oldStatus = $entities->getUseLocalPoints();
  3098.             if(isset($params['minimumPointAmountToExchange'])){
  3099.                 $entities->setUseLocalPoints(isset($params['minimumPointAmountToExchange']) && $params['loyalty'] != ""?(boolean)$params['loyalty']:false);
  3100.                 $accountLicense->setCaptivePortalStatus(isset($params['minimumPointAmountToExchange']) && $params['loyalty'] != ""?(boolean)$params['loyalty']:false);
  3101.                 $entities->setMinimumPointAmountToExchange(isset($params['minimumPointAmountToExchange']) && $params['minimumPointAmountToExchange'] != ""?$params['minimumPointAmountToExchange']:1);
  3102.                 $entities->setUseLocalPoints($params['loyalty']);
  3103.                 $entities->setMinimumPointAmountToExchange($params['minimumPointAmountToExchange']);
  3104.                 $em->persist($entities);
  3105.                 $em->persist($accountLicense);
  3106.                 $em->flush();
  3107.                 // TYPE_LOYALTY_NONE
  3109.                 $saveLevel = $this->saveSyncLoyalty($em, $accountLicense, $params);
  3110.                 
  3111.                 if (isset($params['captivePortalStatus'])) {
  3112.                     $actionType = $params['captivePortalStatus'] ? ActionHistory::ENABLE_CAPTIVE_PORTAL : ActionHistory::DISABLE_CAPTIVE_PORTAL;
  3113.                     Util::logAction(
  3114.                         $em, 'RestaurantLoyaltyConfiguration', 
  3115.                         $id, $actionType, $user->getUsName().' '.$user->getUsLastName(), [
  3116.                             'msg' => $params['captivePortalStatus'] ? 'Enabled captive portal' : 'Disabled captive portal',
  3117.                             'userId' => $user->getId()
  3118.                     ]);
  3119.                 } else if (isset($params['loyalty'])) {
  3120.                     $actionType = $params['loyalty'] ? ActionHistory::ENABLE_LOYALTY : ActionHistory::DISABLE_LOYALTY;
  3121.                     Util::logAction(
  3122.                         $em, 'RestaurantLoyaltyConfiguration', 
  3123.                         $id, $actionType, $user->getUsName().' '.$user->getUsLastName(), [
  3124.                             'old_status' => $oldStatus, 
  3125.                             'new_status' => $entities->getUseLocalPoints(),
  3126.                             'userId' => $user->getId()
  3127.                     ]);
  3128.                 }
  3129.             }
  3130.         }
  3132.         if(isset($saveLevel) && !$saveLevel){
  3133.             return $this->render('AccountLicense\formPointsAdquiRedemRule.html.twig', [
  3134.                 'entities' => $entities,
  3135.                 'toClose' => $toClose,
  3136.                 'formPtsAdquiRedemRules' => null,
  3137.                 'localPoint' => null,
  3138.                 'ratioPointLocal' => null,
  3139.                 'localRatio' => $localRatio,
  3140.                 'globalRatio' => $globalRatio,
  3141.                 'message' => "Error in save"
  3142.             ]);
  3143.         }
  3144.         
  3145.         if ($entities->getLicense()) {
  3146.             PointsUtilPorcessor::createRulesForLocalPointLoyaltyConfiguration($em, $entities->getLicense(), $path);
  3147.         }
  3149.         $points = $em->getRepository('App\Entity\TypePoint')->findAll();
  3150.         foreach ($points as $typePoint) {
  3151.             if ($typePoint->getType() == TypePoint::TYPE_LOCAL) {
  3152.                 $localRatio = $typePoint->getCashRatio();
  3153.                 continue;
  3154.             }
  3155.             if ($typePoint->getType() == TypePoint::WORK_AS_GLOBAl) {
  3156.                 $globalRatio = $typePoint->getCashRatio();
  3157.             }
  3158.         }
  3160.         $basicPurchaseRulesArray = PointsUtilPorcessor::getTheBasicPurchaseRulesArray();
  3162.         // $form = $this->createForm(RestaurantLoyaltyConfig::class, $entities, [
  3163.         //     'action' => $this->generateUrl('update_loyalty_config'),
  3164.         //     'method' => 'POST'
  3165.         // ]);
  3167.         // $form = $this->createForm(PointsAdquiRedemRules::class, $entities, [
  3168.         //     'action' => $this->generateUrl('update_adqui_redem_rules'),
  3169.         //     'method' => 'POST'
  3170.         // ]);
  3172.         // if ($type == 2) {
  3173.         $entitiesadquiRedemRule = $em->getRepository('App\Entity\PtsAdquiRedemRules')->findBy(["license" => $entities->getLicense(), "parentDefinition" => $basicPurchaseRulesArray[0]]);
  3174.         // dump($entitiesadquiRedemRule);die;
  3175.         if (!isset($entitiesadquiRedemRule[0])) {
  3176.             $entitiesadquiRedemRule = $em->getRepository('App\Entity\PtsAdquiRedemRules')->findBy(["parentDefinition" => $basicPurchaseRulesArray[0]]);
  3177.         }
  3179.         $ptsRatePercentage = 0; 
  3180.         $ratioPointLocal = 0;
  3181.         if (isset($entitiesadquiRedemRule[0])) {
  3183.             if ($entitiesadquiRedemRule[0]->getMinimumPurchase() == null) {
  3184.                 $entitiesadquiRedemRule[0]->setMinimumPurchase(0);
  3185.             }
  3187.             $ratioPointLocal = $entitiesadquiRedemRule[0]->getPtsRate() * 100;
  3188.             $entitiesadquiRedemRule[0]->setPtsRate($ratioPointLocal);
  3190.             // $formPtsAdquiRedemRules = $this->createForm(PointsAdquiRedemRules::class, $entitiesadquiRedemRule[0], [
  3191.             //     'action' => $this->generateUrl('update_adqui_redem_rules'),
  3192.             //     'method' => 'POST'
  3193.             // ]);
  3194.             
  3196.             $formPtsAdquiRedemRules = $this->createForm(PointsAdquiRedemRules::class, $entitiesadquiRedemRule[0], [
  3197.                 'action' => $this->generateUrl('update_adqui_redem_rules'),
  3198.                 'minimumPointAmountToExchange' => $entities->getMinimumPointAmountToExchange(),
  3199.                 'method' => 'POST'
  3200.             ]);
  3201.             
  3203.             return $this->render('AccountLicense\formPointsAdquiRedemRule.html.twig', [
  3204.                         'entities' => $entities,
  3205.                         'toClose' => $toClose,
  3206.                         'formPtsAdquiRedemRules' => $formPtsAdquiRedemRules->createView(),
  3207.                         'localPoint' => $entitiesadquiRedemRule[0]->getPointType()->getId(),
  3208.                         'ratioPointLocal' => $ratioPointLocal,
  3209.                         'localRatio' => $localRatio,
  3210.                         'globalRatio' => $globalRatio
  3211.             ]);
  3212.         } else {
  3213.             return $this->render('AccountLicense\formPointsAdquiRedemRule.html.twig', [
  3214.                         'entities' => $entities,
  3215.                         'toClose' => $toClose,
  3216.                         'formPtsAdquiRedemRules' => null,
  3217.                         'localPoint' => null,
  3218.                         'ratioPointLocal' => null,
  3219.                         'localRatio' => $localRatio,
  3220.                         'globalRatio' => $globalRatio
  3221.             ]);
  3222.         }
  3223.         // } else {
  3224.         //     return $this->render('AccountLicense\restaurantLoyaltyConfig.html.twig', [
  3225.         //                 'entities' => $entities,
  3226.         //                 'form' => $form->createView(),
  3227.         //                 'localRatio' => $localRatio,
  3228.         //                 'globalRatio' => $globalRatio
  3229.         //     ]);
  3230.         // }
  3231.     }
  3233.     public function updatePointsAdquiRedemRules(Request $request) {
  3234.         $data = $request->request->getIterator()->getArrayCopy();
  3235.         $em = $this->getDoctrine()->getManager();
  3236.         $params = $data['points_adqui_redem_rules'];
  3237.         // dd($data, $request);
  3238.         
  3239.         // En caso de no tener el tipo de puntos(Locales o globales), elegimos por defecto locales
  3240.         $params['typePoint'] = isset($params['typePoint'])? $params['typePoint']:'a00000a1-0aaa-00a0-a00a-0a0a00aaa0a0';
  3242.         // dump($params);die;  
  3243.         //  $ratioPointLocal = $params['ratioPointLocal'] * 100;
  3244.         // $ratioPointLocal = $params['ratioPointLocal'];
  3245.         $ratioPointLocal = $params['ptsRate'];
  3247.         $ptsRatePercentage = $ratioPointLocal / 100;
  3249.         // dump($ratioPointLocal);
  3250.         // dump($ptsRatePercentage);
  3251.         // die;
  3253.         $basicPurchaseRulesArray = PointsUtilPorcessor::getTheBasicPurchaseRulesArray();
  3254.         foreach ($basicPurchaseRulesArray as $basicPurchaseRule) {
  3255.             $entitiesadquiRedemRule = $em->getRepository('App\Entity\PtsAdquiRedemRules')->findBy(["pointType" => $params['typePoint'], "license" => $params['license'], "parentDefinition" => $basicPurchaseRule]);
  3256.             foreach ($entitiesadquiRedemRule as $adquiRedemLocalRule) {
  3257.                 $adquiRedemLocalRule->setPtsRate($ptsRatePercentage);
  3258.                 $adquiRedemLocalRule->setMinimumPurchase($params['minimumPurchase']);
  3259.                 $em->persist($adquiRedemLocalRule);
  3260.                 $em->flush(); 
  3261.             }
  3262.         }
  3264.         $configLoyaltyOmt = $this->createOrUpdateLoyaltyConfigurationOmt($em, $params);
  3266.         return $this->updateLoyaltyConfig($request, $params['license'], 2, true); 
  3267.     }
  3269.     /**
  3270.      * Funcion secundaria de la configuración del delivery, para realizar determinadas acciones
  3271.      * @author Leandro Román Londoño - 03/03/2020
  3272.      */
  3273.     public function deliveryActionsConfiguration(Request $request, $id){
  3274.         $params = $request->request->getIterator()->getArrayCopy();
  3275.         $em = $this->getDoctrine()->getManager();
  3276.         $response = new Response();
  3277.         $accountLicenseData = $em->getRepository('App\Entity\AccountLicense')->find($id);
  3278.         $emLev = Util::emLicenseConnection($this->realContainer, $em, $accountLicenseData);
  3279.         if (isset($params['action'])) {
  3280.             /**
  3281.              * Si el params contiene un id, se refiere que va a modificar ó eliminar
  3282.              */
  3283.             
  3284.             if (isset($params['id'])) {
  3285.                 $entity = $emLev->getRepository('App\Structure\ConfRangedelivery')->find($params['id']);
  3286.             }else{
  3287.                 $entity = new ConfRangedelivery();
  3288.             }
  3290.             if ($entity != '' || $entity != null) {
  3291.                 $entity = $this->selectActionDelivery($entity, $params, $emLev);
  3292.                 $response->setStatusCode(200);
  3293.                 $responseArr['status'] = WebService::CODE_SUCCESS;
  3294.             }else{
  3295.                 $response->setStatusCode(400);
  3296.                 $responseArr['status'] = WebService::HTTP_CODE_BAD_REQUEST;
  3297.             }
  3298.             
  3299.             if ($entity != '') {
  3300.                 $emLev->persist($entity);
  3301.                 $emLev->flush();
  3302.             }
  3303.         }
  3305.         $responseArr['msg'] = 'Delivery update';
  3306.         $responseArr['bigbag'] = true;
  3307.         $responseArr['status'] = true;
  3309.         $theUrlTrSt = new LicensorGenericTransformer($this->realContainer, $responseArr);
  3310.         $xxArray = $theUrlTrSt->transform();
  3312.         $jsonContent = json_encode($xxArray);
  3314.         return $this->respondWithItem($jsonContent, $theUrlTrSt);
  3315.     }
  3317.     /**
  3318.      * Funcion principal de la configuración del delivery, para cargar todas sus funciones
  3319.      * @author Leandro Román Londoño - 03/03/2020
  3320.      */
  3321.     public function deliveryConfiguration(Request $request, $id){
  3322.         $em = $this->getDoctrine()->getManager();
  3323.         $accountLicenseData = $em->getRepository('App\Entity\AccountLicense')->find($id);
  3324.         $emLev = Util::emLicenseConnection($this->realContainer, $em, $accountLicenseData);
  3325.         $entity = $emLev->getRepository('App\Structure\ConfRangedelivery')->searchAllDates();
  3326.         $flag = 0;
  3327.         $typeDelivery = ConfRangedelivery::CONF_TYPE_DELIVERY_RECHARGE_BY_DISTANCE;
  3328.         $statusSetting = ConfRangedelivery::CONF_TYPE_STATUS_INACTIVE;
  3329.         $typeChecked = 0;
  3330.         
  3331.         /**
  3332.          * Se itera sobre el dato consultado para enviar a la vista lo que necesita
  3333.          */
  3334.         foreach ($entity as $key => $disable) {
  3335.             if ($disable['confTypeDelivery'] == ConfRangedelivery::CONF_TYPE_DELIVERY_PLAIN_RECHARGE) {
  3336.                 $disabled[] = $disable['confTypeDelivery'];
  3337.             }else if ($disable['confTypeNoRechargeDefined'] == ConfRangedelivery::CONF_TYPE_DELIVERY_NOT_RECHARGE) {
  3338.                 $flag = 1;
  3339.             }
  3341.             if($disable['confStatus'] == ConfRangedelivery::CONF_TYPE_STATUS_ACTIVE){
  3342.                 $typeDelivery = $disable['confTypeDelivery'];
  3343.                 $statusSetting = $disable['confStatus'];
  3344.                 $typeChecked = $disable['confTypeRange'];
  3345.             }
  3347.         }
  3349.         if (isset($disabled)) {
  3350.             $disabled = count($disabled);
  3351.         }else{
  3352.             $disabled = 0;
  3353.         }
  3355.         /**
  3356.          * Carga la vista principal de la configuración del delivery, con los parametros consultados
  3357.          */
  3358.         return $this->render('AccountLicense\deliveryConfiguration.html.twig', [
  3359.             'ide' => $id,
  3360.             'params' => $entity,
  3361.             'disabled' => $disabled,
  3362.             'noRecharge' => $flag,
  3363.             'settingActive' => [
  3364.                 'typeDelivery' => $typeDelivery,
  3365.                 'statusSetting' => $statusSetting,
  3366.                 'typeChecked' => $typeChecked
  3367.             ]
  3368.         ]);
  3369.     }
  3371.     /**
  3372.      * Funcion privada de la configuración del delivery
  3373.      * Mediante una accion, se podra editar, crear, eliminar y ademas de eso configurar el no recharge y la activacion
  3374.      * de una configuración
  3375.      * @author Leandro Román Londoño - 03/03/2020
  3376.      */
  3377.     private function selectActionDelivery($entity, $params, $emLev){
  3378.         switch ($params['action']) {
  3379.             
  3380.             case 'add':
  3381.                 $entity = $this->registerNewDeliveryRangeOrPlain($entity, $params);
  3382.                 $emLev->persist($entity);
  3383.                 $emLev->flush();
  3385.                 Util::saveUpdateRecordInRegistActions($emLev, 'conf_rangedelivery', $entity, RegistActions::ACTION_INSERT);
  3387.                 $entity = '';
  3388.                 break;
  3390.             case 'modify':
  3391.                 if (isset($params['changeTypeRecharge']) && $params['changeTypeRecharge'] == 0) {
  3392.                     $entity->setConfRangeDelivery($params['distance']);
  3393.                     $entity->setConfDeliveryPrice($params['price']);
  3394.                 
  3395.                 }else if(isset($params['changeTypeRecharge']) && $params['changeTypeRecharge'] == 1){
  3396.                     $entity->setConfFixedCostValue($params['price']);
  3397.                 }
  3398.                 
  3399.                 Util::saveUpdateRecordInRegistActions($emLev, 'conf_rangedelivery', $entity, RegistActions::ACTION_UPDATE);
  3400.                 break;
  3402.             case 'delete':
  3403.                 $emLev->remove($entity);
  3404.                 $emLev->flush();
  3406.                 Util::saveUpdateRecordInRegistActions($emLev, 'conf_rangedelivery', $entity, RegistActions::ACTION_DELETE);
  3408.                 $entity = '';
  3409.                 break;
  3411.             case 'not_recharge':
  3412.                 $entity = $emLev->getRepository('App\Structure\ConfRangedelivery')->findAll();
  3413.                 $entity = $this->registerNewDeliveryRangeOrPlain($entity, $params);
  3414.                 
  3415.                 foreach ($entity as $key => $value) {
  3416.                     $emLev->persist($value);
  3417.                     $emLev->flush();
  3418.                     Util::saveUpdateRecordInRegistActions($emLev, 'conf_rangedelivery', $value, RegistActions::ACTION_UPDATE);
  3419.                 }
  3421.                 $entity = '';
  3422.                 break;
  3424.             case 'recharge':  
  3425.                 $entity = $emLev->getRepository('App\Structure\ConfRangedelivery')->findBy(['confTypeNoRechargeDefined' => ConfRangedelivery::CONF_TYPE_DELIVERY_NOT_RECHARGE]);
  3426.                 $entity = $this->registerNewDeliveryRangeOrPlain($entity, $params);
  3428.                 foreach ($entity as $key => $value) {
  3429.                     $emLev->persist($value);
  3430.                     $emLev->flush();
  3431.                     Util::saveUpdateRecordInRegistActions($emLev, 'conf_rangedelivery', $value, RegistActions::ACTION_UPDATE);
  3432.                 }
  3434.                 $entity = '';
  3435.                 break;
  3437.             case 'distance_setting':
  3438.                 if (isset($params['type_recharge']) &&  $params['type_recharge'] == '0') {
  3439.                     $entity = $emLev->getRepository('App\Structure\ConfRangedelivery')->findAll();
  3440.                     $entity = $this->registerNewDeliveryRangeOrPlain($entity, $params);
  3442.                     foreach ($entity as $key => $value) {
  3443.                         $emLev->persist($value);
  3444.                         $emLev->flush();
  3445.                         Util::saveUpdateRecordInRegistActions($emLev, 'conf_rangedelivery', $value, RegistActions::ACTION_UPDATE);
  3446.                     }
  3447.                 }
  3449.                 $entity = '';
  3450.                 break;
  3452.             case 'plain_setting': 
  3453.                 if (isset($params['type_recharge']) &&  $params['type_recharge'] == '1') {
  3454.                     $entity = $emLev->getRepository('App\Structure\ConfRangedelivery')->findAll();
  3455.                     $entity = $this->registerNewDeliveryRangeOrPlain($entity, $params);
  3457.                     foreach ($entity as $key => $value) {
  3458.                         $emLev->persist($value);
  3459.                         $emLev->flush();
  3460.                         Util::saveUpdateRecordInRegistActions($emLev, 'conf_rangedelivery', $value, RegistActions::ACTION_UPDATE);
  3461.                     }
  3462.                 }
  3464.                 $entity = '';
  3465.                 break;
  3467.             case 'plain_setting_exit':
  3468.             case 'distance_setting_exit':
  3469.                 if (isset($params['type_recharge']) &&  ($params['type_recharge'] == '0' || $params['type_recharge'] == '1')) {
  3470.                     $entity = $emLev->getRepository('App\Structure\ConfRangedelivery')->findAll();
  3471.                     $entity = $this->registerNewDeliveryRangeOrPlain($entity, $params);
  3473.                     foreach ($entity as $key => $value) {
  3474.                         $emLev->persist($value);
  3475.                         $emLev->flush();
  3476.                         Util::saveUpdateRecordInRegistActions($emLev, 'conf_rangedelivery', $value, RegistActions::ACTION_UPDATE);
  3477.                     }
  3478.                 }
  3480.                 $entity = '';
  3481.                 break;  
  3483.             case 'status_type_distance':
  3484.                 $entity = $emLev->getRepository('App\Structure\ConfRangedelivery')->findAll();
  3485.                 
  3486.                 foreach ($entity as $key => $value) {
  3487.                     if ($value->getConfTypeRange() == (int) $params['rechargeByDistance']) {
  3488.                         $value->setConfStatus(ConfRangedelivery::CONF_TYPE_STATUS_ACTIVE);
  3489.                     }else{
  3490.                         $value->setConfStatus(ConfRangedelivery::CONF_TYPE_STATUS_INACTIVE);
  3491.                     }
  3493.                     $emLev->persist($value);
  3494.                     $emLev->flush();
  3495.                     Util::saveUpdateRecordInRegistActions($emLev, 'conf_rangedelivery', $value, RegistActions::ACTION_UPDATE);
  3496.                 }
  3498.                 $entity = '';
  3499.                 break;
  3500.         }
  3502.         return $entity;
  3503.     }
  3505.     /**
  3506.      * Funcion privada de las acciones de la configuracion del delivery
  3507.      * Dependiendo de sus parametros, se define que va a modificar o crear
  3508.      * @author Leandro Román Londoño - 03/03/2020
  3509.      */
  3510.     private function registerNewDeliveryRangeOrPlain($entity, $params){
  3512.         /**
  3513.          * Espera el parametro en "0", (string), para crear el delivery por distancia
  3514.          */
  3515.         
  3516.         if (isset($params['changeTypeRecharge']) && $params['changeTypeRecharge'] == "0") {
  3517.             $entity->setConfTypeDelivery(ConfRangedelivery::CONF_TYPE_DELIVERY_RECHARGE_BY_DISTANCE);
  3518.             $entity->setConfRangemax(ConfRangedelivery::CONF_DEFAULT_RANGE_MAX);
  3519.             $entity->setConfRangecharge(ConfRangedelivery::CONF_FLAT_FEE_INACTIVE);
  3520.             $entity->setConfTypeRange((int) $params['rechargeByDistance']);
  3521.             
  3522.             if (isset($params['categoryRechage']) && $params['categoryRechage'] != '') {
  3523.                 $entity->setConfRangeDelivery((int) $params['categoryRechage']);
  3524.             }else{
  3525.                 $entity->setConfRangeDelivery(ConfRangedelivery::CONF_TYPE_NOT_RECHARGE);
  3526.             }
  3528.             if (isset($params['valueTotal']) && $params['valueTotal'] != '') {
  3529.                 $entity->setConfDeliveryPrice((int) $params['valueTotal']);
  3530.             }else{
  3531.                 $entity->setConfDeliveryPrice(ConfRangedelivery::CONF_TYPE_NOT_RECHARGE);
  3532.             }
  3533.             
  3534.             $entity->setConfFlatFee(ConfRangedelivery::CONF_FLAT_FEE_INACTIVE);
  3535.             $entity->setConfFixedCostValue(ConfRangedelivery::CONF_FLAT_FEE_INACTIVE);
  3536.             $entity->setConfTypeNoRechargeDefined(ConfRangedelivery::CONF_TYPE_DELIVERY_RECHARGE);
  3537.             $entity->setConfStatus(ConfRangedelivery::CONF_TYPE_STATUS_INACTIVE);
  3538.         }
  3539.         
  3540.         /**
  3541.          * Espera el parametro en "1", (string), para crear el delivery por plain
  3542.          */
  3544.         if (isset($params['changeTypeRecharge']) && $params['changeTypeRecharge'] == "1") {
  3545.             $entity->setConfTypeDelivery(ConfRangedelivery::CONF_TYPE_DELIVERY_PLAIN_RECHARGE);
  3546.             $entity->setConfRangemax(ConfRangedelivery::CONF_DEFAULT_RANGE_MAX);
  3547.             $entity->setConfRangecharge(ConfRangedelivery::CONF_FLAT_FEE_INACTIVE);
  3548.             $entity->setConfTypeRange(ConfRangedelivery::CONF_FLAT_FEE_INACTIVE);
  3549.             $entity->setConfRangeDelivery(ConfRangedelivery::CONF_FLAT_FEE_INACTIVE);
  3550.             $entity->setConfDeliveryPrice(ConfRangedelivery::CONF_FLAT_FEE_INACTIVE);
  3551.             $entity->setConfFlatFee((int) $params['rechargeByPlain']);
  3553.             if(isset($params['valueTotalPlain']) && $params['valueTotalPlain'] != ''){
  3554.                 $entity->setConfFixedCostValue((int) $params['valueTotalPlain']);
  3555.             }else{
  3556.                 $entity->setConfFixedCostValue(ConfRangedelivery::CONF_FLAT_FEE_INACTIVE);
  3557.             }
  3558.             $entity->setConfTypeNoRechargeDefined(ConfRangedelivery::CONF_TYPE_DELIVERY_RECHARGE);
  3559.             $entity->setConfStatus(ConfRangedelivery::CONF_TYPE_STATUS_INACTIVE);
  3560.         }
  3561.         
  3562.         /**
  3563.          * Espera el parametro en "not_recharge", (string), para modificar y establecer que no va a cobrar por domicilios
  3564.          */
  3566.         if (isset($params['action']) && $params['action'] == 'not_recharge') {
  3567.             foreach ($entity as $key => $value) {
  3568.                 $value->setConfTypeNoRechargeDefined(ConfRangedelivery::CONF_TYPE_DELIVERY_NOT_RECHARGE); 
  3570.                 $entity[$key] = $value;
  3571.             }
  3572.         }
  3574.         /**
  3575.          * Espera el parametro en "recharge", (string), para modificar y establecer que va a cobrar por domicilios
  3576.          */
  3577.         
  3578.         if (isset($params['action']) && $params['action'] == 'recharge') {
  3579.             if (!empty($entity)) {
  3580.                 foreach ($entity as $key => $value) {
  3581.                     $value->setConfTypeNoRechargeDefined(ConfRangedelivery::CONF_TYPE_DELIVERY_RECHARGE);
  3583.                     $entity[$key] = $value;
  3584.                 }
  3585.             }
  3586.         }
  3587.         
  3588.         /**
  3589.          * Espera el parametro en "distance_setting", (string), para modificar y establecer que solo activa la configuración
  3590.          * domicilio por distancia
  3591.          */
  3592.         if (isset($params['action']) && $params['action'] == 'distance_setting') {
  3593.             foreach ($entity as $key => $value) {
  3594.                 $confTypeDelivery = $value->getConfTypeDelivery() || 0;
  3596.                 if ((int)$confTypeDelivery == (int) $params['type_recharge'] && $value->getConfTypeRange() == (int) $params['rechargeByDistance']) {
  3597.                     $value->setConfStatus(ConfRangedelivery::CONF_TYPE_STATUS_INACTIVE);
  3598.                 }else{
  3599.                     $value->setConfStatus(ConfRangedelivery::CONF_TYPE_STATUS_ACTIVE);
  3600.                 }
  3602.                 $entity[$key] = $value;
  3603.             }
  3604.         }
  3606.         /**
  3607.          * Espera el parametro en "plain_setting", (string), para modificar y establecer que solo activa la configuración
  3608.          * domicilio por precio fijo
  3609.          */
  3611.         if (isset($params['action']) && $params['action'] == 'plain_setting') {
  3612.             foreach ($entity as $key => $value) {
  3613.                 if ($value->getConfTypeDelivery() == (int) $params['type_recharge']) {
  3614.                     $value->setConfStatus(ConfRangedelivery::CONF_TYPE_STATUS_ACTIVE);
  3615.                 }else{
  3616.                     $value->setConfStatus(ConfRangedelivery::CONF_TYPE_STATUS_INACTIVE);
  3617.                 }
  3619.                 $entity[$key] = $value;
  3620.             }
  3621.         }
  3623.         /**
  3624.          * Espera el parametro "distance_setting_exit" o "plain_setting_exit", (string) para establecer que no quiere
  3625.          * ninguna configuración
  3626.          */
  3628.         if (isset($params['action']) && ($params['action'] == 'distance_setting_exit' || $params['action'] == 'plain_setting_exit')) {
  3629.             foreach ($entity as $key => $value) {
  3630.                 $value->setConfStatus(ConfRangedelivery::CONF_TYPE_STATUS_INACTIVE);
  3632.                 $entity[$key] = $value;
  3633.             }
  3634.         }
  3635.         
  3636.         return $entity;
  3637.     }
  3639.     /**
  3640.      * 
  3641.      */
  3642.     public function updateRestaurantLoyaltyConfig(Request $request) {
  3643.         $data = $request->request->getIterator()->getArrayCopy();
  3644.         $em = $this->getDoctrine()->getManager();
  3645.         $params = $data['restaurant_loyalty_config'];
  3646.         $localRatio = 0;
  3647.         $globalRatio = 0;
  3648.         $path = Util::getValidActiveLogByBaseName($this->realContainer, 'updateRestaurantLoyaltyConfig', 'updateRestaurantLoyaltyConfig0.txt');
  3649.         $this->createFileJson($path, "\r" . 'updateRestaurantLoyaltyConfig fever XD ' . $request->getContent() . "\r");
  3651.         $entities = $em->getRepository('App\Entity\RestaurantLoyaltyConfiguration')->find($params['id']);
  3653.         $accountLicenseData = $em->getRepository('App\Entity\AccountLicense')->find($params['license']);
  3655.         $emLev = Util::emLicenseConnection($this->realContainer, $em, $accountLicenseData);
  3656.         $accountConfig = $emLev->getRepository('App\Structure\Configuracion')->findAll();
  3658.         if (isset($params['typePoint']) && $params['typePoint'] == 'local') {
  3659.             $entities->setUseLocalPoints(true);
  3660.             $entities->setUseGlobalPoints(false);
  3661.             $accountConfig[0]->setConfLoyaltyTypePoints(Configuracion::TYPE_LOYALTY_LOCAL); 
  3662.             $entities->setMinimumPointAmountToExchange($params['minimumPointAmountToExchange']);
  3663.         } elseif (isset($params['typePoint']) && $params['typePoint'] == 'global') {
  3664.             $entities->setUseLocalPoints(false);
  3665.             $entities->setUseGlobalPoints(true);
  3666.             $accountConfig[0]->setConfLoyaltyTypePoints(Configuracion::TYPE_LOYALTY_GLOBAL);
  3667.             $entities->setMinimumPointAmountToExchange((int) $this->realContainer->getParameter('minimum_usage_of_global_points'));
  3668.         } else {
  3669.             $entities->setUseLocalPoints(false);
  3670.             $entities->setUseGlobalPoints(false);
  3671.             $accountConfig[0]->setConfLoyaltyTypePoints(Configuracion::TYPE_LOYALTY_NONE);
  3672.         }
  3674.         if (isset($params['earnPointsInPurchaseWithPoints'])) {
  3675.             $entities->setEarnPointsInPurchaseWithPoints(true);
  3676.         } else {
  3677.             $entities->setEarnPointsInPurchaseWithPoints(false);
  3678.         }
  3680.         $em->persist($entities);
  3681.         $em->flush();
  3683.         $accountConfig[0]->setConfLoyaltyMinAmountToExchange($params['minimumPointAmountToExchange']);
  3685.         if (isset($params['earnPointsInPurchaseWithPoints'])) {
  3686.             $accountConfig[0]->setEarnPointsInPurchaseWithPoints(true);
  3687.         } else {
  3688.             $accountConfig[0]->setEarnPointsInPurchaseWithPoints(false);
  3689.         }
  3691.         $dashboardLoyaltyButton = $emLev->getRepository('App\Structure\Dashboard')->find(14);
  3693.         if (!$dashboardLoyaltyButton) {
  3694.             $dashboardLoyaltyRecord = new Dashboard();
  3696.             $dashboardLoyaltyRecord->setId(14);
  3697.             $dashboardLoyaltyRecord->setDasTabToGo('openSearchLoyaltyCustomer');
  3698.             $dashboardLoyaltyRecord->setDasIcon('icon-pay-points');
  3699.             $dashboardLoyaltyRecord->setDasOrderType(14);
  3700.             $dashboardLoyaltyRecord->setDasName('GENERAL.LOYALTY');
  3701.             $dashboardLoyaltyRecord->setDasStatus(1);
  3702.             $dashboardLoyaltyRecord->setDasSorting(14);
  3704.             $emLev->persist($dashboardLoyaltyRecord);
  3705.             $emLev->flush();
  3707.             Util::saveUpdateRecordInRegistActions($emLev, 'dashboard', $dashboardLoyaltyRecord, RegistActions::ACTION_INSERT);
  3708.         } else {
  3709.             $dashboardLoyaltyButton->setDasStatus(1);
  3711.             $emLev->persist($dashboardLoyaltyButton);
  3712.             $emLev->flush();
  3714.             Util::saveUpdateRecordInRegistActions($emLev, 'dashboard', $dashboardLoyaltyButton, RegistActions::ACTION_UPDATE);
  3715.         }
  3717.         $emLev->persist($accountConfig[0]);
  3718.         $emLev->flush();
  3720.         Util::saveUpdateRecordInRegistActions($emLev, 'configuracion', $accountConfig[0], RegistActions::ACTION_UPDATE);
  3722.         $points = $em->getRepository('App\Entity\TypePoint')->findAll();
  3723.         foreach ($points as $typePoint) {
  3724.             if ($typePoint->getType() == TypePoint::TYPE_LOCAL) {
  3725.                 $localRatio = $typePoint->getCashRatio();
  3726.                 continue;
  3727.             }
  3728.             if ($typePoint->getType() == TypePoint::WORK_AS_GLOBAl) {
  3729.                 $globalRatio = $typePoint->getCashRatio();
  3730.             }
  3731.         }
  3733.         $form = $this->createForm(RestaurantLoyaltyConfig::class, $entities, [
  3734.             'action' => $this->generateUrl('update_loyalty_config'),
  3735.             'method' => 'POST'
  3736.         ]);
  3738.         return $this->render('AccountLicense\restaurantLoyaltyConfig.html.twig', [
  3739.                     'entities' => $entities,
  3740.                     'toClose' => true,
  3741.                     'form' => $form->createView(),
  3742.                     'localRatio' => $localRatio,
  3743.                     'globalRatio' => $globalRatio
  3744.         ]);
  3745.     }
  3748.     /**
  3749.      * Función replica de updateRestaurantLoyaltyConfig pero adaptada al nuevo flujo de guardado de loyalty para sincronización en Android
  3750.      * @param EntityManager     $em
  3751.      * @param Entity            $License Entidad de AccountLicense
  3752.      * @param Array             $params Parametros de entrada['loyalty', 'minimumPointAmountToExchange']
  3753.      * @return Boolean          True o false
  3754.      */
  3755.     public function saveSyncLoyalty($em, $license, $params){
  3757.         try{ 
  3758.             // Se crean los logs 
  3759.             $path = Util::getValidActiveLogByBaseName($this->realContainer, 'updateRestaurantLoyaltyConfig', 'updateRestaurantLoyaltyConfig0.txt');
  3760.             $this->createFileJson($path, "\r" . 'saveSyncLoyalty ' . json_encode($params). "\r");
  3761.             
  3762.             //  Se conecta con la base de datos de level web
  3763.             $emLev = Util::emLicenseConnection($this->realContainer, $em, $license);
  3764.             $accountConfig = $emLev->getRepository('App\Structure\Configuracion')->findAll();
  3765.             
  3766.             // Util::saveUpdateRecordInRegistActions($emLev, 'licensor1', $license, RegistActions::ACTION_UPDATE);
  3767.             
  3768.             // Se valida que se active la función de loyalty, ya que para este caso solo se tiene en cuenta loyalty cash de forma local se activara esta opción.
  3769.             if (isset($params['loyalty']) && $params['loyalty'] == 1) {           
  3770.                 $accountConfig[0]->setConfLoyaltyTypePoints(Configuracion::TYPE_LOYALTY_LOCAL); 
  3771.             
  3772.                 $this->createFileJson($path, "\r" . 'Set value type loyalty local '."\r" );
  3773.             } else {
  3774.                 $accountConfig[0]->setConfLoyaltyTypePoints(Configuracion::TYPE_LOYALTY_NONE);
  3775.                 $this->createFileJson($path, "\r" . 'Set value type loyalty off '."\r" );
  3776.             }
  3778.             // Se ingresa el valor minimo de cash loyalty en level web
  3779.             $accountConfig[0]->setConfLoyaltyMinAmountToExchange($params['minimumPointAmountToExchange']);
  3781.             //  Se ingresan los datos de configuración en la tabla de dashboard para level web 
  3782.             $dashboardLoyaltyButton = $emLev->getRepository('App\Structure\Dashboard')->find(14);
  3784.             if (!$dashboardLoyaltyButton) {
  3786.                 $this->createFileJson($path, "\r" . 'Save config in table Dashboard from levelweb'."\r" );
  3788.                 $dashboardLoyaltyRecord = new Dashboard();
  3790.                 $dashboardLoyaltyRecord->setId(14);
  3791.                 $dashboardLoyaltyRecord->setDasTabToGo('openSearchLoyaltyCustomer');
  3792.                 $dashboardLoyaltyRecord->setDasIcon('icon-pay-points');
  3793.                 $dashboardLoyaltyRecord->setDasOrderType(14);
  3794.                 $dashboardLoyaltyRecord->setDasName('GENERAL.LOYALTY');
  3795.                 $dashboardLoyaltyRecord->setDasStatus(1);
  3796.                 $dashboardLoyaltyRecord->setDasSorting(14);
  3798.                 $emLev->persist($dashboardLoyaltyRecord);
  3799.                 $emLev->flush();
  3801.                 // se guardan los datos en regisAction para ser sincronizados
  3802.                 Util::saveUpdateRecordInRegistActions($emLev, 'dashboard', $dashboardLoyaltyRecord, RegistActions::ACTION_INSERT);
  3803.                 
  3804.                 $this->createFileJson($path, "\r" . 'regisAction Dashboard from levelweb'."\r" );
  3806.             } else {
  3807.                 $dashboardLoyaltyButton->setDasStatus(1);
  3809.                 $emLev->persist($dashboardLoyaltyButton);
  3810.                 $emLev->flush();
  3811.                 // se guardan los datos en regisAction para ser sincronizados
  3813.                 Util::saveUpdateRecordInRegistActions($emLev, 'dashboard', $dashboardLoyaltyButton, RegistActions::ACTION_UPDATE);
  3814.                 $this->createFileJson($path, "\r" . 'regisAction Dashboard from levelweb if register dasboard exist'."\r" );
  3815.             }
  3817.             $emLev->persist($accountConfig[0]);
  3818.             $emLev->flush();
  3819.             
  3820.             // se guardan los datos en regisAction para ser sincronizados
  3821.             Util::saveUpdateRecordInRegistActions($emLev, 'configuracion', $accountConfig[0], RegistActions::ACTION_UPDATE);
  3822.             
  3823.             $this->createFileJson($path, "\r" . 'regisAction configuracion from levelweb'."\r" );
  3824.             return true;
  3825.         }catch (\Throwable $th) {
  3826.             $err = ['Error message' => $th->getMessage(), 'Error Line' => $th->getLine(), 'Error File' => $th->getFile(), 'Error Trance' => $th->getTrace()];
  3827.             $this->createFileJson($path, "\r" . 'Alert Error => '. json_encode($err) ."\r" );
  3828.             return $this->errorInternalError($err);
  3829.         }
  3830.     }
  3834.     /**
  3835.      * Web Service que recibe el nickname del restaurante, el ID del cliente, el teléfono y/o el email 
  3836.      * y responde con la cuenta de los puntos del cliente que tenga registrados en el restaurante 
  3837.      * y se le agrega el token único de transacción para ser verificado en una compra futura.
  3838.      * @author Jhonan Vargas <jsmith@openmytab.com> 11/05/2023
  3839.      * @param Request $request
  3840.      * @return type
  3841.      */
  3842.     public function generateLoyaltyTransactionToken(Request $request){
  3844.         if ($request->getMethod() !== WebService::REQUEST_METHOD_POST) {
  3845.             return $this->errorNotAllowedMethod('Method not allowed. Use ' . WebService::REQUEST_METHOD_POST . " method");
  3846.         }
  3848.         $arrayEncryptResult = Util::decryptDataForAndroid($this->realContainer, $request->getContent());
  3849.         $data = json_decode($arrayEncryptResult['data'], true);
  3851.         $path = Util::getValidActiveLogByBaseName($this->realContainer, 'generateLoyaltyTransactionToken', 'generateLoyaltyTransactionToken0.txt');
  3852.         $this->createFileJson($path, "\r" . 'parameters sent: ' . $arrayEncryptResult['data'] . "\r");
  3854.         $existPhone = isset($data["phone"]);
  3855.         $existEmail = isset($data["email"]);
  3856.         if(!isset($data["nickname"]) || !isset($data["clientId"]) || (!$existPhone && !$existEmail)){
  3857.             $this->createFileJson($path, "\r" . 'Wrong Arguments!'. "\r");
  3858.             return $this->errorWrongArgs('Wrong Arguments!', WebService::CODE_WRONG_ARGUMENTS);
  3859.         }
  3860.         $search = [];
  3861.         $isEmpty = false;
  3862.         // se verifica que el teléfono o el email no estén vacíos
  3863.         if($existPhone){
  3864.             if($data["phone"] !== ''){
  3865.                 $search["phone"] = $data["phone"];
  3866.             }else{
  3867.                 $isEmpty = true;
  3868.             }
  3869.         }
  3871.         if($existEmail){
  3872.             if($data["email"] !== ''){
  3873.                 $search["email"] = $data["email"];
  3874.             }else{
  3875.                 $isEmpty = true;
  3876.             }
  3877.         }
  3879.         // se valida que los parámetros no estén vacíos
  3880.         if(empty($data["nickname"]) || empty($data["clientId"]) || $isEmpty){
  3881.             $this->createFileJson($path, "\r" . 'Some Fields Are Empty!'. "\r");
  3882.             return $this->errorWrongArgs('Wrong Arguments!', WebService::CODE_WRONG_ARGUMENTS);
  3883.         }
  3884.         $em = $this->getDoctrine()->getManager();
  3885.         
  3886.         // se valida si existe la licencia
  3887.         $nicknameDataSearch = ['alLicenseUsername' => $data['nickname']];
  3888.         $accountLicData = $em->getRepository('App\Entity\AccountLicense')->findBy($nicknameDataSearch);
  3890.         if (empty($accountLicData)) {
  3891.             $this->createFileJson($path, "\r" . 'Invalid nickname!'. "\r");
  3892.             return $this->setStatusCode(WebService::HTTP_CODE_UNAUTHORIZED)->respondWithError('Invalid nickname', WebService::CODE_COULD_NOT_AUTHENTICATE);
  3893.         }
  3895.         if(is_null($accountLicData[0]->getLoginType()) || $accountLicData[0]->getLoginType() == AccountLicense::LOGGED_OUT){
  3896.             $this->createFileJson($path, "\r" . 'License not logged!'. "\r");
  3897.             return $this->setStatusCode(WebService::HTTP_CODE_UNAUTHORIZED)->respondWithError('License not logged', WebService::CODE_COULD_NOT_AUTHENTICATE);
  3898.         }
  3900.         // se valida que se tenga una versión de Android registrada en la licencia
  3901.         if (($accountLicData[0]->getLoginType() == AccountLicense::LOGGED_BY_LEVEL_ANDROID || $accountLicData[0]->getLoginType() == AccountLicense::LOGGED_BY_LEVEL_LITE_AND_ANDROID) && !is_null($accountLicData[0]->getAndroidVersionName())) {
  3902.             $this->createFileJson($path, "\r" . 'Android logged in license !'. "\r");
  3903.             // se valida que la versión de Android de la licencia sea mayor o igual a la versión segura de Android la cual ya tiene la verificación por token para las transacciones de loyalty
  3904.             if (!NewUtil::isGreaterThanOrEqualToThisVersion($accountLicData[0]->getAndroidVersionName(), $this->realContainer->getParameter('secure_android_version'), $path)){
  3905.                 $this->createFileJson($path, "\r" . 'Android version is not secure!'. "\r");
  3906.                 return $this->setStatusCode(WebService::HTTP_CODE_UNAUTHORIZED)->respondWithError('Android version is not secure', WebService::CODE_COULD_NOT_AUTHENTICATE);
  3907.             }
  3908.         } else {
  3909.             $this->createFileJson($path, "\r" . 'Level Lite logged in license !'. "\r");
  3910.         }
  3912.         $search['restaurant'] = $accountLicData[0]->getId();
  3913.         $search["client"] = $data["clientId"];
  3914.         
  3915.         // Se busca el cliente con los parámetros de ingresados
  3916.         $client = $em->getRepository('App\Entity\OmtClient')->findOmtClientByFilterSearchParameters($search);
  3918.         if(is_null($client)){
  3919.             $this->createFileJson($path, "\r" . 'Client does not exist!'. "\r");
  3920.             return $this->setStatusCode(WebService::HTTP_CODE_UNAUTHORIZED)->respondWithError('Client does not exist', WebService::CODE_COULD_NOT_AUTHENTICATE);
  3921.         }
  3923.         // se realiza la consulta de los puntos junto con el token correspondiente
  3924.         $transactionToken['tokens'] = $em->getRepository('App\Entity\TypePointAcount')->generateLoyaltyTransactionTokenByClient($search, $path);
  3925.         
  3926.         $transactionToken['licenseId'] = $accountLicData[0]->getId();
  3927.         $transactionToken['msg'] = "Transaction Verification Token ";
  3928.         $transactionToken['status'] = WebService::CODE_SUCCESS;
  3929.         $transactionToken['bigbag'] = true;
  3930.         $theUrlTrSt = new LicensorGenericTransformer($this->realContainer, $transactionToken);
  3931.         $xxArray = $theUrlTrSt->transform();
  3932.         $jsonContent = json_encode($xxArray);
  3934.         return $this->respondWithItem($jsonContent, $theUrlTrSt);
  3935.     }
  3937.     public function getLoyaltyAmount(Request $request): JsonResponse {
  3939.         $container = $this->realContainer;
  3940.         $em = $this->getDoctrine()->getManager();
  3941.         $search = $request->query->all();
  3943.         $statusCode = 200;
  3944.         $data = [
  3945.             'status' => 'success',
  3946.             'message' => 'amount by license',
  3947.         ]; 
  3949.         if (isset($search['restaurant'])) {
  3950.             $typePointAcount = $em->getRepository('App\Entity\TypePointAcount');
  3951.             $amount = $typePointAcount->getLoyaltyAmount($search);
  3952.     
  3953.             $data['amount'] = $amount;
  3954.         }else{
  3955.             $data['status'] = "error";
  3956.             $data['message'] = "restaurant not found";
  3957.             $data['statusCode'] = $statusCode;
  3958.             $statusCode = 500;
  3960.         }
  3963.         return new JsonResponse($data, $statusCode);
  3964.     }
  3966.     /**
  3967.      * Consular puntos loyalty que se encuentran en licensor
  3968.      * Se debe ingresar minimo un parametro relacionado con el cliente de los siguientes
  3969.      * @param Request $request
  3970.      * @param String $phone - numero de telefono con el que esta registrado el cliente
  3971.      * @param String $email - email con el que esta registrado el cliente
  3972.      * @param String $client - id del cliente para omt
  3973.      * @param String $restaurant - id del restaurante
  3974.      * @param String $omt - true / false dependiende desde donde se realice la patición
  3975.      * @return Json  responde con algunos datos del cliente y los puntos locales por restaurante
  3976.      */
  3977.     public function getGenericPointLoyalty(Request $request) {
  3978.         
  3979.         // Se verifica que ingrese con el mehod gett
  3980.         if ($request->getMethod() != WebService::REQUEST_METHOD_GET) {
  3981.             return $this->errorNotAllowedMethod('Method not allowed. Use ' . WebService::REQUEST_METHOD_GET . " method");
  3982.         }
  3983.             
  3984.         // Creamos el log
  3985.         $path = Util::getValidActiveLogByBaseName($this->realContainer, 'getGenericPointLoyalty', 'getGenericPointLoyalty0.txt');
  3986.         $this->createFileJson($path, "\r" . '**-----------------------------------------------------------------------------**' . "\r");
  3987.         $this->createFileJson($path, "\r" . 'getGenericPointLoyalty init: ' . $request->getContent() . "\r");
  3988.         $this->createFileJson($path, "\r" . 'query params: ' . json_encode($request->query->all()) . "\r");
  3990.         $search = [];
  3991.         $indexSearch = [];
  3992.         $order = [];
  3993.         $indexOrder = ['order_by_last_visit', 'order_by_member_since', 'order_by_cash'];
  3995.         $paginator = $this->get('simple_paginator');
  3996.         $pageRanges = [10, 25, 50];
  3997.         $paginator->setPageRanges($pageRanges);
  3999.         (!is_null($request->query->get('itemsPerPage')) && $request->query->get('itemsPerPage') != '') ? $itemsPerPage = (int) $request->query->get('itemsPerPage') : $itemsPerPage = $pageRanges[0];
  4001.         $paginator->setItemsPerPage($itemsPerPage);
  4002.         $paginator->setMaxPagerItems(10);
  4003.         
  4004.         try {
  4006.             // Se inicia el entiti manager
  4007.             $container = $this->realContainer;
  4008.             $em = $this->getDoctrine()->getManager();
  4010.             $search = $request->query->all();
  4011.         
  4012.             if (isset( $search['phone']) &&  $search['phone'] != '' ) {
  4013.                 $search['phone'] = Utilx::clearEspecialCharactersFromPhone($search['phone']);
  4014.             }
  4016.             $debug = (isset($search['debug']) && !is_null($search['debug'])) ? (boolean) $search['debug'] : false;
  4017.             $omtRequest = (isset($search['omt']) && !is_null($search['omt'])) ? $search['omt'] : null;
  4019.             $search = array_filter($search, function ($value) {
  4020.                 return !is_null($value);
  4021.             });
  4022.             
  4023.             if ($debug) {
  4025.                 dump($search);
  4026.                 $this->createFileJson($path, "\r" . 'Parameter debug '. "\r Parametros de entrada" . json_encode($search) .  "\r");
  4027.             }
  4029.             // Se validan los parmetros de llegada
  4030.             if (empty($search) ) {
  4031.                 $this->createFileJson($path, "\r" . 'Invalid parameters name' . "\r");
  4032.                 return $this->setStatusCode(WebService::HTTP_CODE_UNAUTHORIZED)
  4033.                                 ->respondWithError('Invalid parameters name', WebService::CODE_COULD_NOT_AUTHENTICATE);
  4034.             }
  4036.             if (!isset($search['restaurant'])) {
  4037.                 $client = $em->getRepository('App\Entity\OmtClient')->findOmtClientByFilterSearchParametersBasicData($search, $debug);
  4039.                 if ($debug) {
  4040.                     dump("respuesta cliente", $client, isset($client) && !empty($client));
  4041.                     $this->createFileJson($path, "\r" . 'Parameter debug '. "\r Parametros de entrada" . json_encode($client) .  "\r");
  4042.                 }
  4044.                 if (isset($client) && !empty($client)) {
  4045.                     
  4046.                     $this->createFileJson($path, "\r" . 'Client exist' .json_encode($client). "\r");
  4047.                     $pointAccountByClientRepository = $em->getRepository('App\Entity\TypePointAcount');
  4049.                     //  se comenta mientras tanto porque aun no se ha implementado los puntos globales
  4050.                     // // [ client, phone, email ]       
  4051.                     // $pointAccountByClientGlobal = $pointAccountByClientRepository->getPointLoyaltyClientGlobal($search,$omtRequest);
  4052.                     // if(!is_null($pointAccountByClientGlobal)){
  4053.                     //     $responseArrWithPagination['points']['global'] = $pointAccountByClientGlobal;
  4054.                     // }
  4056.                     // [ restaurant ]
  4057.                     $pointAccountByClientRestaurantResult = $pointAccountByClientRepository->getPointLoyaltyClientXRestaurant($search, $omtRequest);
  4058.                     $pointAccountByClientRestaurant = $pointAccountByClientRestaurantResult['pointAccountByClientRestaurant'];
  4059.                     $clientsIdInArray = $pointAccountByClientRestaurantResult['clientsIdInArray'];
  4061.                     if ($debug) {
  4062.                         dump("Return consulata de puntos ",$pointAccountByClientRestaurant);
  4063.                     }
  4065.                     if (!is_null($pointAccountByClientRestaurant) && !empty($pointAccountByClientRestaurant)) {
  4067.                         $responseArrWithPagination['points']['local'] = $pointAccountByClientRestaurant;
  4068.                         $this->createFileJson($path, "\r" . 'points local'. json_encode($pointAccountByClientRestaurant) ."\r");
  4069.                         $msg = "Client ok";
  4071.                     } else {
  4073.                         $this->createFileJson($path, "\r" . 'Not points local'."\r");
  4074.                         $msg = "Client has no loyalty cash";
  4076.                     }
  4078.                     // redondeo del point2cash
  4079.                     $responseArrWithPagination['clients'] = $client;
  4080.                     $responseArrWithPagination['generalInfo'] = $em->getRepository('App\Entity\TypePoint')->getRatioPoints();
  4082.                 }
  4084.             } else if (isset($search['restaurant'])) {
  4085.                 
  4086.                 $order = Paginator::filterParameters($indexOrder, $request, Paginator::REQUEST_TYPE_REQUEST, true);
  4087.                 $pointAccountByClientRepository = $em->getRepository('App\Entity\TypePointAcount');
  4088.                 $search['with_portal_client'] = 1;
  4090.                 $pointAccountByClientRestaurantResult = $pointAccountByClientRepository->getPointLoyaltyClientXRestaurant($search, $omtRequest, true, $debug, $order);
  4091.                 $pointAccountByClientRestaurant = $pointAccountByClientRestaurantResult['pointAccountByClientRestaurant'];
  4092.                 $clientsIdInArray = $pointAccountByClientRestaurantResult['clientsIdInArray'];
  4094.                 if (!is_null($pointAccountByClientRestaurant) && !empty($pointAccountByClientRestaurant)) {
  4096.                     $emLev = WsUtilx::emLicenseIDConnection($container, $em, $search['restaurant']);
  4097.                     foreach ($pointAccountByClientRestaurant as $key => $value) {
  4099.                         $pointAccountByClientRestaurant[$key]['orders'] = [];
  4100.                         $pointAccountByClientRestaurant[$key]['isOmt'] = false;
  4102.                         $clientExtraInfo = $emLev->getRepository('App\Structure\Cliente')->findOneBy(array(
  4103.                             "loyaltyId" => $value['typeCountId']
  4104.                         ));
  4106.                         // if (strpos($pointAccountByClientRestaurant[$key]['clientEmail'], '@test.com') !== false) {
  4107.                         //     $pointAccountByClientRestaurant[$key]['clientEmail'] = "";
  4108.                         // }
  4110.                         $clientOrders = $emLev->getRepository('App\Structure\LoyaltyHistory')->findBy(array(
  4111.                             "phone" => $value['clientPhone']
  4112.                         ), ['date' => 'DESC']);
  4113.                         
  4114.                         // $dateOfLastVisit = $emLev->getRepository('App\Structure\LoyaltyHistory')->findOneBy(array(
  4115.                         //     "phone" => $value['clientPhone']
  4116.                         // ), array( 'date' => $orderLastVisit));
  4118.                         $dateOfLastVisit = $emLev->getRepository('App\Structure\LoyaltyHistory')->findOneBy(["phone" => $value['clientPhone']]);
  4120.                         if ($pointAccountByClientRestaurant[$key]['clientBirthdate'] instanceof \DateTime) {
  4121.                             $pointAccountByClientRestaurant[$key]['clientBirthdate'] = $pointAccountByClientRestaurant[$key]['clientBirthdate']->format('m/d/Y');
  4122.                         }
  4124.                         if (!is_null($dateOfLastVisit)) {
  4125.                             if ($dateOfLastVisit->getDate() instanceof \DateTime) 
  4126.                                 $pointAccountByClientRestaurant[$key]['dateOfLastVisit'] = $dateOfLastVisit->getDate()->format('m/d/Y H:i');
  4127.                         } else if($pointAccountByClientRestaurant[$key]['createAccount'] instanceof \DateTime) 
  4128.                             $pointAccountByClientRestaurant[$key]['dateOfLastVisit'] = $pointAccountByClientRestaurant[$key]['createAccount']->format('m/d/Y H:i');
  4129.                         
  4131.                         if ($pointAccountByClientRestaurant[$key]['createdAt'] instanceof \DateTime) {
  4132.                             $pointAccountByClientRestaurant[$key]['createdAt'] = $pointAccountByClientRestaurant[$key]['createdAt']->format('m/d/Y');
  4133.                         }
  4135.                         if ($pointAccountByClientRestaurant[$key]['createAccount'] instanceof \DateTime) {
  4136.                             $pointAccountByClientRestaurant[$key]['createAccount'] = $pointAccountByClientRestaurant[$key]['createAccount']->format('m/d/Y');
  4137.                         }
  4139.                         if ($pointAccountByClientRestaurant[$key]['startingDate'] instanceof \DateTime) {
  4140.                             $pointAccountByClientRestaurant[$key]['startingDate'] = $pointAccountByClientRestaurant[$key]['startingDate']->format('m/d/Y');
  4141.                         }
  4143.                         if (isset($clientExtraInfo)) {
  4145.                             if ($clientExtraInfo->getCliCreacion() instanceof \DateTime) {
  4146.                                 $pointAccountByClientRestaurant[$key]['cliCreacion'] = $clientExtraInfo->getCliCreacion()->format('m/d/Y');
  4147.                             }
  4149.                             $pointAccountByClientRestaurant[$key]['cliCodigo'] = $clientExtraInfo->getId();
  4151.                         } else {
  4153.                             $pointAccountByClientRestaurant[$key]['isOmt'] = true;
  4155.                         }
  4157.                         if (isset($clientOrders)) {
  4159.                             $cashRedeemed = 0;
  4160.                             $cashEarned = 0;
  4162.                             foreach ($clientOrders as $key_o => $value_o) {
  4164.                                 $indiviauls = number_format((float)$value_o->getPointsRedeemed() - $value_o->getPointsEarned(), 2, '.', ',');
  4166.                                 $getInvoice = $emLev->getRepository('App\Structure\FacturaVentas')->findOneBy([ 'mpCodigo' => $value_o->getOrder() ]);
  4167.                                 $getOrder = $emLev->getRepository('App\Structure\Mesapedido')->findOneBy([ 'id' => $value_o->getOrder() ]);
  4169.                                 // Obtenemos los datos de order & invoice
  4170.                                 $pointAccountByClientRestaurant[$key]['orders'][$key_o]['orderId'] = $value_o->getOrder();
  4171.                                 $pointAccountByClientRestaurant[$key]['orders'][$key_o]['odeTotal'] = $getOrder != null ? $getOrder->getMpValortotal() : null;
  4172.                                 $pointAccountByClientRestaurant[$key]['orders'][$key_o]['customer'] = $getOrder != null ? $getOrder->getMpCodcliente() : null;
  4173.                                 $pointAccountByClientRestaurant[$key]['orders'][$key_o]['status'] = $getOrder != null ? $getOrder->getMpEstado() : null;
  4174.                                 $pointAccountByClientRestaurant[$key]['orders'][$key_o]['invoiceId'] = $getInvoice != null ? $getInvoice->getId() : [];
  4176.                                 if ($value_o->getPointsRedeemed() != null) {
  4177.                                     $cashRedeemed = (float)$cashRedeemed + (float)$value_o->getPointsRedeemed(); 
  4178.                                     $pointAccountByClientRestaurant[$key]['orders'][$key_o]['orderCashRedeemed'] = number_format((float) $value_o->getPointsRedeemed(), 2, '.', ',');
  4179.                                 }
  4180.                                 
  4181.                                 if ($value_o->getPointsEarned() != null) {
  4182.                                     $cashEarned = (float)$cashEarned + (float)$value_o->getPointsEarned(); 
  4183.                                     $pointAccountByClientRestaurant[$key]['orders'][$key_o]['orderCashEarned'] = number_format((float) $value_o->getPointsEarned(), 2, '.', ',');
  4184.                                 }
  4186.                                 $pointAccountByClientRestaurant[$key]['orders'][$key_o]['individualOrders'] = $indiviauls;
  4189.                                 if ($value_o->getDate() instanceof \DateTime) {
  4190.                                     $pointAccountByClientRestaurant[$key]['orders'][$key_o]['cliCreacion'] = $value_o->getDate()->format('m/d/Y');
  4191.                                 }
  4193.                                 if ($value_o->getSaleAmount()) {
  4194.                                     $pointAccountByClientRestaurant[$key]['orders'][$key_o]['mpValortotal'] = number_format((float)$value_o->getSaleAmount(), 2, '.', ',');
  4195.                                 }
  4196.                             }
  4198.                             $pointAccountByClientRestaurant[$key]['cashEarned'] = number_format($cashEarned, 2, '.', ',');
  4199.                             $pointAccountByClientRestaurant[$key]['cashRedeemed'] = number_format(abs($cashRedeemed), 2, '.', ',');
  4200.                         
  4201.                         }
  4203.                     }
  4205.                     $orderLastVisit = null;
  4207.                     if (isset($order['order_by_last_visit']))
  4208.                         $orderLastVisit = $order['order_by_last_visit'] % 2 ? "DESC" : "ASC";
  4210.                     if(!is_null($orderLastVisit)){
  4211.                         usort($pointAccountByClientRestaurant, function ($a, $b) use ($orderLastVisit) {
  4212.                             $dateA = strtotime($a['dateOfLastVisit']);
  4213.                             $dateB = strtotime($b['dateOfLastVisit']);
  4214.                             
  4215.                             if ($orderLastVisit === 'ASC') 
  4216.                                 return $dateA <=> $dateB;
  4217.                             else 
  4218.                                 return $dateB <=> $dateA;
  4219.                         });
  4220.                     }
  4222.                     // usort($pointAccountByClientRestaurant, function ($a, $b) {
  4223.                     //     return strtotime($b['createAccount']) <=> strtotime($a['createAccount']);
  4224.                     // });
  4225.                     
  4226.                     $ClientPaginator = $paginator->paginate($pointAccountByClientRestaurant)->getResult();
  4228.                     $params = Paginator::getUrlFromParameters($indexSearch, $search);
  4229.                     $orderBy = Paginator::getUrlOrderFromParameters($indexOrder, $order, $container);
  4231.                     $responseArrWithPagination['search'] = $search;
  4232.                     $responseArrWithPagination['orderBy'] = $orderBy;
  4233.                     $responseArrWithPagination['params'] = $params;
  4235.                     $finalPaginator = [];
  4236.                     $finalPaginator['currentPage'] = $paginator->getCurrentPage();
  4237.                     $finalPaginator['itemsPerPage'] = $paginator->getItemsPerPage();
  4238.                     $finalPaginator['maxPagerItems'] = $paginator->getMaxPagerItems();
  4239.                     $finalPaginator['totalItems'] = $paginator->getTotalItems();
  4240.                     $finalPaginator['pageRanges'] = $paginator->getPageRanges();
  4241.                     $finalPaginator['previousPage'] = $paginator->getPreviousPage();
  4242.                     $finalPaginator['minPageInRange'] = $paginator->getMinPageInRange();
  4243.                     $finalPaginator['maxPageInRange'] = $paginator->getMaxPageInRange();
  4244.                     $finalPaginator['lastPage'] = $paginator->getLastPage();
  4245.                     $finalPaginator['nextPage'] = $paginator->getNextPage();
  4246.                     $finalPaginator['firstPage'] = $paginator->getFirstPage();
  4247.                     $finalPaginator['RequestStack'] = json_encode($paginator->RequestStack);
  4249.                     $responseArrWithPagination['paginator'] = $finalPaginator;
  4250.                     $responseArrWithPagination['clients'] = $ClientPaginator;
  4252.                     $this->createFileJson($path, "\r" . 'points local'. json_encode($ClientPaginator) ."\r");
  4253.                     $msg = "Restaurant ok";
  4255.                 } else {
  4257.                     $this->createFileJson($path, "\r" . 'Not points local'."\r");
  4258.                     $msg = "Restaurant no found clients with points";
  4259.                 }
  4261.             } else {
  4262.                 $msg = "Client not Found";
  4263.                 $this->createFileJson($path, "\r" . 'Client not found'."\r");
  4264.             } 
  4266.             if (isset($clientsIdInArray) && !empty($clientsIdInArray)) {
  4267.                 $dataToCommand = ['clientsId' => implode(' ', $clientsIdInArray)];
  4268.                 ForcedAsynchronousCommandsUtil::omtClientAddressAsyncRegistOnLicensor($this->realContainer, $dataToCommand);
  4269.             }
  4271.             $responseArrWithPagination['msg'] = $msg;
  4272.             $responseArrWithPagination['status'] = WebService::CODE_SUCCESS;
  4273.             $responseArrWithPagination['bigbag'] = true;  
  4274.             
  4275.             $theUrlTrSt = new LicensorGenericTransformer($this->realContainer, $responseArrWithPagination);
  4276.             $xxArray = $theUrlTrSt->transform();
  4277.             $jsonContent = json_encode($xxArray);
  4278.             
  4279.             if ($debug) {
  4281.                 dump($responseArrWithPagination);
  4282.                 $this->createFileJson($path, "\r" . 'Response'."\r" . $jsonContent );
  4283.                 die;
  4284.             }
  4286.             return $this->respondWithItem($jsonContent, $theUrlTrSt);
  4288.         } catch (\Throwable $th) {
  4290.             $err = ['Error message' => $th->getMessage(), 'Error Line' => $th->getLine(), 'Error File' => $th->getFile(), 'Error Trance' => $th->getTrace()];
  4291.             $this->createFileJson($path, "\r" . 'Alert Error => '. json_encode($err) ."\r" );
  4293.             return $this->errorInternalError($err);
  4294.         }   
  4295.     }
  4297.     public function saveNewTypePointAccount($em, $clientToGetPoint, $data, $path){
  4299.         $debug=isset($data["debug"]) ? true :false;
  4301.         if($debug){
  4302.             dump("Data de entrada ",$data);
  4303.         }
  4305.         // se verifica el restaurante
  4306.         $license=$em->getRepository('App\Entity\AccountLicense')->GetLicenseActive($data["nickname"], $debug);
  4308.         if($debug){
  4309.             dump("License ",$license);
  4310.         }
  4311.         
  4312.         if(empty($license)) {
  4313.             return false;
  4314.         } else { 
  4316.             // Se buscan todos los id de typePointAcount para luego generaruno atomaticamente
  4317.             $existingUUIDs = $em->getRepository('App\Entity\TypePointAcount');
  4319.             // dump("uuid 1", $existingUUIDs);die;
  4321.             $newUUID = $this->validateUUID($existingUUIDs, $path);
  4323.             if (!$newUUID) {
  4324.                 $this->createFileJson($path, 'Limit time for valid UID search reached...' . "\r");
  4325.                 return $this->setStatusCode(WebService::HTTP_CODE_UNAUTHORIZED)
  4326.                                 ->respondWithError('Limit time for valid UID search reached...', WebService::CODE_COULD_NOT_AUTHENTICATE);
  4327.             }
  4328.             
  4329.             // se extraen la entidad del tipo de puntos Locales 
  4330.             $typePoint = $em->getRepository('App\Entity\TypePoint')->findOneBy(["type"=>TypePoint::TYPE_LOCAL]);
  4332.             $resp = $this->savePointAccount($em, $clientToGetPoint, $data, $path);
  4333.     
  4334.             $countryData=$em->getRepository('App\Entity\City')->getLocationCountry($license[0]->getCity());
  4336.             $typePointAccountData = new TypePointAcount();
  4337.             
  4338.             $typePointAccountData->setId($newUUID);
  4339.             $typePointAccountData->setTypePoint($typePoint);
  4340.             $typePointAccountData->setLicense($license[0]);
  4341.             $typePointAccountData->setPointAcount($resp["pointAccountData"]);
  4342.             $typePointAccountData->setCountryId($countryData[0]);
  4343.             $typePointAccountData->setAmount(0);
  4344.             $typePointAccountData->setPointArmAcount('Pepito Habla Ingles!');
  4345.             $typePointAccountData->setStartingDate(new \DateTime());
  4346.             $typePointAccountData->setAcountToken($resp["tokenAcount"]);
  4348.             if (isset($data['Spots']) && !empty($data['Spots']) && $data['Spots'] != '0' && $data['Spots'] != 0) {
  4349.                 
  4350.                 if (!is_null($path)) {
  4351.                     $this->createFileJson($path, 'The request has spots => ' . $data['Spots'] . "\r");
  4352.                 }
  4354.                 $typePointAccountData->setAmount($data['Spots']);
  4355.             }
  4357.             $em->persist($typePointAccountData);
  4358.             $em->flush();
  4359.             return $typePointAccountData;
  4360.         }  
  4361.     }
  4363.     public function validateUUID($existingUUIDs, $path = null){
  4365.         $validate = false;
  4366.         $count = 0;
  4368.         $newUUID = '';
  4370.         while (!$validate && $count < 50) {
  4371.             if(isset($path) && !is_null($path)){
  4372.                 $this->createFileJson($path, 'Generación de uuid ' . $count ."\r");
  4373.             }
  4374.             $newUUID = UUIDGeneratorUtil::getUUIDv4();
  4375.             $getData = $existingUUIDs->getAllIv2validedateNewUuid($newUUID);
  4376.             // $validate = !in_array($newUUID, $existingUUIDs);
  4377.             $validate = !empty($getData) ? false : true; 
  4378.             ++$count;
  4379.         }
  4380.         if(isset($path) && !is_null($path)){
  4381.                 $this->createFileJson($path, 'nuevo  uuid ' . $newUUID ."\r");
  4382.                 $this->createFileJson($path, 'respuesta del validador despues del while de la muerte' . $validate ."\r");
  4383.             }
  4384.         if (!$validate) {
  4385.             return false;
  4386.         }
  4388.         return $newUUID;
  4389.     }
  4391.     public function generateToken($em, $path=null, $base=null){
  4393.         $baseToken = "";
  4394.         $tokenAcount = "";
  4395.         $count=0;
  4397.         if(isset($path) && !is_null($path)){
  4398.             $this->createFileJson($path, 'base  ' . $base ."\r");
  4400.         }
  4401.         do{
  4402.             if(isset($path) && !is_null($path)){
  4403.                 $this->createFileJson($path, 'Generación de token ' . $count ."\r");
  4404.             }
  4405.             if($count > 0 ){
  4406.                 $baseToken = Utilx::randomPassword(32);
  4407.             }
  4408.             else{
  4409.                 $baseToken = is_null($base) ? Utilx::randomPassword(32):$base;
  4410.             }
  4412.             $tokenAcount = Encryptor::encodeInfo($baseToken, 5);
  4413.             $acountToken = $em->getRepository('App\Entity\TypePointAcount')->findBy(['acountToken' => $tokenAcount]);
  4414.             if(isset($path) && !is_null($path)){
  4415.                 $this->createFileJson($path, 'base token ' . $baseToken ."\r");
  4416.                 $this->createFileJson($path, 'token account' . $tokenAcount ."\r");
  4417.                 if(isset($acountToken[0])){
  4418.                     $this->createFileJson($path, 'acount Token' .$acountToken[0]->getAcountToken() ."\r");
  4419.                 }
  4420.                 
  4422.             }
  4423.             ++$count;
  4424.         } while(!empty($acountToken) && $count < 50);
  4426.         if (!empty($acountToken)) {
  4427.             return false;
  4428.         }
  4430.         return ["baseToken"=>$baseToken, "tokenAcount" => $tokenAcount];
  4431.     }
  4433.     public function savePointAccount($em, $clientToGetPoint, $data, $path){
  4435.         $pointAccountData = $em->getRepository('App\Entity\PointAcount')->findOneBy(["omtClient" => $clientToGetPoint->getId()]);
  4436.             
  4437.         // Se valiuda si existe cuenta de puntos, sino existe se cera una 
  4438.         if (!isset($pointAccountData) && empty($pointAccountData)) {
  4439.             
  4440.             $pointAccountData = new PointAcount();
  4441.             $pointAccountData->setId($clientToGetPoint->getId());
  4442.             
  4443.             /*$existingUUIDsPA = $em->getRepository('App\Entity\PointAcount');
  4444.             
  4445.             $this->createFileJson($path, 'savePointAccount -> Se valida la existencia de la cuenta de puntos ' . "\r");
  4446.             $newUUIDPA = $this->validateUUID($existingUUIDsPA, $path);
  4447.             if (!$newUUIDPA) {
  4448.                 $this->createFileJson($path, 'savePointAccount ->Limit time for valid UID 2 search reached...' . "\r");
  4449.                 return $this->setStatusCode(WebService::HTTP_CODE_UNAUTHORIZED)
  4450.                                 ->respondWithError('Limit time for valid UID 2 search reached...', WebService::CODE_COULD_NOT_AUTHENTICATE);
  4451.             }
  4452.             $pointAccountData->setId($newUUIDPA);*/
  4454.             if(isset($data['basePointacount'])) {
  4455.                 $baseToken=$data['basePointacount'];
  4456.             } else {
  4457.                 $tokens=$this->generateToken($em, $path);
  4458.                 if (!$tokens) {
  4459.                     $this->createFileJson($path, 'savePointAccount -> Limit time for valid token search reached...' . "\r");
  4460.                     return $this->setStatusCode(WebService::HTTP_CODE_UNAUTHORIZED)
  4461.                                     ->respondWithError('Limit time for valid token search reached...', WebService::CODE_COULD_NOT_AUTHENTICATE);
  4462.                 }
  4463.                 $baseToken = $tokens['baseToken'];
  4464.                 $tokenAcount = $tokens['tokenAcount'];
  4465.             }
  4466.             
  4467.             $pointAccountData->setOmtClient($clientToGetPoint->getId());
  4468.             $pointAccountData->setBasePointacount($baseToken);
  4469.             $date = isset($data['activationDate']) ? new \DateTime($data['activationDate']) : new \DateTime("NOW");
  4470.             $pointAccountData->setActivationDate($date);
  4471.             
  4472.             $em->persist($pointAccountData);
  4473.             $em->flush();
  4474.         } else {
  4475.             $tokens=$this->generateToken($em, $path, $pointAccountData->getBasePointacount());
  4476.             if (!$tokens) {
  4477.                 $this->createFileJson($path, 'savePointAccount -> Limit time for valid token 2 search reached...' . "\r");
  4478.                 return $this->setStatusCode(WebService::HTTP_CODE_UNAUTHORIZED)
  4479.                                 ->respondWithError('Limit time for valid token 2 search reached...', WebService::CODE_COULD_NOT_AUTHENTICATE);
  4480.             }
  4481.             $tokenAcount = $tokens['tokenAcount'];
  4482.         }
  4483.         return ["tokenAcount" => $tokenAcount, "pointAccountData" => $pointAccountData];
  4484.     }
  4487.     /**
  4488.      * Esta función retorna los punto a un cliente.
  4489.      * @param Uuid id de la orden
  4490.      * @param String license nickname
  4491.      * @param String clienteID from cliente
  4492.      * @param String type point local-gloval
  4493.      * @param String Uid server id
  4494.      */
  4495.     public function returnLoyaltyCash(Request $request, ArmorService $armor, Log $log){
  4497.          // Creamos el log
  4498.         $path = Util::getValidActiveLogByBaseName($this->realContainer, 'returnLoyaltyCash', 'returnLoyaltyCash.txt');
  4499.         $this->createFileJson($path, "\r" . '**-----------------------------------------------------------------------------**' . "\r");
  4500.         $this->createFileJson($path, "\r" . 'returnLoyaltyCash init: ' . $request->getContent() . "\r");
  4502.         //  validamos el metodo del request
  4503.         if ($request->getMethod() !== WebService::REQUEST_METHOD_POST && $request->getMethod() !== WebService::REQUEST_METHOD_OPTIONS) {
  4504.             return $this->errorNotAllowedMethod('Method not allowed. Use ' . WebService::REQUEST_METHOD_POST . " method");
  4505.         }
  4507.         // Validamos el metodo de la petición
  4508.         if ($request->getMethod() === WebService::REQUEST_METHOD_OPTIONS) {
  4509.             $responseArrayAux1['status'] = WebService::CODE_SUCCESS;
  4510.             $responseArrayAux1['msg'] = 'OPTIONS detected, good to go!';
  4512.             $theUrlTrSt = new LicensorGenericTransformer($this->realContainer, $responseArrayAux1);
  4513.             $jsonTransform = $theUrlTrSt->transform();
  4515.             $jsonContent = json_encode($jsonTransform);
  4517.             return $this->respondWithItem($jsonContent, $theUrlTrSt);
  4518.         }
  4520.         $params = json_decode($request->getContent(), true);
  4522.         //  Validamos los parametros del de a consulta 
  4523.         if (!isset($params['nickname']) || !isset($params['orderId']) || !isset($params['clienteID'])) {
  4524.             return $this->errorWrongArgs('Wrong Arguments', WebService::CODE_WRONG_ARGUMENTS);
  4525.         }
  4527.         // Se inicia el entiti manager
  4528.         $container = $this->realContainer;
  4529.         $em = $this->getDoctrine()->getManager();
  4530.         
  4531.         // se busca el restaurante en base de datos
  4532.         $data = ['alLicenseUsername' => $params['nickname']];
  4533.         $accountLicenseData = $em->getRepository('App\Entity\AccountLicense')->findByAlLicenseUsername($data);
  4535.         //  se valida el estado del restaurante
  4536.         $validate = $this->validateLicense(count($accountLicenseData), $path, $accountLicenseData);
  4537.         if(!$validate["status"]){
  4538.             return $this->setStatusCode($validate["status"])
  4539.                             ->respondWithError($validate["message"], $validate["code"]);
  4540.         }
  4542.         
  4543.         // if(isset($params['uid'])){
  4545.         //     $this->createFileJson($path, "\r" . 'Request Android' . "\r");
  4546.         //     if ($accountLicenseData[0]->getDeviceUid() != $params['uid']) {
  4547.         //         // $emLev = Util::emLicenseConnection($this->realContainer, $em, $accountLicenseData[0]);
  4549.         //         $registeredClientsByUID = $emLev->getRepository('App\Structure\Stations')->findBy(['staDeviceCode' => $params['uid']]);
  4551.         //         if (empty($registeredClientsByUID)) {
  4552.         //             $emLev->close();
  4553.         //             $this->createFileJson($path, 'UID diferente! o.O' . "\r");
  4554.         //             return $this->setStatusCode(WebService::HTTP_CODE_UNAUTHORIZED)
  4555.         //                             ->respondWithError('Unknown device', WebService::CODE_UNAUTHORIZED);
  4556.         //         } else {
  4557.         //             $emLev->close();
  4558.         //         }
  4559.         //     }
  4560.         // }
  4561.         
  4562.         // Se crea el entity manager para level web
  4563.         $emLev = Util::emLicenseConnection($this->realContainer, $em, $accountLicenseData[0]);
  4565.         // se crea el valor del flag (en este caso es 1) para ingresarlo en la base de datos
  4566.         $params['flagRedime'] = LoyaltyHistory::FLAG_RETURN_POINT;
  4567.         
  4568.         //  se busca y se valida la orden en mesa pedido.
  4569.         // $mesaPedido = $emLev->getRepository('App\Structure\Mesapedido')->find($params['orderId']);
  4570.         
  4571.         // if(isset($params["debug"])){
  4572.         //     dump($mesaPedido);
  4573.         // }
  4574.         
  4575.         // if(is_null($mesaPedido) || (!is_null($mesaPedido) && $mesaPedido->getMpEstado() != Mesapedido::MESAPEDIDO_STATUS_CANCELED)){
  4576.         //     $this->createFileJson($path, "\r" . 'the return of loyalty cash is inappropriate for the order' . WebService::CODE_ACCOUNT_SUSPENDED . "\r");
  4578.         //     return $this->setStatusCode(WebService::HTTP_CODE_UNAUTHORIZED)
  4579.         //                 ->respondWithError("the return of loyalty cash is inappropriate for the order", WebService::CODE_ACCOUNT_SUSPENDED);
  4580.         // }
  4581.         
  4582.         // se busaca la ultima transacción hecha por loyalty
  4583.         $loyaltyHistory = $emLev->getRepository('App\Structure\LoyaltyHistory')->getLastCustomerInfo($params['orderId']);
  4584.         
  4585.         //  se busca el cliente y la cuenta de loyalty
  4586.         $clientReposiroty = $em->getRepository('App\Entity\OmtClient');
  4587.         $clientToGetPoint = $clientReposiroty->clientWithPhone2analis($params["clienteID"]);
  4589.         if(!is_array($clientToGetPoint)){
  4590.             $this->createFileJson($path, "\r" . 'client not found' . WebService::CODE_ACCOUNT_SUSPENDED . "\r");
  4591.             
  4592.             return $this->setStatusCode(WebService::HTTP_CODE_UNAUTHORIZED)
  4593.                         ->respondWithError("client not found", WebService::CODE_ACCOUNT_SUSPENDED);
  4594.         }
  4596.         // clienteID
  4597.         $params['customerId'] = isset($clientToGetPoint["id"]) ? $clientToGetPoint["id"] : null;
  4599.         //  se obtiene la cuenta de puntos de del uysuatio en el restaurante   $seedData['customerId'], $activeRuleToAnalyze->getPointType()->getId(), $license->getId(), (isset($seedData['debug']) ? true : false)
  4600.         // $typePointAccountData = $em->getRepository('App\Entity\TypePointAcount')->findOneBy(['license' => $accountLicenseData[0]->getId(), 'pointAcount' => $clientToGetPoint["pointAcount"]]);
  4601.         $typePointAccountData = $em->getRepository('App\Entity\TypePointAcount')->findUserPtAccount($params['customerId'], TypePoint::WORK_AS_LOCAL, $accountLicenseData[0]->getId());
  4602.         
  4603.         if(!isset($typePointAccountData[0])){
  4604.             $this->createFileJson($path, "\r" . 'Account loyalty client not found' . WebService::CODE_ACCOUNT_SUSPENDED . "\r");
  4605.             
  4606.             return $this->setStatusCode(WebService::HTTP_CODE_UNAUTHORIZED)
  4607.             ->respondWithError("Account loyalty client not found", WebService::CODE_ACCOUNT_SUSPENDED);
  4608.         }
  4609.         
  4610.         if(isset($params["debug"])){
  4611.             dump("llegue hasta aca", $params, $clientToGetPoint, $typePointAccountData, $loyaltyHistory);
  4612.         }
  4613.         
  4614.         if((double) $loyaltyHistory[0]["pointsRedeemed"] <= 0){
  4615.             
  4616.             // se obtiene el historial de loyalty de la orden     
  4617.             $params['totalAmount'] = $loyaltyHistory[0]["saleAmount"];
  4618.             
  4619.             
  4620.             // Datos necesarios para armor 
  4621.             $armorPack = [
  4622.                 'request' => $request,
  4623.                 'service' => $armor,
  4624.                 'log' => $log
  4625.             ];
  4626.             
  4627.             if(isset($params["debug"])){
  4628.                 dump("pre-validate armor");
  4629.                 dump($typePointAccountData[0], $armorPack);
  4630.             }
  4632.             $validateArmor = PointsUtilPorcessor::validateLicensorPointsAmountWithArmor($container, $em, $typePointAccountData[0], $armorPack, $path);
  4633.             
  4634.             if(isset($params["debug"])){
  4635.                 dump("validateArmor", $validateArmor);
  4636.             }
  4638.             $activeAplicableRule = $em->getRepository("App\Entity\PtsAdquiRedemRules")->findOneBy(['license' => $accountLicenseData[0]->getId()]);
  4639.             
  4640.             if(isset($params["debug"])){
  4641.                 dump("validateArmor", $activeAplicableRule);
  4642.             }
  4643.             
  4644.             $armorPack['typePointAccount'] = $typePointAccountData[0];
  4645.             $armorPack['license'] = $accountLicenseData[0];
  4646.             $armorPack['preTransactionAmount']=$validateArmor[1];
  4647.             $totalAmount = (double) $params['totalAmount'] / (double) $activeAplicableRule->getPtsRate();
  4648.             
  4649.             $this->createFileJson($path, 'Pre makePtsTransactionToClientAccountInArmorServer call: $armorPack -> ' . json_encode($armorPack) . ' $params -> ' . json_encode($params) . "\r");
  4650.             $createArmor = PointsUtilPorcessor::makePtsTransactionToClientAccountInArmorServer($container, $em, $params, $totalAmount, $activeAplicableRule, $armorPack, $path);
  4651.             
  4652.             if(isset($params["debug"])){
  4653.                 dump("Armor", $createArmor);
  4654.                 // die;
  4655.             }
  4657.             // se llena la base de datos de loyaltyHistory
  4658.             $params['transactionCode'] = $createArmor[1];
  4659.             $params['pointsEarned'] = (double) $createArmor[0];
  4660.             $params['actualAmount'] = (double) $createArmor[3];
  4661.             $params['totalAmount'] = $createArmor[4];
  4663.             $loyaltyRecordCreationResult = PointsUtilPorcessor::createLoyaltyTransactionRecordInLicense($container, $em, $accountLicenseData[0], $clientToGetPoint, $params, $path);
  4665.             $responseArrWithPagination['msg'] = "Return of points";
  4666.             $responseArrWithPagination['status'] = WebService::CODE_SUCCESS;
  4667.             $responseArrWithPagination['bigbag'] = true;  
  4668.             
  4669.             $theUrlTrSt = new LicensorGenericTransformer($this->realContainer, $responseArrWithPagination);
  4670.             $xxArray = $theUrlTrSt->transform();
  4671.             $jsonContent = json_encode($xxArray);
  4672.             
  4673.             if (isset($params["debug"])) {
  4674.                 dump($responseArrWithPagination);
  4675.                 $this->createFileJson($path, "\r" . 'Response'."\r" . $jsonContent );
  4676.                 die;
  4677.             }
  4678.             return $this->respondWithItem($jsonContent, $theUrlTrSt);
  4680.             // // se suben los datos a armor 
  4681.             // $arrayTypePointAccountTokenToArmor = PointsUtilPorcessor::createArrayForPostPutArmorPointRequest($typePointAccountData, $typePointAccountData->getAmount(), $path);
  4682.             // $encodeBase = Encryptor::encodeInfo(json_encode($arrayTypePointAccountTokenToArmor));
  4683.             // $request = $armor->duplicateRequestWithOverwritedContentForArmorServer($request, ['token' => $encodeBase]);
  4685.         }else{
  4687.             $this->createFileJson($path, "\r" . 'No points found to return' . WebService::CODE_ACCOUNT_SUSPENDED . "\r");
  4689.             return $this->setStatusCode(WebService::HTTP_CODE_UNAUTHORIZED)
  4690.             ->respondWithError("No points found to return", WebService::CODE_ACCOUNT_SUSPENDED);
  4691.         }
  4693.         return true;
  4694.     }
  4696.     /**
  4697.      * Valida la licencia de que se sta consultando  
  4698.      */
  4699.     function validateLicense($countResult, $path, $accountLicenseData){
  4700.         if ($countResult <= 0) {
  4701.             $this->createFileJson($path, "\r" . 'Invalid nickname or channelname' . WebService::CODE_COULD_NOT_AUTHENTICATE . "\r");
  4702.             return ["status" => WebService::HTTP_CODE_UNAUTHORIZED, "message" => 'Invalid nickname or channelname', "code"=>WebService::CODE_COULD_NOT_AUTHENTICATE];
  4703.             // $this->setStatusCode(WebService::HTTP_CODE_UNAUTHORIZED)
  4704.             //                 ->respondWithError('Invalid nickname or channelname', WebService::CODE_COULD_NOT_AUTHENTICATE);
  4705.         }
  4707.         if ($accountLicenseData[0]->getAlAccountLicense()->getDeleted()) {
  4708.             $this->createFileJson($path, "\r" . 'Account is inactive' . WebService::CODE_ACCOUNT_SUSPENDED . "\r");
  4709.             return ["status" => WebService::HTTP_CODE_UNAUTHORIZED, "message" => 'Account is inactive', "code" => WebService::CODE_ACCOUNT_SUSPENDED];
  4711.             // return $this->setStatusCode(WebService::HTTP_CODE_UNAUTHORIZED)
  4712.             //                 ->respondWithError('Account is inactive', WebService::CODE_ACCOUNT_SUSPENDED);
  4713.         }
  4715.         if ($accountLicenseData[0]->getAlLicenseStatus() == AccountLicense::LICENSE_STATUS_INACTIVE) {
  4716.             $this->createFileJson($path, "\r" . 'Inactive License' . WebService::CODE_ACCOUNT_SUSPENDED . "\r");
  4717.             return ["status" => WebService::HTTP_CODE_UNAUTHORIZED, "message" => 'Inactive License', "code" => WebService::CODE_ACCOUNT_SUSPENDED];
  4719.         //     return $this->setStatusCode(WebService::HTTP_CODE_UNAUTHORIZED)
  4720.         //                     ->respondWithError('Inactive License', WebService::CODE_ACCOUNT_SUSPENDED);
  4721.         }
  4722.         return ["status" => true];
  4723.     }
  4725.     /**
  4726.      * Obtiene el balance de puntos en la targeta gift card que tenga el cliente
  4727.      * @param String id de la orden
  4728.      */
  4729.     function getGiftCardBalancePoints(Request $request) {
  4731.         // Se verifica que ingrese con el mehod get
  4732.         if ($request->getMethod() == WebService::REQUEST_METHOD_GET) {
  4733.             return $this->errorNotAllowedMethod('Method not allowed. Use ' . WebService::REQUEST_METHOD_GET . " method");
  4734.         }
  4736.         $params = json_decode($request->getContent(), true);
  4738.         // Se inicia el entity manager
  4739.         $container = $this->realContainer;
  4740.         $em = $this->getDoctrine()->getManager();
  4742.         if (isset($params['orderId']) && !empty($params['orderId'])) {
  4744.             $mpCodigo = $params['orderId'];
  4745.             $response = [];
  4747.             $giftCardData = $em->getRepository('App\Entity\GiftCardTransaction')->getTransactionsByOrder($mpCodigo);
  4749.             $response['msg'] = "Your gift card balance";
  4750.             $response['status'] = WebService::CODE_SUCCESS;
  4751.             $response['bigbag'] = true;
  4752.             $response['data'] = $giftCardData != '' ? $giftCardData: null;  
  4754.             $licensorTransformer = new LicensorGenericTransformer($this->realContainer, $response);
  4755.             $transformData = $licensorTransformer->transform();
  4756.             $jsonEncodedData = json_encode($transformData);
  4758.             return $this->respondWithItem($jsonEncodedData, $licensorTransformer);
  4760.         } else {
  4762.             return $this->errorWrongArgs('Wrong Arguments', WebService::CODE_WRONG_ARGUMENTS);
  4764.         }
  4766.     }
  4768.     /**
  4769.      * Function configuration loyalty account to restaurant in omt
  4770.      * 
  4771.      */
  4772.     public function createOrUpdateLoyaltyConfigurationOmt($em, $params){
  4774.         $container = $this->realContainer;
  4775.         $restaurantEntity = $em->getRepository('App\Entity\AccountLicense')->find($params['license']);
  4777.         $arrayToRequest = [
  4778.             "restNickname" => $restaurantEntity->getAlLicenseUsername(),
  4779.             "minimumPointAmountToExchange" => $params['minimumPointAmountToExchange'],
  4780.             "useLocalPoints" => true,
  4781.             "useGlobalPoints" => false,
  4782.             "ptsRate" => $params['ptsRate'],
  4783.             "minimumPurchase" => $params['minimumPurchase'],
  4784.             "restaurantId" => $restaurantEntity->getAlLicenseUsername(),
  4785.         ]; 
  4787.         $url = $container->getParameter('omt_scheme') . '://' . $container->getParameter('omt_host') . 'common/setLoyaltyConfiguration';
  4788.         
  4789.         $ch = curl_init();
  4790.         curl_setopt($ch, CURLOPT_URL, $url);
  4791.         curl_setopt($ch, CURLOPT_POST, true);
  4792.         curl_setopt($ch, CURLOPT_POSTFIELDS, json_encode($arrayToRequest));
  4793.         curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
  4794.         
  4795.         $result = curl_exec($ch);
  4796.         $decodeResult = json_decode($result, true);
  4798.         return $decodeResult;
  4800.     }
  4802. }