@Override
public DoExpressCheckoutPaymentDTO doExpressCheckoutPayment(
GetExpressCheckoutDetailsDTO details, ProfilePayPalDTO profile, OrderFullDTO order)
throws PayPalFundingFailureException, PayPalException, PayPalFailureException,
StockNotPresentException, PayPalPostPaymentException {
// TODO Auto-generated method stub
// VERIFICO LA GIACENZA
orderService.checkQtaInStock(order.getIdOrder(), order);
// effettuo il doCheckOut, si paga...
DoExpressCheckoutPaymentDTO checkDTO =
getWrapper(profile)
.doExpressCheckoutPayment(
details, profilePayPal.getNotifyUrl(), profilePayPal.getRedirectUrl());
order.setIdTransaction(checkDTO.getPAYMENTINFO_0_TRANSACTIONID());
order.setIdStato(
TypeStateOrder.fromString(checkDTO.getPAYMENTINFO_0_PAYMENTSTATUS()).getState());
order.setPendingReason(checkDTO.getPAYMENTINFO_0_PENDINGREASON());
try {
// aggiorno l'ordine con lo stato, se completed o pending facciamo
// anche
// il decremento della qta
TypeStateOrder state = TypeStateOrder.fromString(checkDTO.getPAYMENTINFO_0_PAYMENTSTATUS());
log.info(
String.format(
"stato PayPal %s- stato Othala %s",
checkDTO.getPAYMENTINFO_0_PAYMENTSTATUS(), Integer.toString(state.getState())));
if (isPaymentCompleted(checkDTO.getPAYMENTINFO_0_PAYMENTSTATUS())
|| isPaymentPending(checkDTO.getPAYMENTINFO_0_PAYMENTSTATUS())) {
orderService.confirmOrderPayment(order);
} else {
orderService.updateStateOrder(order.getIdOrder(), order, state);
}
// salvo il messaggio
MessageIpnDTO ipn = new MessageIpnDTO();
ipn.setFgElaborato(false);
ipn.setIdOrder(order.getIdOrder());
ipn.setIdTransaction(order.getIdTransaction());
ipn.setTxMessage(checkDTO.getOkMessage());
if (state.getState() == TypeStateOrder.PENDING.getState()) {
ipn.setTxNote(checkDTO.getPAYMENTINFO_0_PENDINGREASON());
}
ipn.setTxStato(checkDTO.getPAYMENTINFO_0_PAYMENTSTATUS());
messageIpnDAO.insertMessageIpn(ipn);
} catch (Throwable e) {
log.error("errore PaymentService dopo il pagamento", e);
throw new PayPalPostPaymentException(
e, order.getIdOrder(), "errore nel docheckout dopo il pagamento");
}
return checkDTO;
}
@Override
public SetExpressCheckoutDTO setExpressCheckout(OrderFullDTO order, ProfilePayPalDTO profile)
throws PayPalException, PayPalFailureException, OthalaException {
// TODO Auto-generated method stub
// inserisco l'ordine
order = orderService.insertOrder(order);
// costruisco la busta per PayPal
OrderPayPalDTO ordPayPal = valueOf(profile, order);
SetExpressCheckoutDTO chechDTO = getWrapper(profile).setExpressCheckout(ordPayPal);
return chechDTO;
}
private RefundTransactionDTO updateStateRefund(
String paypalStatus,
String pendingReason,
String parentTransactionID,
RefoundFullDTO ref,
RefundTransactionDTO refTrans,
MailPropertiesDTO mailProps)
throws PayPalException, MailNotSendException {
if (ref == null) {
log.info("ref null updateStateRefund");
List<RefoundFullDTO> refs =
orderService.getRefounds(null, null, null, null, parentTransactionID, null);
if (refs != null && refs.isEmpty()) {
ref = refs.get(0);
} else {
// richiesta rimborso direttamente da paypal, non è presente in
// OrderRefund
log.info(
"richiesta rimborso direttamente da paypal, non è presente parentTransactionID in OrderRefund");
// inserire manualmente la richiesta in OrderRefound/annullare
// l'ordine.
return null;
}
}
if (refTrans == null) {
refTrans = new RefundTransactionDTO();
}
if (isPaymenRefunded(paypalStatus)) {
orderService.updateStateRefound(
ref.getIdRefound(), TypeStateOrder.REFOUND_COMPLETED, pendingReason);
try {
OthalaFactory.getOrderServiceInstance().sendMailConfirmReso(ref.getIdRefound(), mailProps);
} catch (Exception e) {
throw new MailNotSendException(e);
}
} else if (isPaymentPending(paypalStatus)) {
orderService.updateStateRefound(ref.getIdRefound(), TypeStateOrder.PENDING, pendingReason);
refTrans.setPending(true);
} else if (isPaymentKO(paypalStatus)) {
orderService.updateStateRefound(
ref.getIdRefound(), TypeStateOrder.REFOUND_REFUSED, pendingReason);
refTrans.setFailed(true);
} else if (isPaymenInstant(paypalStatus)) {
orderService.updateStateRefound(ref.getIdRefound(), TypeStateOrder.INSTANT, pendingReason);
refTrans.setInstant(true);
} else {
// throw new
// PayPalException(String.format("Stati %s non ammesso nella fase di rimborso",
// paypalStatus));
log.info(
String.format("nessuna operazione da fare per lo stato %s di rimborso", paypalStatus));
}
return refTrans;
}
private void updateStateRefundIPN(
OrderFullDTO order,
IpnDTO ipnDTO,
HashMap<String, String> responseMap,
MailPropertiesDTO mailProps)
throws PayPalException, MailNotSendException {
log.info("refund updateStateRefundIPN");
List<RefoundFullDTO> refs =
orderService.getRefounds(null, null, null, null, ipnDTO.getParent_txn_id(), null);
BigDecimal reqToRefund = new BigDecimal(ipnDTO.getMc_gross().replace("-", ""));
RefoundFullDTO ref = null;
HashMap<Integer, String> idArticle = new HashMap<>();
for (String key : responseMap.keySet()) {
log.info("key=" + key);
if (key.contains("item_number")) {
idArticle.put(Integer.parseInt(responseMap.get(key)), key);
log.info("add product " + responseMap.get(key));
}
}
if (refs != null && !refs.isEmpty()) {
log.info("individuato txtId in tabella order refound");
ref = refs.get(0);
updateStateRefund(
ipnDTO.getPayment_status(), null, ipnDTO.getParent_txn_id(), ref, null, mailProps);
} else {
// richiesta rimborso direttamente da paypal, non è presente in
// OrderRefund
log.info(
"richiesta rimborso direttamente da paypal, non è presente parentTransactionID in OrderRefund");
ref = new RefoundFullDTO();
List<ArticleRefounded> artToRefund = new ArrayList<ArticleRefounded>();
BigDecimal imRefunded = BigDecimal.ZERO;
for (ArticleFullDTO art : order.getCart()) {
if (idArticle.containsKey(art.getPrdFullDTO().getIdProduct().intValue())) {
log.info(
"inserito articolo in articoli da rimborsare "
+ art.getPrdFullDTO().getIdProduct().intValue());
ArticleRefounded artref = new ArticleRefounded(art);
artToRefund.add(artref);
}
}
if (artToRefund.isEmpty()) {
throw new PayPalException(
"nessun articolo trovato per la somma "
+ ipnDTO.getMc_gross()
+ " ed ordine "
+ order.getIdOrder());
}
ref.setCart(artToRefund);
ref.setIdOrder(order.getIdOrder());
ref.setIdUser(order.getIdUser());
ref.setImRefound(reqToRefund);
ref.setIdTransaction(ipnDTO.getParent_txn_id());
ref.setFgChangeRefound("R");
ref.setFgPartialRefound(order.getImOrdineSenzaSpese().compareTo(ref.getImRefound()) != 0);
ref.setIdStato(TypeStateOrder.REFUNDED.getState());
try {
ref = OthalaFactory.getOrderServiceInstance().insertRefound(ref, null);
} catch (Exception e) {
// TODO Auto-generated catch block
log.error("errore in inserimento richiesta di rimborso da PayPal", e);
throw new PayPalException(e);
}
log.info("inserimento richiesta di rimborso da PayPal eseguita correttamente");
}
}
@Override
public void processIpnMessage(
String originalRequest, ProfilePayPalDTO profile, MailPropertiesDTO mailProps)
throws PayPalException, PayPalIpnErrorException {
log.info("IPN Original Request:" + originalRequest);
String responseRequest = originalRequest + "&cmd=_notify-validate";
StringBuilder sb = new StringBuilder();
boolean errorFormalMessage = false;
OrderFullDTO order = null;
try {
// resend message to PayPal for securiry protocol
HashMap<String, String> responseMap = getWrapper(profile).getNotificationIPN(responseRequest);
IpnDTO ipnDTO = valueOf(responseMap);
log.info(String.format("prosessIpnMessage, ipnDTO: %s", ipnDTO.toString()));
// check that txn_id has not been previously processed
String txn_id = ipnDTO.getTxn_id();
Integer idOrder = Integer.valueOf(ipnDTO.getCustom());
TypeStateOrder state = TypeStateOrder.fromString(ipnDTO.getPayment_status());
if (!exitsIdTransaction(txn_id, ipnDTO.getPayment_status())) {
// check that receiver_email is your Primary PayPal email
String recEmailMerchant = profile.getReceiverEmail();
String receiver_email = ipnDTO.getReceiver_email();
if (!recEmailMerchant.trim().equalsIgnoreCase(receiver_email)) {
sb.append(
String.format(
"messagio non elaborato: emailMerchant %s diversa dalla mail %s presente nel messaggio %s",
recEmailMerchant, receiver_email, ipnDTO.toString()));
errorFormalMessage = true;
}
if (!ipnDTO.getMc_currency().trim().equalsIgnoreCase("EUR")) {
sb.append(
String.format(
"messagio non elaborato:divisa accettata %s diversa dalla divisa %s presente nel messaggio %s",
"EUR", ipnDTO.getMc_currency(), ipnDTO.toString()));
errorFormalMessage = true;
}
if (errorFormalMessage) {
log.error(
String.format(
"Messagio %s non elaborato, ci sono errori formali: %s",
ipnDTO.getTxn_id(), sb.toString()));
return;
}
// inserisco il messaggio
MessageIpnDTO ipnMessage = new MessageIpnDTO();
ipnMessage.setIdOrder(idOrder);
ipnMessage.setFgElaborato(!errorFormalMessage);
ipnMessage.setIdTransaction(txn_id);
ipnMessage.setTxMessage(ipnDTO.toString());
ipnMessage.setTxStato(ipnDTO.getPayment_status());
ipnMessage.setTxNote(sb.toString());
insertMessage(ipnMessage);
// verifica se richiesta di rimborso
if (ipnDTO.getParent_txn_id() != null
&& ipnDTO.getReason_code().equalsIgnoreCase("refund")) {
log.info("refund trovato txtId = " + ipnDTO.getParent_txn_id());
try {
if (idOrder != null) {
order = orderService.getOrders(idOrder, null, null, null).get(0);
}
updateStateRefundIPN(order, ipnDTO, responseMap, null);
} catch (MailNotSendException e) {
// TODO Auto-generated catch block
log.error("errore nell'invio della mail per il conferma rimborso", e);
}
return;
}
// è presente un ordine, recupero i dettagli
if (idOrder != null) {
order = orderService.getOrders(idOrder, null, null, null).get(0);
// check that payment_amount/payment_currency are correct
BigDecimal mc_grossBD = new BigDecimal(ipnDTO.getMc_gross());
if (order.getImOrdine().compareTo(mc_grossBD.abs()) != 0) {
sb.append(
String.format(
"messagio non elaborato: importo db %s diverso dalla importo %s presente nel messaggio %s",
order.getImOrdine(), ipnDTO.getMc_gross(), ipnDTO.toString()));
errorFormalMessage = true;
}
}
// message is correct, process message
if (isPaymentKO(ipnDTO.getPayment_status())) {
// inviare una mail in cui si comunica che PayPal non ha
// accettato il pagamento
if (idOrder != null) {
// siamo nel caso di express checkout
orderService.increaseQtaArticle(order, state);
try {
sendMailRefusedPayment(order, mailProps);
} catch (MailNotSendException e) {
// TODO Auto-generated catch block
log.error(
String.format("errore nell'invio della mail di rifuto", order.getIdOrder()), e);
}
}
} else if (isPaymentCompleted(ipnDTO.getPayment_status())) {
// inviare una mail in cui si comunica che PayPal ha
// accettato il pagamento
if (idOrder != null) {
int oldState = order.getIdStato();
log.info(String.format("Old state %d ", oldState));
orderService.updateStateOrder(idOrder, order, state);
try {
if (oldState != TypeStateOrder.COMPLETEDFUNDSHELD.getState()) {
// questo stato è gia considerato completed, non
// ha senso reinviare la mail;
sendMailAcceptedPyamentAfterPending(order, mailProps, state);
}
} catch (MailNotSendException e) {
// TODO Auto-generated catch block
log.error(
String.format(
"errore nell'invio della mail di accettazione pagamento", order.getIdOrder()),
e);
}
}
} else {
// nessuna elaborazione da fare
log.error(
String.format(
"stato del messaggio %s, per il transactionId %s, non ammesso. Nessuna elaborazione da fare, messaggio %s",
ipnDTO.getPayment_status(), ipnDTO.getTxn_id(), ipnDTO.toString()));
}
return;
} else {
// messaggio già elaborato
log.error(
String.format(
"transactionId %s del messaggio %s già elaborato ", txn_id, originalRequest));
return;
}
} catch (PayPalIpnInvalidException e) {
// TODO Auto-generated catch block
log.error("invalid nella ricezione IPN da paypal, messaggion non corretto", e);
} catch (PayPalIpnErrorException e) {
// TODO Auto-generated catch block
log.error("stringa non prevista nella ricezione IPN da paypal", e);
throw e;
} catch (PayPalException e) {
// TODO Auto-generated catch block
log.error("errore imprevisto sull'invio del messaggio IPN verso paypal", e);
throw e;
}
}