src/Service/AuthorizeNetService.php line 43

Open in your IDE?
  1. <?php
  3. namespace App\Service;
  5. use App\Entity\AuthorizeNetErrorLog;
  6. use App\Entity\Charges;
  7. use App\Entity\Users;
  8. use App\Repository\StudentsRepository;
  9. use Psr\Log\LoggerInterface;
  10. use net\authorize\api\contract\v1 as AnetAPI;
  11. use net\authorize\api\controller as AnetController;
  12. use Symfony\Component\Config\Definition\Exception\Exception;
  13. use Symfony\Component\HttpFoundation\Response;
  15. class AuthorizeNetService
  16. {
  17. /**
  18. * @var LoggerInterface
  19. */
  20. private $logger;
  21. /**
  22. * @var ChargesService
  23. */
  24. private $pckChargesService;
  25. /**
  26. * @var AuthorizeNetErrorLogService
  27. */
  28. private $authorizeNetErrorLogService;
  29. private StudentsRepository $studentsRepository;
  31. public function __construct(
  32. LoggerInterface $logger,
  33. ChargesService $pckChargesService,
  34. AuthorizeNetErrorLogService $authorizeNetErrorLogService,
  35. CreditCardsService $creditCardsService,
  36. StudentsRepository $studentsRepository,
  37. ) {
  38. $this->logger = $logger;
  39. $this->authorizeNetPlatform = $_ENV["AUTHNET_PLATFORM"] == 'P' ? \net\authorize\api\constants\ANetEnvironment::PRODUCTION :
  40. \net\authorize\api\constants\ANetEnvironment::SANDBOX;
  41. $this->pckChargesService = $pckChargesService;
  42. $this->authorizeNetErrorLogService = $authorizeNetErrorLogService;
  43. $this->creditCardService = $creditCardsService;
  44. $this->studentsRepository = $studentsRepository;
  45. }
  46. private function getAuthentication()
  47. {
  48. $merchantAuthentication = new AnetAPI\MerchantAuthenticationType();
  49. $merchantAuthentication->setName($_ENV["AUTHNET_LOGIN_ID"]);
  50. $merchantAuthentication->setTransactionKey($_ENV["AUTHNET_TRANSACTION_KEY"]);
  51. return $merchantAuthentication;
  52. }
  54. private function processResponse($response,$studentId,$amount,$description,$apiMethod,$userId = null){
  55. if ($response->getMessages()->getResultCode() == "Ok") {
  56. $tresponse = $response->getTransactionResponse();
  58. if ($tresponse != null && $tresponse->getMessages() != null) {
  59. $transId = $tresponse->getTransId();
  60. } else {
  61. // echo "Transaction Failed \n";
  62. if ($tresponse->getErrors() != null) {
  63. $this->logger->error('charge ERROR: ' . $tresponse->getErrors()[0]->getErrorCode() . ': ' .
  64. $tresponse->getErrors()[0]->getErrorText());
  65. $authorizeError = new AuthorizeNetErrorLog();
  66. $authorizeError->setCreateDate(new \DateTime());
  67. $authorizeError->setStudentId($studentId);
  68. $authorizeError->setUserId($userId);
  69. $authorizeError->setApiMethod($apiMethod);
  70. $authorizeError->setExceptionMsg($tresponse->getErrors()[0]->getErrorText());
  71. $authorizeError->setDetails('amount: ' . $amount . ' description: ' . $description);
  72. $this->authorizeNetErrorLogService->save($authorizeError);
  73. throw new Exception($tresponse->getErrors()[0]->getErrorText());
  74. }
  75. }
  76. } else {
  77. //echo "Transaction Failed \n";
  78. $tresponse = $response->getTransactionResponse();
  79. if ($tresponse != null && $tresponse->getErrors() != null) {
  80. $this->logger->error('charge ERROR: ' . $tresponse->getErrors()[0]->getErrorCode() . ': ' .
  81. $tresponse->getErrors()[0]->getErrorText());
  82. $authorizeError = new AuthorizeNetErrorLog();
  83. $authorizeError->setCreateDate(new \DateTime());
  84. $authorizeError->setStudentId($studentId);
  85. $authorizeError->setUserId($userId);
  86. $authorizeError->setApiMethod($apiMethod);
  87. $authorizeError->setExceptionMsg($tresponse->getErrors()[0]->getErrorText());
  88. $authorizeError->setDetails('amount: ' . $amount . ' description: ' . $description);
  89. $this->authorizeNetErrorLogService->save($authorizeError);
  90. throw new Exception($tresponse->getErrors()[0]->getErrorText());
  91. } else {
  92. $this->logger->error('charge ERROR: ' . $response->getMessages()->getMessage()[0]->getCode() . ': ' .
  93. $response->getMessages()->getMessage()[0]->getText());
  94. $authorizeError = new AuthorizeNetErrorLog();
  95. $authorizeError->setCreateDate(new \DateTime());
  96. $authorizeError->setStudentId($studentId);
  97. $authorizeError->setUserId($userId);
  98. $authorizeError->setApiMethod($apiMethod);
  99. $authorizeError->setExceptionMsg($response->getMessages()->getMessage()[0]->getText());
  100. $authorizeError->setDetails('amount: ' . $amount . ' description: ' . $description);
  101. $this->authorizeNetErrorLogService->save($authorizeError);
  102. // return new Response(json_encode($response->getMessages()->getMessage()[0]->getText()),500);
  103. throw new Exception(json_encode($response->getMessages()->getMessage()[0]->getText()));
  104. }
  105. }
  106. return [$transId,$tresponse];
  107. }
  110. // public function createCustomerProfile($email){
  111. // $merchantAuthentication = $this->getAuthentication();
  112. // // Set the transaction's refId
  113. // $refId = 'ref' . time();
  114. //
  115. // // Set credit card information for payment profile
  116. // $creditCard = new AnetAPI\CreditCardType();
  117. // $creditCard->setCardNumber("4242424242424242");
  118. // $creditCard->setExpirationDate("2038-12");
  119. // $creditCard->setCardCode("142");
  120. // $paymentCreditCard = new AnetAPI\PaymentType();
  121. // $paymentCreditCard->setCreditCard($creditCard);
  122. //
  123. // // Create a new CustomerPaymentProfile object
  124. // $paymentProfile = new AnetAPI\CustomerPaymentProfileType();
  125. // $paymentProfile->setCustomerType('individual');
  126. // $paymentProfile->setPayment($paymentCreditCard);
  127. // $paymentProfiles[] = $paymentProfile;
  128. //
  129. // // Create a new CustomerProfileType and add the payment profile object
  130. // $customerProfile = new AnetAPI\CustomerProfileType();
  131. // $customerProfile->setDescription("Customer 2 Test PHP");
  132. // $customerProfile->setMerchantCustomerId("M_" . time());
  133. // $customerProfile->setEmail($email);
  134. // $customerProfile->setpaymentProfiles($paymentProfiles);
  135. //
  136. // // Assemble the complete transaction request
  137. // $request = new AnetAPI\CreateCustomerProfileRequest();
  138. // $request->setMerchantAuthentication($merchantAuthentication);
  139. // $request->setRefId($refId);
  140. // $request->setProfile($customerProfile);
  141. //
  142. // // Create the controller and get the response
  143. // $controller = new AnetController\CreateCustomerProfileController($request);
  144. // $response = $controller->executeWithApiResponse(\net\authorize\api\constants\ANetEnvironment::SANDBOX);
  145. //
  146. // if (($response != null) && ($response->getMessages()->getResultCode() == "Ok")) {
  147. // echo "Succesfully created customer profile : " . $response->getCustomerProfileId() . "\n";
  148. // $paymentProfiles = $response->getCustomerPaymentProfileIdList();
  149. // echo "SUCCESS: PAYMENT PROFILE ID : " . $paymentProfiles[0] . "\n";
  150. // } else {
  151. // echo "ERROR : Invalid response\n";
  152. // $errorMessages = $response->getMessages()->getMessage();
  153. // echo "Response : " . $errorMessages[0]->getCode() . " " .$errorMessages[0]->getText() . "\n";
  154. // }
  155. // return $response;
  156. // }
  158. // public function chargeCreditCard($amount, $creditCardNumber, $expirationDate, $cardCode, $description, $email){
  159. // $merchantAuthentication = $this->getAuthentication();
  160. // $refId = 'ref' . time();
  161. //
  162. // // Create the payment data for a credit card
  163. // $creditCard = new AnetAPI\CreditCardType();
  164. // $creditCard->setCardNumber($creditCardNumber); //4111111111111111
  165. // $creditCard->setExpirationDate($expirationDate); //2025-12
  166. // $creditCard->setCardCode($cardCode);//123
  167. //
  168. // // Add the payment data to a paymentType object
  169. // $paymentOne = new AnetAPI\PaymentType();
  170. // $paymentOne->setCreditCard($creditCard);
  171. //
  172. // // Create order information
  173. // $order = new AnetAPI\OrderType();
  174. // //$order->setInvoiceNumber("10101");
  175. // $order->setDescription($description);
  176. //
  177. // // Set the customer's identifying information
  178. // $customerData = new AnetAPI\CustomerDataType();
  179. // $customerData->setType("individual");
  180. // $customerData->setId("99999456654");
  181. // $customerData->setEmail($email);
  182. //
  183. // $transactionRequestType = new AnetAPI\TransactionRequestType();
  184. // $transactionRequestType->setTransactionType("authCaptureTransaction");
  185. // $transactionRequestType->setAmount($amount);
  186. // $transactionRequestType->setOrder($order);
  187. // $transactionRequestType->setPayment($paymentOne);
  188. // $transactionRequestType->setCustomer($customerData);
  189. //
  190. // // Assemble the complete transaction request
  191. // $request = new AnetAPI\CreateTransactionRequest();
  192. // $request->setMerchantAuthentication($merchantAuthentication);
  193. // $request->setRefId($refId);
  194. // $request->setTransactionRequest($transactionRequestType);
  195. //
  196. // // Create the controller and get the response
  197. // $controller = new AnetController\CreateTransactionController($request);
  198. // $response = $controller->executeWithApiResponse(\net\authorize\api\constants\ANetEnvironment::SANDBOX);
  199. //
  200. // if ($response != null) {
  201. // // Check to see if the API request was successfully received and acted upon
  202. // if ($response->getMessages()->getResultCode() == "Ok") {
  203. // // Since the API request was successful, look for a transaction response
  204. // // and parse it to display the results of authorizing the card
  205. // $tresponse = $response->getTransactionResponse();
  206. //
  207. // if ($tresponse != null && $tresponse->getMessages() != null) {
  208. // echo " Successfully created transaction with Transaction ID: " . $tresponse->getTransId() . "\n";
  209. // echo " Transaction Response Code: " . $tresponse->getResponseCode() . "\n";
  210. // echo " Message Code: " . $tresponse->getMessages()[0]->getCode() . "\n";
  211. // echo " Auth Code: " . $tresponse->getAuthCode() . "\n";
  212. // echo " Description: " . $tresponse->getMessages()[0]->getDescription() . "\n";
  213. // return ['transId'=>$tresponse->getTransId(),'responseCode' => $tresponse->getResponseCode()];
  214. // } else {
  215. // echo "Transaction Failed \n";
  216. // if ($tresponse->getErrors() != null) {
  217. // echo " Error Code : " . $tresponse->getErrors()[0]->getErrorCode() . "\n";
  218. // echo " Error Message : " . $tresponse->getErrors()[0]->getErrorText() . "\n";
  219. // }
  220. // return ['failed','Error Code'=>$tresponse->getErrors()[0]->getErrorCode(),'Error Message' =>$tresponse->getErrors()[0]->getErrorText()];
  221. // }
  222. // // Or, print errors if the API request wasn't successful
  223. // } else {
  224. // echo "Transaction Failed \n";
  225. // $tresponse = $response->getTransactionResponse();
  226. //
  227. // if ($tresponse != null && $tresponse->getErrors() != null) {
  228. // echo " Error Code : " . $tresponse->getErrors()[0]->getErrorCode() . "\n";
  229. // echo " Error Message : " . $tresponse->getErrors()[0]->getErrorText() . "\n";
  230. // } else {
  231. // echo " Error Code : " . $response->getMessages()->getMessage()[0]->getCode() . "\n";
  232. // echo " Error Message : " . $response->getMessages()->getMessage()[0]->getText() . "\n";
  233. // }
  234. // return 'failed';
  235. // }
  236. // } else {
  237. // echo "No response returned \n";
  238. // }
  239. // }
  241. // public function createAnAcceptPaymentTransaction($amount,$dataDescriptor,$dataValue){
  242. // /* Create a merchantAuthenticationType object with authentication details
  243. // retrieved from the constants file */
  244. // $merchantAuthentication = $this->getAuthentication();
  245. // // Set the transaction's refId
  246. // $refId = 'ref' . time();
  247. //
  248. // // Create the payment object for a payment nonce
  249. // $opaqueData = new AnetAPI\OpaqueDataType();
  250. // $opaqueData->setDataDescriptor($dataDescriptor);
  251. // $opaqueData->setDataValue($dataValue);
  252. //
  253. //
  254. // // Add the payment data to a paymentType object
  255. // $paymentOne = new AnetAPI\PaymentType();
  256. // $paymentOne->setOpaqueData($opaqueData);
  257. //
  258. // // Create order information
  259. // $order = new AnetAPI\OrderType();
  260. // $order->setInvoiceNumber("10101");
  261. // $order->setDescription("Golf Shirts");
  262. //
  263. // // Set the customer's Bill To address
  264. // $customerAddress = new AnetAPI\CustomerAddressType();
  265. // $customerAddress->setFirstName("Ellen");
  266. // $customerAddress->setLastName("Johnson");
  267. // $customerAddress->setCompany("Souveniropolis");
  268. // $customerAddress->setAddress("14 Main Street");
  269. // $customerAddress->setCity("Pecan Springs");
  270. // $customerAddress->setState("TX");
  271. // $customerAddress->setZip("44628");
  272. // $customerAddress->setCountry("USA");
  273. //
  274. // // Set the customer's identifying information
  275. // $customerData = new AnetAPI\CustomerDataType();
  276. // $customerData->setType("individual");
  277. // $customerData->setId("99999456654");
  278. // $customerData->setEmail("EllenJohnson@example.com");
  279. //
  280. // // Add values for transaction settings
  281. // $duplicateWindowSetting = new AnetAPI\SettingType();
  282. // $duplicateWindowSetting->setSettingName("duplicateWindow");
  283. // $duplicateWindowSetting->setSettingValue("60");
  284. //
  285. //
  286. // // Create a TransactionRequestType object and add the previous objects to it
  287. // $transactionRequestType = new AnetAPI\TransactionRequestType();
  288. // $transactionRequestType->setTransactionType("authCaptureTransaction");
  289. // $transactionRequestType->setAmount($amount);
  290. // $transactionRequestType->setOrder($order);
  291. // $transactionRequestType->setPayment($paymentOne);
  292. // $transactionRequestType->setBillTo($customerAddress);
  293. // $transactionRequestType->setCustomer($customerData);
  294. // $transactionRequestType->addToTransactionSettings($duplicateWindowSetting);
  295. //
  296. // // Assemble the complete transaction request
  297. // $request = new AnetAPI\CreateTransactionRequest();
  298. // $request->setMerchantAuthentication($merchantAuthentication);
  299. // $request->setRefId($refId);
  300. // $request->setTransactionRequest($transactionRequestType);
  301. //
  302. // // Create the controller and get the response
  303. // $controller = new AnetController\CreateTransactionController($request);
  304. // $response = $controller->executeWithApiResponse(\net\authorize\api\constants\ANetEnvironment::SANDBOX);
  305. //
  306. //
  307. // if ($response != null) {
  308. // // Check to see if the API request was successfully received and acted upon
  309. // if ($response->getMessages()->getResultCode() == "Ok") {
  310. // // Since the API request was successful, look for a transaction response
  311. // // and parse it to display the results of authorizing the card
  312. // $tresponse = $response->getTransactionResponse();
  313. //
  314. // if ($tresponse != null && $tresponse->getMessages() != null) {
  315. // $transId = $tresponse->getTransId();
  316. // } else {
  317. // echo "Transaction Failed \n";
  318. // if ($tresponse->getErrors() != null) {
  319. // echo " Error Code : " . $tresponse->getErrors()[0]->getErrorCode() . "\n";
  320. // echo " Error Message : " . $tresponse->getErrors()[0]->getErrorText() . "\n";
  321. // }
  322. // }
  323. // // Or, print errors if the API request wasn't successful
  324. // } else {
  325. // echo "Transaction Failed \n";
  326. // $tresponse = $response->getTransactionResponse();
  327. //
  328. // if ($tresponse != null && $tresponse->getErrors() != null) {
  329. // echo " Error Code : " . $tresponse->getErrors()[0]->getErrorCode() . "\n";
  330. // echo " Error Message : " . $tresponse->getErrors()[0]->getErrorText() . "\n";
  331. // } else {
  332. // echo " Error Code : " . $response->getMessages()->getMessage()[0]->getCode() . "\n";
  333. // echo " Error Message : " . $response->getMessages()->getMessage()[0]->getText() . "\n";
  334. // }
  335. // }
  336. // } else {
  337. // echo "No response returned \n";
  338. // }
  339. //
  340. // return ['transaction_id'=>$transId,'authResultCode'=>$response->getMessages()->getResultCode(), 'authNetResponse'=>$tresponse->getAuthCode()];
  341. // }
  342. public function chargeCustomerProfile($customerProfileId, $paymentProfileId, $amount, $description, $email , $studentName , $studentId, $allowDuplicateTransaction = false)
  343. {
  344. $transId = '';
  345. // Set the transaction's refId
  346. $refId = 'ref' . time();
  348. $this->checkAndUpdateCustomerProfile($studentId);
  350. $profileToCharge = new AnetAPI\CustomerProfilePaymentType();
  351. $profileToCharge->setCustomerProfileId($customerProfileId);
  352. $paymentProfile = new AnetAPI\PaymentProfileType();
  353. $paymentProfile->setPaymentProfileId($paymentProfileId);
  354. $profileToCharge->setPaymentProfile($paymentProfile);
  356. // Create order information
  357. $order = new AnetAPI\OrderType();
  358. # TODO: How do we want to set the invoice number??
  359. #$order->setInvoiceNumber("10101");
  360. $order->setDescription($description);
  362. $transactionRequestType = new AnetAPI\TransactionRequestType();
  363. $transactionRequestType->setTransactionType("authCaptureTransaction");
  364. $transactionRequestType->setAmount($amount);
  365. $transactionRequestType->setOrder($order);
  366. $transactionRequestType->setProfile($profileToCharge);
  368. if ($allowDuplicateTransaction) {
  369. $duplicateWindowSetting = new AnetAPI\SettingType();
  370. $duplicateWindowSetting->setSettingName("duplicateWindow");
  371. $duplicateWindowSetting->setSettingValue("0");
  372. $transactionRequestType->addToTransactionSettings($duplicateWindowSetting);
  373. }
  375. $request = new AnetAPI\CreateTransactionRequest();
  376. $request->setMerchantAuthentication($this->getAuthentication());
  377. $request->setRefId($refId);
  378. $request->setTransactionRequest($transactionRequestType);
  379. $controller = new AnetController\CreateTransactionController($request);
  380. $response = $controller->executeWithApiResponse($this->authorizeNetPlatform);
  383. if ($response != null) {
  384. [$transId,$tresponse]=$this->processResponse($response,$studentId,$amount,$description,'chargeCustomerProfile');
  385. } else {
  386. $this->logger->error('ERROR: No Response');
  387. throw new Exception('No Response');
  388. }
  390. # Is there a specific reason why these are named differently to how they are named in accept.js?
  391. return ['transaction_id' => $transId,'authResultCode' => $response->getMessages()->getResultCode(), 'authNetResponse' => $tresponse->getAuthCode()];
  392. }
  394. public function createCustomerProfileFromAcceptNonce(
  395. $studentId,
  396. $firstName,
  397. $lastName,
  398. $cardholderName,
  399. $zipcode,
  400. $email,
  401. $acceptPaymentDescriptor,
  402. $acceptPaymentValue
  403. ) {
  404. // Set the transaction's refId
  405. $refId = 'ref' . time();
  407. // Set the payment data for the payment profile to a token obtained from Accept.js
  408. $op = new AnetAPI\OpaqueDataType();
  409. $op->setDataDescriptor($acceptPaymentDescriptor);
  410. $op->setDataValue($acceptPaymentValue);
  411. $paymentOne = new AnetAPI\PaymentType();
  412. $paymentOne->setOpaqueData($op);
  414. $billTo = $this->getBillTo($cardholderName, $zipcode);
  416. // Create a new CustomerPaymentProfile object
  417. $paymentProfile = new AnetAPI\CustomerPaymentProfileType();
  418. $paymentProfile->setCustomerType('individual');
  419. $paymentProfile->setBillTo($billTo);
  420. $paymentProfile->setPayment($paymentOne);
  421. $paymentProfiles[] = $paymentProfile;
  423. // Create a new CustomerProfileType and add the payment profile object
  424. $customerProfile = new AnetAPI\CustomerProfileType();
  425. $customerProfile->setDescription($lastName . ', ' . $firstName);
  426. $customerProfile->setMerchantCustomerId($studentId);
  427. $customerProfile->setEmail($email);
  428. $customerProfile->setPaymentProfiles($paymentProfiles);
  430. // Assemble the complete transaction request
  431. $request = new AnetAPI\CreateCustomerProfileRequest();
  432. $request->setMerchantAuthentication($this->getAuthentication());
  433. $request->setRefId($refId);
  434. $request->setProfile($customerProfile);
  435. //$request->setValidationMode('testMode');
  437. // Create the controller and get the response
  438. $controller = new AnetController\CreateCustomerProfileController($request);
  439. $response = $controller->executeWithApiResponse($this->authorizeNetPlatform);
  441. if (($response == null) || ($response->getMessages()->getResultCode() != "Ok")) {
  442. $errorMessages = $response->getMessages()->getMessage();
  443. $this->logger->error('Error: StudentId: ' . $studentId . ' - ' . $errorMessages[0]->getCode() . ': ' . $errorMessages[0]->getText());
  444. $authorizeError = new AuthorizeNetErrorLog();
  445. $authorizeError->setCreateDate(new \DateTime());
  446. $authorizeError->setStudentId($studentId);
  447. $authorizeError->setApiMethod('CreateCustomerProfileRequest');
  448. $authorizeError->setExceptionMsg($errorMessages[0]->getText());
  449. $this->authorizeNetErrorLogService->save($authorizeError);
  450. //$authorizeError->setRequestBody($request);
  451. throw new Exception($errorMessages[0]->getCode() . ': ' . $errorMessages[0]->getText());
  452. }
  453. return array('customerProfileId' => $response->getCustomerProfileId(),
  454. 'paymentProfileId' => $response->getCustomerPaymentProfileIdList()[0]);
  455. }
  457. private function getBillTo($cardholderName, $zipcode)
  458. {
  459. $cardholderNameArray = explode(" ", $cardholderName);
  460. $lastName = array_pop($cardholderNameArray);
  461. $firstName = implode(" ", $cardholderNameArray);
  462. // Create the Bill To info for new payment type
  463. $billTo = new AnetAPI\CustomerAddressType();
  464. $billTo->setFirstName($firstName);
  465. $billTo->setLastName($lastName);
  466. $billTo->setZip($zipcode);
  467. return $billTo;
  468. }
  470. public function createCustomerPaymentProfileFromAcceptNonce(
  471. $customerProfileId,
  472. $cardholderName,
  473. $zipcode,
  474. $email,
  475. $acceptPaymentDescriptor,
  476. $acceptPaymentValue,
  477. $studentName ,
  478. $studentId
  479. ) {
  480. // Set the transaction's refId
  481. $refId = 'ref' . time();
  483. // Set the payment data for the payment profile to a token obtained from Accept.js
  484. $op = new AnetAPI\OpaqueDataType();
  485. $op->setDataDescriptor($acceptPaymentDescriptor);
  486. $op->setDataValue($acceptPaymentValue);
  487. $paymentOne = new AnetAPI\PaymentType();
  488. $paymentOne->setOpaqueData($op);
  490. $billTo = $this->getBillTo($cardholderName, $zipcode);
  492. // Create a new CustomerPaymentProfile object
  493. $paymentProfile = new AnetAPI\CustomerPaymentProfileType();
  494. $paymentProfile->setCustomerType('individual');
  495. $paymentProfile->setBillTo($billTo);
  496. $paymentProfile->setPayment($paymentOne);
  497. $paymentProfiles[] = $paymentProfile;
  499. // Assemble the complete transaction request
  500. $request = new AnetAPI\CreateCustomerPaymentProfileRequest();
  501. $request->setMerchantAuthentication($this->getAuthentication());
  503. // Add an existing profile id to the request
  504. $request->setCustomerProfileId($customerProfileId);
  505. $request->setPaymentProfile($paymentProfile);
  506. //$request->setValidationMode('testMode');
  508. // Create the controller and get the response
  509. $controller = new AnetController\CreateCustomerPaymentProfileController($request);
  510. $response = $controller->executeWithApiResponse($this->authorizeNetPlatform);
  512. if (($response == null) || ($response->getMessages()->getResultCode() != "Ok")) {
  513. $errorMessages = $response->getMessages()->getMessage();
  514. $this->logger->error('Error: ' . $errorMessages[0]->getCode() . ': ' . $errorMessages[0]->getText());
  515. $authorizeError = new AuthorizeNetErrorLog();
  516. $authorizeError->setCreateDate(new \DateTime());
  517. $authorizeError->setStudentId($studentId);
  518. $authorizeError->setApiMethod('CreateCustomerPaymentProfileController');
  519. $authorizeError->setExceptionMsg($errorMessages[0]->getText());
  520. $this->authorizeNetErrorLogService->save($authorizeError);
  521. throw new Exception($errorMessages[0]->getCode() . ': ' . $errorMessages[0]->getText());
  522. }
  524. return $response->getCustomerPaymentProfileId();
  525. }
  527. public function refundTransaction(Charges $charge, $amount)
  528. {
  529. $this->checkAndUpdateCustomerProfile($charge->getStudentid());
  531. $merchantAuthentication = $this->getAuthentication();
  532. $cc = $this->creditCardService->find($charge->getCcid());
  533. // Set the transaction's refId
  534. $refId = 'ref' . time();
  537. // Create the payment data for a credit card
  538. $creditCard = new AnetAPI\CreditCardType();
  539. //$creditCard->setCardNumber("1111");
  540. $creditCard->setCardNumber($cc->getCc4digits());//$charge->getCcLast4()
  541. $creditCard->setExpirationDate($cc->getCcexpmonth() . $cc->getCcexpyear());//$charge->getCcExp()
  542. $paymentOne = new AnetAPI\PaymentType();
  543. $paymentOne->setCreditCard($creditCard);
  544. //create a transaction
  545. $transactionRequest = new AnetAPI\TransactionRequestType();
  546. $transactionRequest->setTransactionType("refundTransaction");
  547. $transactionRequest->setAmount($amount);
  548. $transactionRequest->setPayment($paymentOne);
  549. $transactionRequest->setRefTransId($charge->getTransid());
  551. $request = new AnetAPI\CreateTransactionRequest();
  552. $request->setMerchantAuthentication($merchantAuthentication);
  553. $request->setRefId($refId);
  554. $request->setTransactionRequest($transactionRequest);
  555. $controller = new AnetController\CreateTransactionController($request);
  556. $response = $controller->executeWithApiResponse($this->authorizeNetPlatform);
  558. return $response;
  559. }
  561. public function voidTransaction($transactionid,$studentId)
  562. {
  563. $this->checkAndUpdateCustomerProfile($studentId);
  565. $merchantAuthentication = $this->getAuthentication();
  566. $refId = 'ref' . time();
  567. $transactionRequestType = new AnetAPI\TransactionRequestType();
  568. $transactionRequestType->setTransactionType("voidTransaction");
  569. $transactionRequestType->setRefTransId($transactionid);
  570. $request = new AnetAPI\CreateTransactionRequest();
  571. $request->setMerchantAuthentication($merchantAuthentication);
  572. $request->setRefId($refId);
  573. $request->setTransactionRequest($transactionRequestType);
  574. $controller = new AnetController\CreateTransactionController($request);
  575. $response = $controller->executeWithApiResponse($this->authorizeNetPlatform);
  577. return $response;
  578. }
  580. private function checkAndUpdateCustomerProfile($studentId)
  581. {
  582. // $student = $this->student
  583. $student = $this->studentsRepository->find($studentId);
  584. if(!$student->getAuthnetProfileUpdated()){
  585. $response = $this->updateCustomerProfile($student);
  586. if($response->getMessages()->getResultCode() == "Ok"){
  587. $student->setAuthnetProfileUpdated(new \DateTime());
  588. $this->studentsRepository->save($student);
  589. }
  590. }
  591. }
  593. function updateCustomerProfile($student)
  594. {
  595. $merchantAuthentication = $this->getAuthentication();
  597. // Update an existing customer profile
  599. $updatecustomerprofile = new AnetAPI\CustomerProfileExType();
  600. $updatecustomerprofile->setCustomerProfileId($student->getCimId());
  601. $updatecustomerprofile->setDescription($student->getLastname() . ', ' . $student->getFirstname());
  602. $updatecustomerprofile->setMerchantCustomerId($student->getId());
  603. $updatecustomerprofile->setEmail($student->getEmail());
  605. $request = new AnetAPI\UpdateCustomerProfileRequest();
  606. $request->setMerchantAuthentication($merchantAuthentication);
  607. $request->setProfile($updatecustomerprofile);
  609. $controller = new AnetController\UpdateCustomerProfileController($request);
  610. $response = $controller->executeWithApiResponse($this->authorizeNetPlatform);
  612. return $response;
  613. }
  615. public function chargeCustomerWithNewProfile(
  616. $student,
  617. $acceptPaymentDescriptor,
  618. $acceptPaymentValue,
  619. $amount,
  620. $ccName,
  621. $ccLast4,
  622. $ccExpMonth,
  623. $ccExpYear,
  624. $billingZipCode,
  625. $ccType,
  626. $chargeDescription,
  627. $toCharge = true
  628. ) {
  629. if (!$student->getCimid()) {
  630. $profileIds = $this->createCustomerProfileFromAcceptNonce(
  631. $student->getId(),
  632. $student->getFirstname(),
  633. $student->getLastname(),
  634. $ccName,
  635. $billingZipCode,
  636. $student->getEmail(),
  637. $acceptPaymentDescriptor,
  638. $acceptPaymentValue
  639. );
  640. $customerProfileId = $profileIds['customerProfileId'];
  641. $student->setCimid($customerProfileId);
  642. $this->studentsRepository->save($student);
  643. $paymentProfileId = $profileIds['paymentProfileId'];
  644. } else {
  645. $paymentProfileId = $this->createCustomerPaymentProfileFromAcceptNonce(
  646. $student->getCimid(),
  647. $ccName,
  648. $billingZipCode,
  649. $student->getEmail(),
  650. $acceptPaymentDescriptor,
  651. $acceptPaymentValue,
  652. $student->getLastname() . ', ' . $student->getFirstname(),
  653. $student->getId()
  654. );
  655. }
  657. if ($toCharge) {
  658. $response = $this->chargeCustomerProfile(
  659. $student->getCimid(),
  660. $paymentProfileId,
  661. $amount,
  662. $chargeDescription,
  663. $student->getEmail(),
  664. $student->getLastname() . ', ' . $student->getFirstname(),
  665. $student->getId()
  666. );
  667. }
  670. $cc = $this->creditCardService->addCreditCard(
  671. $student->getId(),
  672. $paymentProfileId,
  673. $ccName,
  674. $ccLast4,
  675. $ccExpMonth,
  676. $ccExpYear,
  677. $billingZipCode,
  678. $ccType
  679. );
  681. $response['ccId'] = $cc->getId();
  682. $response['paymentProfileId'] = $paymentProfileId;
  683. return $response;
  684. }
  686. public function getTransactionDetails($transactionId)
  687. {
  688. $merchantAuthentication = $this->getAuthentication();
  689. $request = new AnetAPI\GetTransactionDetailsRequest();
  690. $request->setMerchantAuthentication($merchantAuthentication);
  691. $request->setTransId($transactionId);
  693. $controller = new AnetController\GetTransactionDetailsController($request);
  695. $response = $controller->executeWithApiResponse($this->authorizeNetPlatform);
  697. return $response;
  698. }
  700. public function singlePaymentFromAcceptNonce($acceptPaymentDescriptor,$acceptPaymentValue,$amount,Users $user,$description,$schoolName){
  701. $op = new AnetAPI\OpaqueDataType();
  702. $op->setDataDescriptor($acceptPaymentDescriptor);
  703. $op->setDataValue($acceptPaymentValue);
  704. $paymentOne = new AnetAPI\PaymentType();
  705. $paymentOne->setOpaqueData($op);
  707. // Create order information
  708. $order = new AnetAPI\OrderType();
  709. $order->setDescription($description);
  712. // Set the customer's Bill To address
  713. $customerAddress = new AnetAPI\CustomerAddressType();
  714. // $customerAddress->setFirstName("Ellen");
  715. // $customerAddress->setLastName("Johnson");
  716. $customerAddress->setCompany($schoolName);
  718. // Set the customer's identifying information
  719. $customerData = new AnetAPI\CustomerDataType();
  720. $customerData->setEmail($user->getEmail());
  722. $transactionRequestType = new AnetAPI\TransactionRequestType();
  723. $transactionRequestType->setTransactionType("authCaptureTransaction");
  724. $transactionRequestType->setAmount($amount);
  725. $transactionRequestType->setOrder($order);
  726. $transactionRequestType->setPayment($paymentOne);
  727. $transactionRequestType->setBillTo($customerAddress);
  728. $transactionRequestType->setCustomer($customerData);
  732. $request = new AnetAPI\CreateTransactionRequest();
  733. $merchantAuthentication = $this->getAuthentication();
  734. $refId = 'ref' . time();
  735. $request->setMerchantAuthentication($merchantAuthentication);
  736. $request->setRefId($refId);
  737. $request->setTransactionRequest($transactionRequestType);
  739. $controller = new AnetController\CreateTransactionController($request);
  740. $response = $controller->executeWithApiResponse($this->authorizeNetPlatform);
  741. if ($response != null) {
  742. [$transId,$tresponse]=$this->processResponse($response,null,$amount,$description,'singlePaymentFromAcceptNonce',$user->getId());
  743. } else {
  744. $this->logger->error('ERROR: No Response');
  745. throw new Exception('No Response');
  746. }
  748. return ['transaction_id' => $transId,'authResultCode' => $response->getMessages()->getResultCode(), 'authNetResponse' => $tresponse->getAuthCode()];
  750. }
  751. }