Symfony Profiler

<?php
namespace EADPlataforma\Controller\Admin;
use Sensio\Bundle\FrameworkExtraBundle\Configuration\Cache;
use Symfony\Component\HttpFoundation\Request;
use Symfony\Component\Routing\Annotation\Route;
use EADPlataforma\Entity\Transaction;
use EADPlataforma\Entity\TransactionItem;
use EADPlataforma\Entity\User;
use EADPlataforma\Entity\Enrollment;
use EADPlataforma\Entity\TransactionRefund;
use EADPlataforma\Entity\TransactionXReceiver;
use EADPlataforma\Entity\TransactionRefundReceiver;
use EADPlataforma\Entity\TransactionContest;
use EADPlataforma\Entity\Commission;
use EADPlataforma\Entity\UserSubscription;
use EADPlataforma\Entity\Course;
use EADPlataforma\Entity\Product;
use EADPlataforma\DataTransferObject\PagarMeBankAccountDTO;
use EADPlataforma\Enum\TransactionEnum;
use EADPlataforma\Enum\TransactionItemEnum;
use EADPlataforma\Enum\TransactionContestEnum;
use EADPlataforma\Enum\TransactionXReceiverEnum;
use EADPlataforma\Enum\UserSubscriptionEnum;
use EADPlataforma\Enum\EnrollmentEnum;
use EADPlataforma\Enum\CourseEnum;
use EADPlataforma\Enum\ProductEnum;
use EADPlataforma\Enum\TagsMarketingEnum;
use EADPlataforma\Enum\NotificationEnum;
use EADPlataforma\Enum\ErrorEnum;
/**
* @Route(
* path = "/admin/transaction",
* schemes = {"http|https"}
* )
* @Cache(
* maxage = "0",
* smaxage = "0",
* expires = "now",
* public = false
* )
*/
class TransactionController extends AbstractController {
public function getEntityClass(){
return Transaction::class;
}
/**
* @Route(
* path = "/list/paginate",
* methods = {"GET"},
* )
*/
public function getTransactionPaginate(Request $request) {
$permission = $this->userPermissionUtil->getPermission(
"financial",
"transaction",
"see"
);
$this->requestUtil->setRequest($request)->setData();
$receiverId = $request->get('receiver');
$userId = $this->requestUtil->getField('user');
if(empty($receiverId) && (empty($userId) || $userId = $this->user->getId())){
if($this->userPermissionUtil->isLow($permission)){
return $this->eadResponse(null, ErrorEnum::PERMISSION);
}
}
$enrollmentId = $this->requestUtil->getField('enrollment');
$userSubscriptionId = $this->requestUtil->getField('userSubscription');
$searchText = $this->requestUtil->getField('searchText');
$orderParam = $this->requestUtil->getField('order');
$gateway = (int)$this->requestUtil->getField('gateway');
$paymentMethod = (int)$this->requestUtil->getField('paymentMethod');
$dateStart = $this->requestUtil->getField('dateStart');
$dateEnd = $this->requestUtil->getField('dateEnd');
$origin = (int)$this->requestUtil->getField('origin');
$status = $this->requestUtil->getField('status');
$limit = $this->requestUtil->getField('limit');
$offset = $this->requestUtil->getField('offset');
$columns = [
"t.id",
"t.hash",
"t.status",
"u.name",
"u.email",
"t.gateway",
"t.amount",
"t.paymentMethod",
"t.origin",
"t.numberItems",
"DATE_FORMAT(t.dateRegister, '%Y-%m-%d %H:%i:%s') AS dateRegister",
"DATE_FORMAT(t.dateDelete, '%Y-%m-%d %H:%i:%s') AS dateDelete",
"ud.name AS userDelete"
];
$userClass = User::class;
$joins = [
"{$userClass} AS u" => "u.id = t.user",
"{$userClass} AS ud" => ["LEFT", "ud.id = t.userDelete"]
];
if($enrollmentId > 0){
$enrollmentClass = Enrollment::class;
$joins["{$enrollmentClass} AS e"] = "e MEMBER OF t.enrollment AND e.id = {$enrollmentId}";
}
if($userSubscriptionId > 0){
$userSubscriptionClass = UserSubscription::class;
$joins["{$userSubscriptionClass} AS us"] = "us MEMBER OF t.userSubscription
AND us.id = {$userSubscriptionId}";
}
if($receiverId > 0){
$trXReceiverClass = TransactionXReceiver::class;
$joins["{$trXReceiverClass} AS tr"] = "tr.transaction = t.id
AND tr.receiver = {$receiverId}";
}
$filter = [];
$filterDelete = $this->requestUtil->getDeletedParam();
$filter["whereText"] = "t.id > 0";
if($userId > 0){
$filter["t.user"] = $userId;
}
if(!empty($gateway)){
$filter["t.gateway"] = $gateway;
}
if(!empty($paymentMethod)){
$filter["t.paymentMethod"] = $paymentMethod;
}
if(!empty($origin)){
$filter["t.origin"] = $origin;
}
if(!empty($status)){
if($status == TransactionEnum::APPROVED){
$sComplete = TransactionEnum::COMPLETE;
$filter["whereText"] .= " AND (t.status = {$status} OR t.status = {$sComplete})";
}else if($status == TransactionEnum::REPAYMENT){
$sReProgress = TransactionEnum::REPAYMENT_IN_PROGRESS;
$sRePartial = TransactionEnum::REPAYMENT_PARTIAL;
$filter["whereText"] .= "AND (
t.status = {$status} OR
t.status = {$sReProgress} OR
t.status = {$sRePartial}
)";
}else{
$filter["t.status"] = $status;
}
}
if(!empty($dateStart) && !empty($dateEnd)){
$filter["whereText"] .= " AND (DATE_FORMAT(t.dateRegister, '%Y-%m-%d') BETWEEN '{$dateStart}' AND '{$dateEnd}') ";
}
$group = [ "t.hash" ];
$order = [ "t.id" => "DESC" ];
if(!empty($orderParam)){
$order = json_decode($orderParam, true);
}
try{
//$this->repository->updateTransactionPaidAndAnticipated();
}catch(\Exception $e){
}
$data = $this->repository->paginate(
"t",
$searchText,
$columns,
$joins,
$filter,
$order,
$limit,
$offset,
$filterDelete,
false,
[],
true,
$group
);
return $this->eadResponse($data);
}
/**
* @Route(
* path = "/user/list/paginate",
* methods = {"GET"},
* )
*/
public function getTransactionUserPaginate(Request $request) {
$this->requestUtil->setRequest($request)->setData();
$userId = $this->user->getId();
$userSubscriptionId = $this->requestUtil->getField('userSubscription');
$searchText = $this->requestUtil->getField('searchText');
$orderParam = $this->requestUtil->getField('order');
$status = $this->requestUtil->getField('status');
$limit = $this->requestUtil->getField('limit');
$offset = $this->requestUtil->getField('offset');
$dateStart = $this->requestUtil->getField('dateStart');
$dateEnd = $this->requestUtil->getField('dateEnd');
$columns = [
"t.id",
"t.hash",
"t.status",
"u.name",
"u.email",
"t.gateway",
"t.amount",
"t.paymentMethod",
"t.numberItems",
"DATE_FORMAT(t.dateRegister, '%Y-%m-%d %H:%i:%s') AS dateRegister",
"DATE_FORMAT(t.dateDelete, '%Y-%m-%d %H:%i:%s') AS dateDelete",
"ud.name AS userDelete"
];
$userClass = User::class;
$joins = [
"{$userClass} AS u" => "u.id = t.user",
"{$userClass} AS ud" => ["LEFT", "ud.id = t.userDelete"]
];
if($userSubscriptionId > 0){
$userSubscriptionClass = UserSubscription::class;
$joins["{$userSubscriptionClass} AS us"] = "us MEMBER OF t.userSubscription AND us.id = {$userSubscriptionId}";
}
$filter = [];
$filterDelete = $this->requestUtil->getDeletedParam();
$filter = [
"t.user" => $userId
];
if(!empty($status)){
$filter["t.status"] = $status;
}
if(!empty($dateStart) && !empty($dateEnd)){
$filter["whereText"] = "DATE_FORMAT(t.dateRegister, '%Y-%m-%d') BETWEEN '{$dateStart}' AND '{$dateEnd}'";
}
$group = [ "t.hash" ];
$order = [ "t.id" => "DESC" ];
if(!empty($orderParam)){
$order = json_decode($orderParam, true);
}
$data = $this->repository->paginate(
"t",
$searchText,
$columns,
$joins,
$filter,
$order,
$limit,
$offset,
$filterDelete,
false,
[],
true,
$group
);
foreach ($data['rows'] as $key => $item) {
$item = (object)$item;
$item->paymentMethodText = $this->repository->stringPaymentMethod(
$item->paymentMethod
);
$item->statusText = $this->repository->stringStatus($item->status);
$data['rows'][$key] = $item;
}
return $this->eadResponse($data);
}
/**
* @Route(
* path = "/detail/{id}",
* methods = {"GET"},
* requirements = { "id" = "\d+" }
* )
*/
public function getTransaction(Request $request) {
$permission = $this->userPermissionUtil->getPermission(
"financial",
"transaction",
"see"
);
if($this->userPermissionUtil->isLow($permission)){
return $this->eadResponse(null, ErrorEnum::PERMISSION);
}
$transactionId = $request->get('id');
$transaction = $this->repository->findOneBy([
"id" => $transactionId,
"deleted" => TransactionEnum::ITEM_NO_DELETED
]);
if (!$transaction) {
return $this->eadResponse(null, ErrorEnum::NOT_FOUND);
}
$userCheckoutInfo = $transaction->getUserCheckoutInfo();
$msgError = null;
if($transaction->getGateway() == TransactionEnum::EAD_CHECKOUT){
$pagarMeTransaction = $this->generalService->getService(
'PagarMe\\PagarMeTransaction'
);
try{
$transactionPagarme = $pagarMeTransaction->get($transaction->getHash());
if($transaction->getPaymentMethod() == TransactionEnum::PAYMENT_BILL){
$dateExpire = date('Y-m-d', strtotime("+ 7 day"));
if(!empty($transactionPagarme->boleto_expiration_date)){
$dateExpire = date(
'Y-m-d',
strtotime($transactionPagarme->boleto_expiration_date)
);
}
$transaction->setBillCode($transactionPagarme->boleto_barcode);
$transaction->setBillLink($transactionPagarme->boleto_url);
$transaction->setDateExpire($dateExpire);
}else if($transaction->getPaymentMethod() == TransactionEnum::PAYMENT_PIX){
$dateExpire = date('Y-m-d', strtotime("+ 7 day"));
if(!empty($transactionPagarme->pix_qr_code)){
$dateExpire = date(
'Y-m-d',
strtotime($transactionPagarme->pix_expiration_date)
);
}
$transaction->setPixCode($transactionPagarme->pix_qr_code);
$transaction->setDateExpire($dateExpire);
}
if($transactionPagarme->status == "authorized"){
$dateRef = date('Y-m-d', strtotime("- 11 day"));
if($dateRef >= $transaction->getDateRegister('Y-m-d')){
$transaction->setStatus(TransactionEnum::CANCELED);
$transaction->setCancelReason(
TransactionEnum::CANCELED_BY_EXPIRATION_MANUAL
);
}
}
if(!empty($transactionPagarme->acquirer_response_code)){
$msgError = $pagarMeTransaction->getTransactionError(
$transactionPagarme->acquirer_response_code
);
}
$this->em->flush();
}catch(Exception $e){
}
}
$transactionItems = $this->em->getRepository(TransactionItem::class)->findBy([
"transaction" => $transaction->getId(),
"deleted" => TransactionItemEnum::ITEM_NO_DELETED
]);
$commissionAmountTotal = 0;
$commissionItems = [];
foreach ($transactionItems as $key => $transactionItem) {
$commissionAmount = $transactionItem->getCommissionTotalAmount();
$commissionPercent = $transactionItem->getCommissionPercent();
if(!empty($commissionAmount) && !empty($commissionPercent)){
$commissionAmountTotal = $commissionAmountTotal + $commissionAmount;
$obj = (object)[
"description" => $transactionItem->getDescription(),
"commissionPercent" => $commissionPercent,
"commissionAmount" => $commissionAmount,
];
$commissionItems[$key] = $obj;
}
}
$transaction = $this->repository->updatePaidAndAnticipated($transaction);
$dataTransaction = (object)$transaction->toReturn();
$netAmount = $transaction->getNetTotalAmount();
$antAmount = $transaction->getAnticipationAmount();
$dataTransaction->finalAmount = $netAmount - $antAmount - $commissionAmountTotal;
$data = [
"transaction" => $dataTransaction,
"commissionItems" => $commissionItems,
"canceledMessage" => $msgError,
"userCheckoutInfo" => (
$userCheckoutInfo ? $userCheckoutInfo->toReturn() : null
),
];
return $this->eadResponse($data);
}
/**
* @Route(
* path = "/detail/hash/{hash}",
* methods = {"GET"}
* )
*/
public function getTransactionHash(Request $request) {
$permission = $this->userPermissionUtil->getPermission(
"financial",
"transaction",
"see"
);
if($this->userPermissionUtil->isLow($permission)){
return $this->eadResponse(null, ErrorEnum::PERMISSION);
}
$hash = $request->get('hash');
$transaction = $this->repository->findOneBy([
"hash" => $hash,
"deleted" => TransactionEnum::ITEM_NO_DELETED
]);
if (!$transaction) {
return $this->eadResponse(null, ErrorEnum::NOT_FOUND);
}
$userCheckoutInfo = $transaction->getUserCheckoutInfo();
$msgError = null;
if($transaction->getGateway() == TransactionEnum::EAD_CHECKOUT){
$pagarMeTransaction = $this->generalService->getService(
'PagarMe\\PagarMeTransaction'
);
try{
$transactionPagarme = $pagarMeTransaction->get($transaction->getHash());
if($transaction->getPaymentMethod() == TransactionEnum::PAYMENT_BILL){
$dateExpire = date('Y-m-d', strtotime("+ 7 day"));
if(!empty($transactionPagarme->boleto_expiration_date)){
$dateExpire = date(
'Y-m-d',
strtotime($transactionPagarme->boleto_expiration_date)
);
}
$transaction->setBillCode($transactionPagarme->boleto_barcode);
$transaction->setBillLink($transactionPagarme->boleto_url);
$transaction->setDateExpire($dateExpire);
}else if($transaction->getPaymentMethod() == TransactionEnum::PAYMENT_PIX){
$dateExpire = date('Y-m-d', strtotime("+ 7 day"));
if(!empty($transactionPagarme->pix_qr_code)){
$dateExpire = date(
'Y-m-d',
strtotime($transactionPagarme->pix_expiration_date)
);
}
$transaction->setPixCode($transactionPagarme->pix_qr_code);
$transaction->setDateExpire($dateExpire);
}
if($transactionPagarme->status == "authorized"){
$dateRef = date('Y-m-d', strtotime("- 11 day"));
if($dateRef >= $transaction->getDateRegister('Y-m-d')){
$transaction->setStatus(TransactionEnum::CANCELED);
$transaction->setCancelReason(
TransactionEnum::CANCELED_BY_EXPIRATION_MANUAL
);
}
}
if(!empty($transactionPagarme->acquirer_response_code)){
$msgError = $pagarMeTransaction->getTransactionError(
$transactionPagarme->acquirer_response_code
);
}
$this->em->flush();
}catch(Exception $e){
}
}
$transactionItems = $this->em->getRepository(TransactionItem::class)->findBy([
"transaction" => $transaction->getId(),
"deleted" => TransactionItemEnum::ITEM_NO_DELETED
]);
$commissionAmountTotal = 0;
$commissionItems = [];
foreach ($transactionItems as $key => $transactionItem) {
$commissionAmount = $transactionItem->getCommissionTotalAmount();
$commissionPercent = $transactionItem->getCommissionPercent();
if(!empty($commissionAmount) && !empty($commissionPercent)){
$commissionAmountTotal = $commissionAmountTotal + $commissionAmount;
$obj = (object)[
"description" => $transactionItem->getDescription(),
"commissionPercent" => $commissionPercent,
"commissionAmount" => $commissionAmount,
];
$commissionItems[$key] = $obj;
}
}
$transaction = $this->repository->updatePaidAndAnticipated($transaction);
$dataTransaction = (object)$transaction->toReturn();
$netAmount = $transaction->getNetTotalAmount();
$antAmount = $transaction->getAnticipationAmount();
$dataTransaction->finalAmount = $netAmount - $antAmount - $commissionAmountTotal;
$data = [
"transaction" => $dataTransaction,
"commissionItems" => $commissionItems,
"canceledMessage" => $msgError,
"userCheckoutInfo" => (
$userCheckoutInfo ? $userCheckoutInfo->toReturn() : null
),
];
return $this->eadResponse($data);
}
/**
* @Route(
* path = "/process/{id}",
* methods = {"GET"},
* requirements = { "id" = "\d+" }
* )
*/
public function processTransaction(Request $request) {
$permission = $this->userPermissionUtil->getPermission(
"financial",
"transaction",
"see"
);
if($this->userPermissionUtil->isLow($permission)){
return $this->eadResponse(null, ErrorEnum::PERMISSION);
}
$transactionId = $request->get('id');
$transaction = $this->repository->findOneBy([
"id" => $transactionId,
"deleted" => TransactionEnum::ITEM_NO_DELETED
]);
if (!$transaction) {
return $this->eadResponse(null, ErrorEnum::NOT_FOUND);
}
$debug = ($this->user->getId() == TransactionEnum::YES);
$this->repository->processTransaction($transaction, $debug);
return $this->eadResponse([ "success" => 1, "debug" => $debug ]);
}
/**
* @Route(
* path = "/process/invoice/{id}",
* methods = {"GET"},
* requirements = { "id" = "\d+" }
* )
*/
public function processTransactionInvoice(Request $request) {
$permission = $this->userPermissionUtil->getPermission(
"financial",
"transaction",
"see"
);
if($this->userPermissionUtil->isLow($permission)){
return $this->eadResponse(null, ErrorEnum::PERMISSION);
}
$transactionId = $request->get('id');
$transaction = $this->repository->findOneBy([
"id" => $transactionId,
"deleted" => TransactionEnum::ITEM_NO_DELETED
]);
if (!$transaction) {
return $this->eadResponse(null, ErrorEnum::NOT_FOUND);
}
$debug = ($this->user->getId() == TransactionEnum::YES);
$result = $this->repository->processInvoiceTransaction($transaction, $debug);
if(!$result){
return $this->eadResponse([ "debug" => $debug ], ErrorEnum::ACTION_INVALID);
}
$this->em->flush();
return $this->eadResponse([ "success" => 1, "debug" => $debug ]);
}
/**
* @Route(
* path = "/register",
* methods = {"POST"},
* )
*/
public function registerTransaction(Request $request) {
$permission = $this->userPermissionUtil->getPermission(
"financial",
"transaction",
"create"
);
if($this->userPermissionUtil->isLow($permission)){
return $this->eadResponse(null, ErrorEnum::PERMISSION);
}
$this->requestUtil->setRequest($request)->setData();
$transaction = new Transaction();
if($this->requestUtil->issetField('paymentMethod')){
$transaction->setPaymentMethod(
(int)$this->requestUtil->getField('paymentMethod')
);
}
if($this->requestUtil->issetField('amount')){
$transaction->setAmount($this->requestUtil->getField('amount'));
}
if($this->requestUtil->issetField('hashReference')){
$transaction->setHashReference($this->requestUtil->getField('hashReference'));
}
if($this->requestUtil->issetField('hash')){
$transaction->setHash($this->requestUtil->getField('hash'));
}
if($this->requestUtil->issetField('status')){
$transaction->setStatus((int)$this->requestUtil->getField('status'));
}
$transaction->setGateway(TransactionEnum::MANUAL);
$transaction->setOrigin(TransactionEnum::ORIGIN_MANUAL);
if($this->requestUtil->issetField('user')){
$userId = (int)$this->requestUtil->getField('user');
if($userId > 0){
$user = $this->em->getRepository(User::class)->findOneBy([
"id" => $userId,
"deleted" => TransactionEnum::ITEM_NO_DELETED
]);
if($user){
$transaction->setUser($user);
}
}
}
$errors = $this->validateEntity($transaction);
if($errors){
return $this->eadResponse($errors, ErrorEnum::FIELD_EMPTY);
}
$products = json_decode($this->requestUtil->getField('products'));
if(empty($products) || count($products) == 0){
return $this->eadResponse([ "products" ], ErrorEnum::FIELD_EMPTY);
}
$enrollUser = TransactionEnum::NO;
if($this->requestUtil->issetField('enroll')){
$enrollUser = (int)$this->requestUtil->getField('enroll');
}
$this->em->persist($transaction);
$this->repository->processTransactionRegister(
$transaction,
$products,
$enrollUser
);
$this->em->flush();
$data = $transaction->toReturn();
$this->userLogService->logInsert("transaction", $transaction->getId(), $data);
return $this->eadResponse($data);
}
/**
* @Route(
* path = "/edit/{id}",
* methods = {"PUT"},
* requirements = { "id" = "\d+" }
* )
*/
public function editTransaction(Request $request) {
$permission = $this->userPermissionUtil->getPermission(
"financial",
"transaction",
"edit"
);
if($this->userPermissionUtil->isLow($permission)){
return $this->eadResponse(null, ErrorEnum::PERMISSION);
}
$transactionId = $request->get('id');
$transaction = $this->repository->findOneBy([
"id" => $transactionId,
"deleted" => TransactionEnum::ITEM_NO_DELETED
]);
if (!$transaction) {
return $this->eadResponse(null, ErrorEnum::NOT_FOUND);
}
if($transaction->getGateway() == TransactionEnum::EAD_CHECKOUT){
return $this->eadResponse(null, ErrorEnum::ACTION_INVALID);
}
$this->requestUtil->setRequest($request)->setData();
if($this->requestUtil->issetField('hashReference')){
$transaction->setHashReference($this->requestUtil->getField('hashReference'));
}
if($this->requestUtil->issetField('hash')){
$transaction->setHash($this->requestUtil->getField('hash'));
}
if($this->requestUtil->issetField('paymentMethod')){
$transaction->setPaymentMethod(
(int)$this->requestUtil->getField('paymentMethod')
);
}
if($this->requestUtil->issetField('status')){
$transaction->setStatus((int)$this->requestUtil->getField('status'));
}
if($this->requestUtil->issetField('gateway')){
$transaction->setGateway((int)$this->requestUtil->getField('gateway'));
}
if($this->requestUtil->issetField('currencyCode')){
$transaction->setCurrencyCode($this->requestUtil->getField('currencyCode'));
}
if($this->requestUtil->issetField('currencySymbol')){
$transaction->setCurrencySymbol(
$this->requestUtil->getField('currencySymbol')
);
}
if($this->requestUtil->issetField('amount')){
$transaction->setAmount($this->requestUtil->getField('amount'));
}
if($this->requestUtil->issetField('interestAmount')){
$transaction->setInterestAmount(
$this->requestUtil->getField('interestAmount')
);
}
if($this->requestUtil->issetField('totalAmount')){
$transaction->setTotalAmount($this->requestUtil->getField('totalAmount'));
}
if($this->requestUtil->issetField('rate')){
$transaction->setRate($this->requestUtil->getField('rate'));
}
if($this->requestUtil->issetField('fee')){
$transaction->setFee($this->requestUtil->getField('fee'));
$transaction->setFeeGateway($this->requestUtil->getField('fee'));
}
if($this->requestUtil->issetField('feeAmount')){
$transaction->setFeeAmount($this->requestUtil->getField('feeAmount'));
}
if($this->requestUtil->issetField('feeInterest')){
$transaction->setFeeInterest($this->requestUtil->getField('feeInterest'));
}
if($this->requestUtil->issetField('feeTotalAmount')){
$transaction->setFeeTotalAmount(
$this->requestUtil->getField('feeTotalAmount')
);
}
if($this->requestUtil->issetField('netAmount')){
$transaction->setNetAmount($this->requestUtil->getField('netAmount'));
}
if($this->requestUtil->issetField('netInterestAmount')){
$transaction->setNetInterestAmount($this->requestUtil->getField('netInterestAmount'));
}
if($this->requestUtil->issetField('netTotalAmount')){
$transaction->setNetTotalAmount($this->requestUtil->getField('netTotalAmount'));
}
if($this->requestUtil->issetField('feeAnticipation')){
$transaction->setFeeAnticipation(
$this->requestUtil->getField('feeAnticipation')
);
}
if($this->requestUtil->issetField('anticipationAmount')){
$transaction->setAnticipationAmount($this->requestUtil->getField('anticipationAmount'));
}
if($this->requestUtil->issetField('installments')){
$transaction->setInstallments($this->requestUtil->getField('installments'));
}
if($this->requestUtil->issetField('numberItems')){
$transaction->setNumberItems($this->requestUtil->getField('numberItems'));
}
if($this->requestUtil->issetField('paid')){
$transaction->setPaid($this->requestUtil->getField('paid'));
}
if($this->requestUtil->issetField('anticipated')){
$transaction->setAnticipated((int)$this->requestUtil->getField('anticipated'));
}
if($this->requestUtil->issetField('eadpaymentAmount')){
$transaction->setEadpaymentAmount($this->requestUtil->getField('eadpaymentAmount'));
}
if($this->requestUtil->issetField('dateUpdateGateway')){
$transaction->setDateUpdateGateway($this->requestUtil->getField('dateUpdateGateway'));
}
if($this->requestUtil->issetField('dateApprove')){
$transaction->setDateApprove($this->requestUtil->getField('dateApprove'));
}
if($this->requestUtil->issetField('billLink')){
$transaction->setBillLink($this->requestUtil->getField('billLink'));
}
if($this->requestUtil->issetField('billCode')){
$transaction->setBillCode($this->requestUtil->getField('billCode'));
}
if($this->requestUtil->issetField('pixCode')){
$transaction->setPixCode($this->requestUtil->getField('pixCode'));
}
if($this->requestUtil->issetField('dateExpire')){
$transaction->setDateExpire($this->requestUtil->getField('dateExpire'));
}
if($this->requestUtil->issetField('user')){
$userId = (int)$this->requestUtil->getField('user');
if($userId > 0){
$user = $this->em->getRepository(User::class)->findOneBy([
"id" => $userId,
"deleted" => TransactionEnum::ITEM_NO_DELETED
]);
if($user){
$transaction->setUser($user);
}
}
}
if($this->requestUtil->issetField('userCheckoutInfo')){
$userCheckoutInfoId = (int)$this->requestUtil->getField('userCheckoutInfo');
if($userCheckoutInfoId > 0){
$userCheckoutInfo = $this->em->getRepository(User::class)->findOneBy([
"id" => $userCheckoutInfoId,
"deleted" => TransactionEnum::ITEM_NO_DELETED
]);
if($userCheckoutInfo){
$transaction->setUserCheckoutInfo($userCheckoutInfo);
}
}
}
$errors = $this->validateEntity($transaction);
if($errors){
return $this->eadResponse($errors, ErrorEnum::FIELD_EMPTY);
}
$this->em->flush();
$data = $transaction->toReturn();
$this->userLogService->logUpdate("transaction", $transaction->getId(), $data);
return $this->eadResponse($data);
}
/**
* @Route(
* path = "/statement/{id}",
* methods = {"GET"},
* requirements = { "id" = "\d+" }
* )
*/
public function getTransactionBankStatement(Request $request) {
$permission = $this->userPermissionUtil->getPermission(
"financial",
"transaction",
"see"
);
if($this->userPermissionUtil->isLow($permission)){
return $this->eadResponse(null, ErrorEnum::PERMISSION);
}
$transactionId = $request->get('id');
$transaction = $this->repository->findOneBy([
"id" => $transactionId,
"deleted" => TransactionEnum::ITEM_NO_DELETED
]);
if (!$transaction) {
return $this->eadResponse(null, ErrorEnum::NOT_FOUND);
}
$trXReceiverRepository = $this->em->getRepository(TransactionXReceiver::class);
$transactionReceivers = $trXReceiverRepository->findBy([
"transaction" => $transactionId
]);
$bankStatements = [];
foreach ($transactionReceivers as $key => $transactionReceiver) {
$bankStatements[] = [
"receiverId" => $transactionReceiver->getReceiver()->getId(),
"receiverName" => $transactionReceiver->getReceiver()->getLegalName(),
"receiverType" => $transactionReceiver->getReceiver()->getType(),
"paymentMethod" => $transaction->getPaymentMethod(),
];
}
return $this->eadResponse($bankStatements);
}
/**
* @Route(
* path = "/statement/{id}/receiver/{receiverId}",
* methods = {"GET"},
* requirements = { "id" = "\d+", "receiverId" = "\d+" }
* )
*/
public function getTransactionBankStatementPayments(Request $request) {
$permission = $this->userPermissionUtil->getPermission(
"financial",
"transaction",
"see"
);
if($this->userPermissionUtil->isLow($permission)){
return $this->eadResponse(null, ErrorEnum::PERMISSION);
}
$transactionId = $request->get('id');
$receiverId = $request->get('receiverId');
$transaction = $this->repository->findOneBy([
"id" => $transactionId,
"deleted" => TransactionEnum::ITEM_NO_DELETED
]);
if (!$transaction) {
return $this->eadResponse(null, ErrorEnum::NOT_FOUND);
}
$pagarMeTransaction = $this->generalService->getService(
'PagarMe\\PagarMeTransaction'
);
$transactionService = $this->generalService->getService(
'Transaction\\TransactionService'
);
$trXReceiverRepository = $this->em->getRepository(TransactionXReceiver::class);
$transactionReceiver = $trXReceiverRepository->findOneBy([
"transaction" => $transactionId,
"receiver" => $receiverId,
]);
if (!$transactionReceiver) {
return $this->eadResponse(null, ErrorEnum::NOT_FOUND);
}
$payments = $transactionService->getStatementByTransactionReceiver(
$transaction,
$transactionReceiver->getReceiver()
);
return $this->eadResponse([ "payments" => $payments ]);
}
/**
* @Route(
* path = "/receivers/{id}",
* methods = {"GET"},
* requirements = { "id" = "\d+" }
* )
*/
public function getReceiversByTransaction(Request $request){
$permission = $this->userPermissionUtil->getPermission(
"financial",
"transaction",
"refund"
);
if($this->userPermissionUtil->isLow($permission)){
return $this->eadResponse(null, ErrorEnum::PERMISSION);
}
$transactionId = $request->get('id');
$transaction = $this->repository->findOneBy([
"id" => $transactionId,
"deleted" => TransactionEnum::ITEM_NO_DELETED
]);
if (!$transaction) {
return $this->eadResponse(null, ErrorEnum::NOT_FOUND);
}
if($transaction->getGateway() != TransactionEnum::EAD_CHECKOUT){
return $this->eadResponse([
"message" => "Action invalid"
], ErrorEnum::ACTION_INVALID);
}
$trXReceiverRepository = $this->em->getRepository(TransactionXReceiver::class);
$trXReceivers = $trXReceiverRepository->getReceiversByTransaction($transactionId);
$data = [];
foreach ($trXReceivers as $key => $trXReceiver) {
$data[] = $trXReceiver->toReturn();
}
return $this->eadResponse($data);
}
/**
* @Route(
* path = "/refund/{id}",
* methods = {"PUT"},
* requirements = { "id" = "\d+" }
* )
*/
public function refundTransaction(Request $request) {
$permission = $this->userPermissionUtil->getPermission(
"financial",
"transaction",
"refund"
);
if($this->userPermissionUtil->isLow($permission)){
return $this->eadResponse(null, ErrorEnum::PERMISSION);
}
$this->requestUtil->setRequest($request)->setData();
$transactionId = $request->get('id');
$transaction = $this->repository->findOneBy([
"id" => $transactionId,
"deleted" => TransactionEnum::ITEM_NO_DELETED
]);
if (!$transaction) {
return $this->eadResponse(null, ErrorEnum::NOT_FOUND);
}
if($transaction->getGateway() != TransactionEnum::EAD_CHECKOUT){
return $this->eadResponse([
"message" => "Action invalid"
], ErrorEnum::ACTION_INVALID);
}
if(!$transaction->getAllowRefund()){
return $this->eadResponse([
"message" => "Action invalid"
], ErrorEnum::ACTION_INVALID);
}
$pagarMeTransaction = $this->generalService->getService(
'PagarMe\\PagarMeTransaction'
);
$pagarMeBankAccount = $this->generalService->getService(
'PagarMe\\PagarMeBankAccount'
);
$numberUtil = $this->generalService->getUtil('NumberUtil');
$amount = $this->requestUtil->getField('amount');
$rSplits = (array)json_decode(
$this->requestUtil->getField('receiverSplits')
);
$cancelEnrollments = (int)$this->requestUtil->getField('cancelEnrollments');
$cancelUserSubscriptions = (int)$this->requestUtil->getField(
'cancelUserSubscriptions'
);
$amountCent = $numberUtil->numberToCents($amount);
$bankHash = null;
if($transaction->getPaymentMethod() == TransactionEnum::PAYMENT_BILL){
$bankAccountData = [
"bankCode" => $this->requestUtil->getField('bankCode'),
"agency" => $this->requestUtil->getField('agency'),
"agencyDv" => $this->requestUtil->getField('agencyDv'),
"account" => $this->requestUtil->getField('account'),
"accountDv" => (int)$this->requestUtil->getField('accountDv'),
"documentNumber" => $this->requestUtil->getField('documentNumber'),
"legalName" => $this->requestUtil->getField('legalName'),
"type" => $this->requestUtil->getField('bankAccountType')
];
$emptyDataBank = [];
foreach ($bankAccountData as $key => $value) {
if(empty($value) && $key != "agencyDv" && $key != "accountDv"){
$emptyDataBank[] = $key;
}
}
if(!empty($emptyDataBank)){
return $this->eadResponse($emptyDataBank, ErrorEnum::FIELD_EMPTY);
}
$bankAccountDTO = new PagarMeBankAccountDTO($bankAccountData);
$bankAccount = $pagarMeBankAccount->create($bankAccountDTO);
$bankHash = $bankAccount->id;
if(empty($bankHash)){
return $this->eadResponse([], ErrorEnum::ACTION_INVALID);
}
}
if($amount <= 0){
return $this->eadResponse([
"message" => "Amount invalid!"
], ErrorEnum::ACTION_INVALID);
}
if(empty($amount)){
return $this->eadResponse([
"message" => "Amount invalid!!"
], ErrorEnum::ACTION_INVALID);
}
if(empty($rSplits)){
return $this->eadResponse([
"message" => "Receivers not found!"
], ErrorEnum::FIELD_EMPTY);
}
if(count($rSplits) == 0){
return $this->eadResponse([
"message" => "Receivers not found!!"
], ErrorEnum::FIELD_EMPTY);
}
$transactionId = $transaction->getId();
$trXReceiverRepository = $this->em->getRepository(TransactionXReceiver::class);
$trXReceivers = $trXReceiverRepository->getReceiversByTransaction($transactionId);
$transactionPagarMe = $pagarMeTransaction->get($transaction->getHash());
$userSubscriptionRepository = $this->em->getRepository(UserSubscription::class);
if(count($trXReceivers) == 0){
return $this->eadResponse([
"message" => "Receivers not found!!!"
], ErrorEnum::FIELD_EMPTY);
}
$amountPaid = $transaction->getAmount();
$amountPaidCent = $numberUtil->numberToCents($amountPaid);
$transactionRefundRepository = $this->em->getRepository(TransactionRefund::class);
$amountRefund = $transactionRefundRepository->sumRefundValueByTransaction(
$transactionId
);
$amountRefundCent = $numberUtil->numberToCents($amountRefund);
$amountPaidCent = $amountPaidCent - $amountRefundCent;
if($transactionPagarMe->amount < ($amountCent + $amountRefundCent)){
return $this->eadResponse([
"message" => "Amount invalid!!!"
], ErrorEnum::ACTION_INVALID);
}
$refundAll = false;
if($amountPaidCent == $amountCent){
$refundAll = true;
}
if($amountCent == $transactionPagarMe->amount){
$refundAll = true;
}
$transactionService = $this->generalService->getService(
'Transaction\\TransactionService'
);
$checkoutAmountsEAD = $transactionService->getEADCheckoutAmountFixedFee(
$amount,
$transaction->getRate(),
$transaction->getFee(),
$transaction->getFeeGateway(),
false
);
$amountCentPartial = $checkoutAmountsEAD->amountTotalCents;
$amountEAD = $checkoutAmountsEAD->amountEADCents;
foreach ($trXReceivers as $key => $trXReceiver) {
$receiver = $trXReceiver->getReceiver();
$receiverId = $receiver->getId();
if(!empty($rSplits[$receiverId])){
if(!isset($rSplits[$receiverId]->percent)){
$rSplits[$receiverId]->percent = 0;
}
if(
$rSplits[$receiverId]->responsible == TransactionEnum::YES ||
$refundAll
){
$rSplits[$receiverId]->type = $trXReceiver->getType();
$rSplits[$receiverId]->receiver = $receiver;
$rSplits[$receiverId]->receiverId = $receiverId;
$rSplits[$receiverId]->receiverHash = $receiver->getReceiverHash();
$rSplits[$receiverId]->splitRuleHash = $trXReceiver->getSplitRuleHash();
$receiverAmount = $amountCentPartial * (
$rSplits[$receiverId]->percent / 100
);
$rSplits[$receiverId]->amount = round($receiverAmount);
if($rSplits[$receiverId]->type == TransactionXReceiverEnum::SCHOOL){
if(
$transaction->getPaymentMethod() == TransactionEnum::PAYMENT_BILL
){
$rSplits[$receiverId]->amount += 200;
$bankAccount = $pagarMeBankAccount->get($bankHash);
if($pagarMeBankAccount->isBradesco($bankAccount->bank_code)){
$rSplits[$receiverId]->amount += 280;
}
}
}
if(!empty($rSplits[$receiverId]->amount)){
$hasBalance = $pagarMeTransaction->receiverHasBalance(
$rSplits[$receiverId]->amount,
$transaction->getHash(),
$transactionId,
$rSplits[$receiverId]->receiverHash,
($rSplits[$receiverId]->type == TransactionXReceiverEnum::SCHOOL),
$refundAll,
$transaction->getPaymentMethod()
);
if(!$hasBalance){
$transactionReceiverAmount = $pagarMeTransaction->getReceiverAmount(
$transaction->getHash(),
$rSplits[$receiverId]->receiverHash
);
return $this->eadResponse([
"message" => "Receiver Amount invalid!",
"receiverId" => $receiverId,
"amountReceiver" => $rSplits[$receiverId]->amount,
"refundAll" => $refundAll,
"transactionReceiverAmount" => $transactionReceiverAmount,
"amountCentPartial" => $amountCentPartial,
"amountEAD" => $amountEAD,
"percent" => $rSplits[$receiverId]->percent,
], ErrorEnum::ACTION_INVALID);
}
}
if($rSplits[$receiverId]->type == TransactionXReceiverEnum::SCHOOL){
$paymentMethod = $transaction->getPaymentMethod();
if($paymentMethod == TransactionEnum::PAYMENT_BILL){
$rSplits[$receiverId]->amount -= 200;
$bankAccount = $pagarMeBankAccount->get($bankHash);
if($pagarMeBankAccount->isBradesco($bankAccount->bank_code)){
$rSplits[$receiverId]->amount -= 280;
}
}
}
}
}
}
$refundParameters = [ "id" => $transaction->getHash() ];
if(
$transaction->getPaymentMethod() == TransactionEnum::PAYMENT_BILL &&
!empty($bankHash)
){
$refundParameters["bank_account_id"] = $bankHash;
}
$transaction->setStatus(TransactionEnum::APPROVED);
if($refundAll){
$transaction->setStatus(TransactionEnum::REPAYMENT_IN_PROGRESS);
}else{
$refundParameters["amount"] = $amountCent;
$isSchool = false;
$splitRules = [];
$totalSplit = 0;
foreach ($rSplits as $key => $receiverSplit) {
if($receiverSplit->responsible == TransactionContestEnum::YES){
$chargeProcessingFee = false;
$liable = false;
if($receiverSplit->type == TransactionXReceiverEnum::SCHOOL){
$chargeProcessingFee = true;
$liable = true;
$isSchool = true;
}
$totalSplit = $totalSplit + $receiverSplit->amount;
$splitRules[] = (object)[
"id" => $receiverSplit->splitRuleHash,
"recipient_id" => $receiverSplit->receiverHash,
"charge_processing_fee" => $chargeProcessingFee,
"liable" => $liable,
"percentage" => null,
"amount" => $receiverSplit->amount,
"date_created" => date('Y-m-d H:i:s'),
"date_updated" => date('Y-m-d H:i:s')
];
}
}
if(!$isSchool){
$trXReceiverSchool = $trXReceiverRepository->getSchoolReceiverByTransaction(
$transactionId
);
$splitRules[] = (object)[
"id" => $trXReceiverSchool->getSplitRuleHash(),
"recipient_id" => $trXReceiverSchool->getReceiver()->getReceiverHash(),
"charge_processing_fee" => true,
"liable" => true,
"percentage" => null,
"amount" => 0,
"date_created" => date('Y-m-d H:i:s'),
"date_updated" => date('Y-m-d H:i:s')
];
}
$eadSplitId = $pagarMeTransaction->getEADSplitIdByTransaction(
$transactionPagarMe
);
$totalSplit = $totalSplit + $amountEAD;
if($totalSplit > $amountCent){
$diff = $totalSplit - $amountCent;
$amountEAD = $amountEAD - $diff;
}
$splitRules[] = (object)[
"id" => $eadSplitId,
"recipient_id" => $pagarMeTransaction->getReceiverIdEAD(),
"charge_processing_fee" => false,
"liable" => false,
"percentage" => null,
"amount" => $amountEAD,
"date_created" => date('Y-m-d H:i:s'),
"date_updated" => date('Y-m-d H:i:s')
];
$refundParameters['split_rules'] = $splitRules;
}
$transactionContests = $this->em->getRepository(TransactionContest::class)->findBy([
"transaction" => $transaction->getId(),
"status" => TransactionContestEnum::WAITING,
]);
foreach ($transactionContests as $key => $transactionContest) {
$transactionContest->setAmount($amount);
$transactionContest->setStatus(TransactionContestEnum::APPROVED);
$transactionContest->setNote("Finalizado por reembolso");
$transactionContest->setDateEnd(date('Y-m-d H:i:s'));
}
if($this->debug){
$discordService = $this->generalService->getService('DiscordService');
$discordService->setChannel('debug');
$discordService->setMessage(json_encode($refundParameters));
$discordService->sendDiscord();
}
$pagarMeTransaction->refund($refundParameters);
if($cancelEnrollments == TransactionEnum::YES){
$enrollments = $transaction->getEnrollment();
foreach ($enrollments as $key => $enrollment) {
$enrollment->setStatus(EnrollmentEnum::STATUS_CANCELED);
}
}
// send marketing
$marketingService = $this->generalService->getService(
'Marketing\\MarketingService'
);
if($cancelUserSubscriptions == TransactionEnum::YES){
$userSubscriptions = $transaction->getUserSubscription();
foreach ($userSubscriptions as $key => $userSubscription) {
$userSubscription->setStatus(UserSubscriptionEnum::STATUS_CANCELED);
$userSubscription->setCancelReason(UserSubscriptionEnum::CANCELED_BY_REFUND);
$userSubscription->setDateNextPayment(date('Y-m-d'));
$userSubscription->setDateCancel(date('Y-m-d'));
$userSubscription->setDateExpiration(null);
$marketingService->setTag(TagsMarketingEnum::TAG_CANCELED_SUBSCRIPTION);
$marketingService->setTextComplement(
$userSubscription->getProduct()->getTitle()
);
$marketingService->setUser($userSubscription->getUser());
$marketingService->send();
}
}
$transactionRefund = new TransactionRefund();
$transactionRefund->setAmount($amount);
$transactionRefund->setTransaction($transaction);
if($transaction->getPaymentMethod() == TransactionEnum::PAYMENT_BILL){
$transactionRefund->setBankHash($bankHash);
}
$this->em->persist($transactionRefund);
$commissionRepository = $this->em->getRepository(Commission::class);
foreach ($rSplits as $key => $receiverSplit) {
if(
$receiverSplit->responsible == TransactionEnum::YES &&
!empty($receiverSplit->receiver)
){
$transactionRefundReceiver = new TransactionRefundReceiver();
$transactionRefundReceiver->setAmount(
$numberUtil->centsToNumber($receiverSplit->amount)
);
$transactionRefundReceiver->setPercent($receiverSplit->percent);
$transactionRefundReceiver->setReceiver($receiverSplit->receiver);
$transactionRefundReceiver->setTransactionRefund($transactionRefund);
$errors = $this->validateEntity($transactionRefundReceiver);
if(!$errors){
$this->em->persist($transactionRefundReceiver);
}else{
return $this->eadResponse($transactionRefundReceiver, $errors);
}
$commissions = $commissionRepository->getByReceiverAndTransaction(
$transactionId,
$receiverSplit->receiverId
);
foreach ($commissions as $keyCommission => $commission) {
$commRefAmount = round(
($receiverSplit->amount / 100) / count($commissions), 2
);
$commRefAmount = $commission->getRefundAmount() + $commRefAmount;
$commission->setRefundAmount($commRefAmount);
}
}
}
$this->repository->processInvoiceTransaction($transaction);
$this->em->flush();
if(!$refundAll){
$emailService = $this->generalService->getService('EmailService');
$notificationService = $this->generalService->getService('NotificationService');
$this->requestUtil->setRequest($request)->setData();
//send email partial refund
$email = $this->requestUtil->getField('email');
$user = $transaction->getUser();
if(empty($email)){
$email = $user->getEmail();
}
$hash = $this->stringUtil->encodeHex($transactionId);
$domain = "https://{$this->client->getDomainPrimary()}";
if($emailService->checkUserToSend($user)){
$emailService->setToEmail($email);
$emailService->setToName($user->getName());
$subText = $this->configuration->getLanguage('new_message.subject', 'email');
$emailService->setSubject(
"{$subText} - {$transaction->getHash()} - {$this->client->getBrand()}"
);
$emailService->setData([
"userName" => $user->getName(),
"btnLink" => "{$domain}/transaction/refund/view/{$hash}",
]);
$emailService->setTemplateBody("repayment");
$emailService->send();
}
$notificationService->create(
$this->user,
$user,
NotificationEnum::ORIGIN_TRANSACTION_REPAYMENT_PARTIAL,
$transaction->getId()
);
}
$data = $transaction->toReturn();
$this->userLogService->logUpdate("transaction", $transaction->getId(), $data);
return $this->eadResponse([ "message" => "Success" ]);
}
/**
* @Route(
* path = "/send/email/{id}",
* methods = {"POST"},
* name = "sendTransactionEmail",
* requirements = { "id" = "\d+" }
* )
*/
public function sendTransactionEmail(Request $request) {
$permission = $this->userPermissionUtil->getPermission(
"financial",
"transaction",
"send"
);
$this->requestUtil->setRequest($request)->setData();
$client = $this->configuration->getClient();
$brand = $client->getBrand();
$domainPrimary = $client->getDomainPrimary();
$transactionId = $request->get('id');
$transaction = $this->repository->findOneBy([
"id" => $transactionId,
"deleted" => TransactionEnum::ITEM_NO_DELETED
]);
if (!$transaction) {
return $this->eadResponse(null, ErrorEnum::NOT_FOUND);
}
if($transaction->getUser()->getId() != $this->user->getId()){
if($this->userPermissionUtil->isLow($permission)){
return $this->eadResponse(null, ErrorEnum::PERMISSION);
}
}
if($transaction->getPaymentMethod() == TransactionEnum::PAYMENT_CARD){
return $this->eadResponse([
"message" => "Transaction is not able"
], ErrorEnum::ACTION_INVALID);
}
$email = $this->requestUtil->getField('email');
$user = $transaction->getUser();
if(empty($email)){
$email = $user->getEmail();
}
$emailService = $this->generalService->getService('EmailService');
if($emailService->checkUserToSend($user) || $email != $user->getEmail()){
$emailService->setToEmail($email);
$emailService->setToName($user->getName());
$transactionItems = $this->em->getRepository(TransactionItem::class)->findBy([
"transaction" => $transaction->getId(),
"deleted" => TransactionEnum::ITEM_NO_DELETED
]);
$isCharge = false;
foreach ($transactionItems as $key => $value) {
if($value->getType() == TransactionItemEnum::CHARGE){
$isCharge = true;
}
}
$domainPrimary = $this->client->getDomainPrimary();
$url = "https://{$domainPrimary}/transaction/{$transaction->getHash()}";
$emailService->setData([
"transaction" => $transaction,
"userName" => $user->getName(),
"statusString" => $this->repository->stringStatus(
$transaction->getStatus()
),
"paymentMethodString" => $this->repository->stringPaymentMethod(
$transaction->getPaymentMethod()
),
"itens" => $transactionItems,
"btnLink" => $url,
"isCharge" => $isCharge,
"isBuyer" => true,
]);
$emailService->setSubject(
$this->repository->getEmailSubjectPaymentStatus($transaction->getStatus())
);
$emailService->setTemplateBody("payment");
$emailService->send();
return $this->eadResponse([ "message" => "E-mail send" ]);
}
return $this->eadResponse([ "message" => "Erro to send E-mail" ], ErrorEnum::ACTION_INVALID);
}
}

src/Controller/Admin/TransactionController.php line 1057