def process_order_confirmed(self, request, order):
PAGSEGURO = settings.PAGSEGURO
if not order.balance_remaining:
return self.already_paid(order)
logger.info("Processing order %s using PagSeguro" % order)
payment = self.create_pending_payment(order)
if plata.settings.PLATA_STOCK_TRACKING:
StockTransaction = plata.stock_model()
self.create_transactions(
order,
_("payment process reservation"),
type=StockTransaction.PAYMENT_PROCESS_RESERVATION,
negative=True,
payment=payment,
)
return self.shop.render(
request,
"payment/pagseguro_form.html",
{
"order": order,
"payment": payment,
"HTTP_HOST": request.META.get("HTTP_HOST"),
"post_url":
"https://pagseguro.uol.com.br/v2/checkout/payment.html",
"email": PAGSEGURO["EMAIL"],
},
)
def update_payment(self, payment_details, request):
order_id, payment_id = payment_details.trackingId.split("-")
order = plata.shop.models.Order.objects.select_related("payments").get(
pk=order_id
)
if order.status >= plata.shop.models.Order.PAID:
return order
payment = order.payments.get(pk=payment_id)
if payment_details.status not in ("CREATED", "PENDING", "PROCESSING"):
payment.status = plata.shop.models.OrderPayment.PROCESSED
payment.currency = payment_details.currencyCode
payment.amount = payment_details.amount
payment.data = payment_details.post_data
payment.transaction_id = payment_details.purchaseId
payment.payment_method = payment_details.type
payment.transaction_fee = payment_details.receiverFee
if payment_details.status == "COMPLETED":
payment.authorized = timezone.now()
payment.status = plata.shop.models.OrderPayment.AUTHORIZED
payment.save()
order = order.reload()
if payment.authorized and plata.settings.PLATA_STOCK_TRACKING:
StockTransaction = plata.stock_model()
self.create_transactions(
order,
_("sale"),
type=StockTransaction.SALE,
negative=True,
payment=payment,
)
if not order.balance_remaining:
self.order_paid(order, payment=payment, request=request)
return order
def order_payment_failure(self, request):
"""Handles order payment failures"""
order = self.order_from_request(request)
logger.warn('Order payment failure for %s' % order.order_id)
if plata.settings.PLATA_STOCK_TRACKING:
StockTransaction = plata.stock_model()
for transaction in order.stock_transactions.filter(
type=StockTransaction.PAYMENT_PROCESS_RESERVATION):
transaction.delete()
order.payments.pending().delete()
if order.payments.authorized().exists():
# There authorized order payments around!
messages.warning(request, _('Payment failed, please try again.'))
logger.warn('Order %s is already partially paid, but payment'
' failed anyway!' % order.order_id)
elif order.status > order.CHECKOUT and order.status < order.PAID:
order.update_status(
order.CHECKOUT,
'Order payment failure, going back to checkout')
messages.info(
request,
_('Payment failed; you can continue editing your order and'
' try again.'))
return self.render(
request, self.failure_template,
self.get_context(request, {
'order': order,
'progress': 'failure',
}))
def process_order_confirmed(self, request, order):
PAYPAL = settings.PAYPAL
if not order.balance_remaining:
return self.already_paid(order)
logger.info('Processing order %s using Paypal' % order)
payment = self.create_pending_payment(order)
if plata.settings.PLATA_STOCK_TRACKING:
StockTransaction = plata.stock_model()
self.create_transactions(
order, _('payment process reservation'),
type=StockTransaction.PAYMENT_PROCESS_RESERVATION,
negative=True, payment=payment)
if PAYPAL['LIVE']:
PP_URL = "https://www.paypal.com/cgi-bin/webscr"
else:
PP_URL = "https://www.sandbox.paypal.com/cgi-bin/webscr"
return self.shop.render(request, 'payment/%s_form.html' % self.key, {
'order': order,
'payment': payment,
'RETURN_SCHEME': PAYPAL.get(
'RETURN_SCHEME',
'https' if request.is_secure() else 'http'
),
'IPN_SCHEME': PAYPAL.get('IPN_SCHEME', 'http'),
'HTTP_HOST': request.META.get('HTTP_HOST'),
'post_url': PP_URL,
'business': PAYPAL['BUSINESS'],
})
def create_transactions(self, order, stage, **kwargs):
"""
Create transactions for all order items. The real work is offloaded
to ``StockTransaction.objects.bulk_create``.
"""
if not plata.settings.PLATA_STOCK_TRACKING:
warnings.warn(
'StockTransaction.objects.create_transactions'
' currently has no effect when PLATA_STOCK_TRACKING = False.'
' This will change in the future. Change your code to only'
' call create_transactions when'
' plata.settings.PLATA_STOCK_TRACKING = True',
DeprecationWarning,
stacklevel=2)
return
StockTransaction = plata.stock_model()
StockTransaction.objects.bulk_create(
order,
notes=_('%(stage)s: %(order)s processed by %(payment_module)s') % {
'stage': stage,
'order': order,
'payment_module': self.name,
},
**kwargs)
def create_transactions(self, order, stage, **kwargs):
"""
Create transactions for all order items. The real work is offloaded
to ``StockTransaction.objects.bulk_create``.
"""
if not plata.settings.PLATA_STOCK_TRACKING:
warnings.warn(
"StockTransaction.objects.create_transactions"
" currently has no effect when PLATA_STOCK_TRACKING = False."
" This will change in the future. Change your code to only"
" call create_transactions when"
" plata.settings.PLATA_STOCK_TRACKING = True",
DeprecationWarning,
stacklevel=2,
)
return
StockTransaction = plata.stock_model()
StockTransaction.objects.bulk_create(
order,
notes=_("%(stage)s: %(order)s processed by %(payment_module)s") % {
"stage": stage,
"order": order,
"payment_module": self.name
},
**kwargs)
def process_order_confirmed(self, request, order):
if not order.balance_remaining:
return self.already_paid(order, request=request)
logger.info("Processing order %s using COD" % order)
payment = self.create_pending_payment(order)
payment.status = OrderPayment.AUTHORIZED
payment.authorized = timezone.now()
payment.save()
order = order.reload()
if plata.settings.PLATA_STOCK_TRACKING:
StockTransaction = plata.stock_model()
self.create_transactions(
order,
_("sale"),
type=StockTransaction.SALE,
negative=True,
payment=payment,
)
self.order_paid(order, payment=payment, request=request)
return self.shop.redirect("plata_order_success")
def process_order_confirmed(self, request, order):
OGONE = settings.OGONE
if not order.balance_remaining:
return self.already_paid(order)
logger.info('Processing order %s using Ogone' % order)
payment = self.create_pending_payment(order)
if plata.settings.PLATA_STOCK_TRACKING:
StockTransaction = plata.stock_model()
self.create_transactions(order, _('payment process reservation'),
type=StockTransaction.PAYMENT_PROCESS_RESERVATION,
negative=True, payment=payment)
# params that will be hashed
form_params = {
'PSPID': OGONE['PSPID'],
'orderID': 'Order-%d-%d' % (order.id, payment.id),
'amount': u'%s' % int(order.balance_remaining.quantize(Decimal('0.00'))*100),
'currency': order.currency,
'language': locale.normalize(to_locale(get_language())).split('.')[0],
'CN': u'%s %s' % (order.billing_first_name, order.billing_last_name),
'EMAIL': order.email,
'ownerZIP': order.billing_zip_code,
'owneraddress': order.billing_address,
'ownertown': order.billing_city,
'accepturl': u'http://%s%s' % (
request.META.get('HTTP_HOST'),
reverse('plata_order_success')),
'declineurl': u'http://%s%s' % (
request.META.get('HTTP_HOST'),
reverse('plata_order_payment_failure')),
'exceptionurl': u'http://%s%s' % (
request.META.get('HTTP_HOST'),
reverse('plata_order_payment_failure')),
'cancelurl': u'http://%s%s' % (
request.META.get('HTTP_HOST'),
reverse('plata_order_payment_failure')),
}
# create hash
value_strings = [u'{0}={1}{2}'.format(key.upper(), value, OGONE['SHA1_IN'])
for key, value in form_params.items()]
hash_string = u''.join(sorted(value_strings))
encoded_hash_string = sha1(hash_string.encode('utf-8')).hexdigest()
# add hash and additional params
form_params.update({
'SHASign': encoded_hash_string.upper(),
'mode': OGONE['LIVE'] and 'prod' or 'test',
})
return self.shop.render(request, 'payment/ogone_form.html', {
'order': order,
'HTTP_HOST': request.META.get('HTTP_HOST'),
'form_params': form_params,
'locale': form_params['language'],
})
def reserve_stock_item(self, order, payment):
if plata.settings.PLATA_STOCK_TRACKING:
StockTransaction = plata.stock_model()
self.create_transactions(
order,
_("payment process reservation"),
type=StockTransaction.PAYMENT_PROCESS_RESERVATION,
negative=True,
payment=payment,
)
def process_order_confirmed(self, request, order):
POSTFINANCE = settings.POSTFINANCE
if not order.balance_remaining:
return self.already_paid(order, request=request)
logger.info("Processing order %s using Postfinance" % order)
payment = self.create_pending_payment(order)
if plata.settings.PLATA_STOCK_TRACKING:
StockTransaction = plata.stock_model()
self.create_transactions(
order,
_("payment process reservation"),
type=StockTransaction.PAYMENT_PROCESS_RESERVATION,
negative=True,
payment=payment,
)
form_params = {
"orderID":
"Order-%d-%d" % (order.id, payment.id),
"amount":
"%s" %
int(order.balance_remaining.quantize(Decimal("0.00")) * 100),
"currency":
order.currency,
"PSPID":
POSTFINANCE["PSPID"],
"mode":
POSTFINANCE["LIVE"] and "prod" or "test",
}
form_params["SHASign"] = sha1(("".join((
form_params["orderID"],
form_params["amount"],
form_params["currency"],
form_params["PSPID"],
POSTFINANCE["SHA1_IN"],
))).encode("utf-8")).hexdigest()
return self.shop.render(
request,
"payment/%s_form.html" % self.key,
{
"order":
order,
"HTTP_HOST":
request.get_host(),
"form_params":
form_params,
"locale":
locale.normalize(to_locale(get_language())).split(".")[0],
},
)
def process_order_confirmed(self, request, order):
STRIPE = settings.STRIPE
stripe.api_key = STRIPE["SECRET_KEY"]
if "template" in STRIPE:
self.template = STRIPE["template"]
self.amount = 0
if not order.balance_remaining:
return self.already_paid(order, request=request)
logger.info("Processing order %s using %s" %
(order, self.default_name))
payment = self.create_pending_payment(order)
if plata.settings.PLATA_STOCK_TRACKING:
StockTransaction = plata.stock_model()
self.create_transactions(
order,
_("payment process reservation"),
type=StockTransaction.PAYMENT_PROCESS_RESERVATION,
negative=True,
payment=payment,
)
for item in order.items.all():
itemsum = 0
if item.unit_price != item.line_item_discount:
itemsum = item.unit_price
if item.line_item_discount:
itemsum -= item.line_item_discount
self.amount += itemsum * item.quantity
self.amount += order.shipping
if order.currency not in plata.settings.CURRENCIES_WITHOUT_CENTS:
# only if currency has cents; Stripe takes only integer values
# keyword zero-decimal currencies
self.amount = int(self.amount * 100)
self.order = order
return self.shop.render(
request,
self.template,
{
"order": order,
"payment": payment,
"post_url":
"/payment/%s/" % self.key, # internal, gets payment token
"amount": self.amount,
"currency": order.currency.lower(),
"public_key": STRIPE["PUBLIC_KEY"],
"name": get_current_site(request).name,
"description": _("Order %s") % order,
"logo": STRIPE["LOGO"],
},
)
def clear_pending_payments(self, order):
"""
Clear pending payments
"""
logger.info('Clearing pending payments on %s' % order)
if plata.settings.PLATA_STOCK_TRACKING:
StockTransaction = plata.stock_model()
for transaction in order.stock_transactions.filter(
type=StockTransaction.PAYMENT_PROCESS_RESERVATION):
transaction.delete()
order.payments.pending().delete()
def clear_pending_payments(self, order):
"""
Clear pending payments
"""
logger.info('Clearing pending payments on %s' % order)
if plata.settings.PLATA_STOCK_TRACKING:
StockTransaction = plata.stock_model()
for transaction in order.stock_transactions.filter(
type=StockTransaction.PAYMENT_PROCESS_RESERVATION):
transaction.delete()
order.payments.pending().delete()
def process_order_confirmed(self, request, order):
POSTFINANCE = settings.POSTFINANCE
if not order.balance_remaining:
return self.already_paid(order)
logger.info('Processing order %s using Postfinance' % order)
payment = self.create_pending_payment(order)
if plata.settings.PLATA_STOCK_TRACKING:
StockTransaction = plata.stock_model()
self.create_transactions(
order,
_('payment process reservation'),
type=StockTransaction.PAYMENT_PROCESS_RESERVATION,
negative=True,
payment=payment)
form_params = {
'orderID':
'Order-%d-%d' % (order.id, payment.id),
'amount':
u'%s' %
int(order.balance_remaining.quantize(Decimal('0.00')) * 100),
'currency':
order.currency,
'PSPID':
POSTFINANCE['PSPID'],
'mode':
POSTFINANCE['LIVE'] and 'prod' or 'test',
}
form_params['SHASign'] = sha1(u''.join((
form_params['orderID'],
form_params['amount'],
form_params['currency'],
form_params['PSPID'],
POSTFINANCE['SHA1_IN'],
))).hexdigest()
return self.shop.render(
request, 'payment/%s_form.html' % self.key, {
'order':
order,
'HTTP_HOST':
request.META.get('HTTP_HOST'),
'form_params':
form_params,
'locale':
locale.normalize(to_locale(get_language())).split('.')[0],
})
def order_payment_failure(self, request):
"""Handles order payment failures"""
order = self.order_from_request(request)
if not order:
messages.info(
request,
_("Payment failed and order could not be found anymore. Sorry."
),
)
return self.redirect("plata_shop_cart")
logger.warn("Order payment failure for %s" % order.order_id)
if plata.settings.PLATA_STOCK_TRACKING:
StockTransaction = plata.stock_model()
for transaction in order.stock_transactions.filter(
type=StockTransaction.PAYMENT_PROCESS_RESERVATION):
transaction.delete()
order.payments.pending().delete()
if order.payments.authorized().exists():
# There authorized order payments around!
messages.warning(request, _("Payment failed, please try again."))
logger.warn("Order %s is already partially paid, but payment"
" failed anyway!" % order.order_id)
elif order.status > order.CHECKOUT and order.status < order.PAID:
order.update_status(
order.CHECKOUT,
"Order payment failure, going back to checkout")
messages.info(
request,
_("Payment failed; you can continue editing your order and"
" try again."),
)
return self.render(
request,
self.failure_template,
self.get_context(request, {
"order": order,
"progress": "failure"
}),
)
def process_order_confirmed(self, request, order):
PAYPAL = settings.PAYPAL
if not order.balance_remaining:
return self.already_paid(order, request=request)
logger.info("Processing order %s using Paypal" % order)
payment = self.create_pending_payment(order)
if plata.settings.PLATA_STOCK_TRACKING:
StockTransaction = plata.stock_model()
self.create_transactions(
order,
_("payment process reservation"),
type=StockTransaction.PAYMENT_PROCESS_RESERVATION,
negative=True,
payment=payment,
)
if PAYPAL["LIVE"]:
PP_URL = "https://www.paypal.com/cgi-bin/webscr"
else:
PP_URL = "https://www.sandbox.paypal.com/cgi-bin/webscr"
return self.shop.render(
request,
"payment/%s_form.html" % self.key,
{
"order":
order,
"payment":
payment,
"RETURN_SCHEME":
PAYPAL.get("RETURN_SCHEME",
"https" if request.is_secure() else "http"),
"IPN_SCHEME":
PAYPAL.get("IPN_SCHEME", "http"),
"HTTP_HOST":
request.get_host(),
"post_url":
PP_URL,
"business":
PAYPAL["BUSINESS"],
},
)
def process_order_confirmed(self, request, order):
if not order.balance_remaining:
return self.already_paid(order)
logger.info('Processing order %s using CASH' % order)
payment = self.create_pending_payment(order)
payment.status = OrderPayment.PROCESSED
payment.save()
order = order.reload()
if plata.settings.PLATA_STOCK_TRACKING:
StockTransaction = plata.stock_model()
self.create_transactions(
order, _('sale'),
type=StockTransaction.SALE, negative=True, payment=payment)
return self.shop.redirect('plata_order_success')
def already_paid(self, order):
"""
Handles the case where a payment module is selected but the order
is already completely paid for (f.e. because an amount discount has
been used which covers the order).
Does nothing if the order **status** is ``PAID`` already.
"""
if order.status < order.PAID:
logger.info('Order %s is already completely paid' % order)
if plata.settings.PLATA_STOCK_TRACKING:
StockTransaction = plata.stock_model()
self.create_transactions(order, _('sale'),
type=StockTransaction.SALE, negative=True)
self.order_paid(order)
return self.shop.redirect('plata_order_success')
def product_xls():
"""
Create a list of all product variations, including stock and aggregated
stock transactions (by type)
"""
from plata.product.stock.models import Period
StockTransaction = plata.stock_model()
xls = XLSDocument()
xls.add_sheet(capfirst(_('products')))
_transactions = StockTransaction.objects.filter(
period=Period.objects.current(),
).order_by().values('product', 'type').annotate(Sum('change'))
transactions = defaultdict(dict)
for t in _transactions:
transactions[t['product']][t['type']] = t['change__sum']
titles = [
capfirst(_('product')),
_('SKU'),
capfirst(_('stock')),
]
titles.extend(
unicode(name) for key, name in StockTransaction.TYPE_CHOICES)
data = []
for product in plata.product_model().objects.all().select_related():
row = [
product,
getattr(product, 'sku', ''),
getattr(product, 'items_in_stock', -1),
]
row.extend(
transactions[product.id].get(key, '')
for key, name in StockTransaction.TYPE_CHOICES)
data.append(row)
xls.table(titles, data)
return xls
def product_xls():
"""
Create a list of all product variations, including stock and aggregated
stock transactions (by type)
"""
from plata.product.stock.models import Period
StockTransaction = plata.stock_model()
xls = XLSXDocument()
xls.add_sheet(capfirst(_("products")))
_transactions = (
StockTransaction.objects.filter(period=Period.objects.current())
.order_by()
.values("product", "type")
.annotate(Sum("change"))
)
transactions = defaultdict(dict)
for t in _transactions:
transactions[t["product"]][t["type"]] = t["change__sum"]
titles = [capfirst(_("product")), _("SKU"), capfirst(_("stock"))]
titles.extend("%s" % row[1] for row in StockTransaction.TYPE_CHOICES)
data = []
for product in plata.product_model().objects.all().select_related():
row = [
product,
getattr(product, "sku", ""),
getattr(product, "items_in_stock", -1),
]
row.extend(
transactions[product.id].get(key, "")
for key, name in StockTransaction.TYPE_CHOICES
)
data.append(row)
xls.table(titles, data)
return xls
def product_xls():
"""
Create a list of all product variations, including stock and aggregated
stock transactions (by type)
"""
from plata.product.stock.models import Period
StockTransaction = plata.stock_model()
xls = XLSDocument()
xls.add_sheet(capfirst(_('products')))
_transactions = StockTransaction.objects.filter(
period=Period.objects.current(), ).order_by().values(
'product', 'type').annotate(Sum('change'))
transactions = defaultdict(dict)
for t in _transactions:
transactions[t['product']][t['type']] = t['change__sum']
titles = [
capfirst(_('product')),
_('SKU'),
capfirst(_('stock')),
]
titles.extend('%s' % row[1] for row in StockTransaction.TYPE_CHOICES)
data = []
for product in plata.product_model().objects.all().select_related():
row = [
product,
getattr(product, 'sku', ''),
getattr(product, 'items_in_stock', -1),
]
row.extend(transactions[product.id].get(key, '')
for key, name in StockTransaction.TYPE_CHOICES)
data.append(row)
xls.table(titles, data)
return xls
def process_order_confirmed(self, request, order):
PAYPAL = settings.PAYPAL
if not order.balance_remaining:
return self.already_paid(order)
logger.info('Processing order %s using Paypal' % order)
payment = self.create_pending_payment(order)
if plata.settings.PLATA_STOCK_TRACKING:
StockTransaction = plata.stock_model()
self.create_transactions(
order,
_('payment process reservation'),
type=StockTransaction.PAYMENT_PROCESS_RESERVATION,
negative=True,
payment=payment)
if PAYPAL['LIVE']:
PP_URL = "https://www.paypal.com/cgi-bin/webscr"
else:
PP_URL = "https://www.sandbox.paypal.com/cgi-bin/webscr"
return self.shop.render(
request, 'payment/%s_form.html' % self.key, {
'order':
order,
'payment':
payment,
'RETURN_SCHEME':
PAYPAL.get('RETURN_SCHEME',
'https' if request.is_secure() else 'http'),
'IPN_SCHEME':
PAYPAL.get('IPN_SCHEME', 'http'),
'HTTP_HOST':
request.META.get('HTTP_HOST'),
'post_url':
PP_URL,
'business':
PAYPAL['BUSINESS'],
})
def already_paid(self, order):
"""
Handles the case where a payment module is selected but the order
is already completely paid for (f.e. because an amount discount has
been used which covers the order).
Does nothing if the order **status** is ``PAID`` already.
"""
if order.status < order.PAID:
logger.info('Order %s is already completely paid' % order)
if plata.settings.PLATA_STOCK_TRACKING:
StockTransaction = plata.stock_model()
self.create_transactions(order,
_('sale'),
type=StockTransaction.SALE,
negative=True)
self.order_paid(order)
return self.shop.redirect('plata_order_success')
def process_order_confirmed(self, request, order):
POSTFINANCE = settings.POSTFINANCE
if not order.balance_remaining:
return self.already_paid(order)
logger.info('Processing order %s using Postfinance' % order)
payment = self.create_pending_payment(order)
if plata.settings.PLATA_STOCK_TRACKING:
StockTransaction = plata.stock_model()
self.create_transactions(
order, _('payment process reservation'),
type=StockTransaction.PAYMENT_PROCESS_RESERVATION,
negative=True, payment=payment)
form_params = {
'orderID': 'Order-%d-%d' % (order.id, payment.id),
'amount': u'%s' % int(
order.balance_remaining.quantize(Decimal('0.00')) * 100),
'currency': order.currency,
'PSPID': POSTFINANCE['PSPID'],
'mode': POSTFINANCE['LIVE'] and 'prod' or 'test',
}
form_params['SHASign'] = sha1(u''.join((
form_params['orderID'],
form_params['amount'],
form_params['currency'],
form_params['PSPID'],
POSTFINANCE['SHA1_IN'],
))).hexdigest()
return self.shop.render(request, 'payment/%s_form.html' % self.key, {
'order': order,
'HTTP_HOST': request.META.get('HTTP_HOST'),
'form_params': form_params,
'locale': locale.normalize(
to_locale(get_language())).split('.')[0],
})
def order_payment_failure(self, request):
"""Handles order payment failures"""
order = self.order_from_request(request)
logger.warn('Order payment failure for %s' % order.order_id)
if plata.settings.PLATA_STOCK_TRACKING:
StockTransaction = plata.stock_model()
for transaction in order.stock_transactions.filter(
type=StockTransaction.PAYMENT_PROCESS_RESERVATION):
transaction.delete()
order.payments.pending().delete()
if order.payments.authorized().exists():
# There authorized order payments around!
messages.warning(request, _('Payment failed, please try again.'))
logger.warn(
'Order %s is already partially paid, but payment'
' failed anyway!' % order.order_id)
elif order.status > order.CHECKOUT and order.status < order.PAID:
order.update_status(
order.CHECKOUT,
'Order payment failure, going back to checkout')
messages.info(request, _(
'Payment failed; you can continue editing your order and'
' try again.'))
return self.render(
request,
self.failure_template,
self.get_context(
request, {
'order': order,
'progress': 'failure',
}
)
)
def create_transactions(self, order, stage, **kwargs):
"""
Create transactions for all order items. The real work is offloaded
to ``StockTransaction.objects.bulk_create``.
"""
if not plata.settings.PLATA_STOCK_TRACKING:
warnings.warn('StockTransaction.objects.create_transactions'
' currently has no effect when PLATA_STOCK_TRACKING = False.'
' This will change in the future. Change your code to only'
' call create_transactions when'
' plata.settings.PLATA_STOCK_TRACKING = True',
DeprecationWarning, stacklevel=2)
return
StockTransaction = plata.stock_model()
StockTransaction.objects.bulk_create(order,
notes=_('%(stage)s: %(order)s processed by %(payment_module)s') %{
'stage': stage,
'order': order,
'payment_module': self.name,
},
**kwargs)
def process_order_confirmed(self, request, order):
DATATRANS = settings.DATATRANS
if not order.balance_remaining:
return self.already_paid(order, request=request)
logger.info("Processing order %s using Datatrans" % order)
payment = self.create_pending_payment(order)
if plata.settings.PLATA_STOCK_TRACKING:
StockTransaction = plata.stock_model()
self.create_transactions(
order,
_("payment process reservation"),
type=StockTransaction.PAYMENT_PROCESS_RESERVATION,
negative=True,
payment=payment,
)
if DATATRANS.get("LIVE", True):
DT_URL = "https://payment.datatrans.biz/upp/jsp/upStart.jsp"
else:
DT_URL = "https://pilot.datatrans.biz/upp/jsp/upStart.jsp"
return render(
request,
"payment/datatrans_form.html",
{
"order": order,
"total_in_smallest_unit":
payment.amount * SMALLEST_UNIT_FACTOR,
"payment": payment,
"HTTP_HOST": request.META.get("HTTP_HOST"),
"post_url": DT_URL,
"MERCHANT_ID": DATATRANS["MERCHANT_ID"],
},
)
def ipn(self, request):
if not request._read_started:
if 'windows-1252' in request.body:
if request.encoding != 'windows-1252':
request.encoding = 'windows-1252'
else: # middleware (or something else?) has triggered request reading
if request.POST.get('charset') == 'windows-1252':
if request.encoding != 'windows-1252':
# since the POST data has already been accessed,
# unicode characters may have already been lost and
# cannot be re-encoded.
# -- see https://code.djangoproject.com/ticket/14035
# Unfortunately, PayPal:
# a) defaults to windows-1252 encoding (why?!)
# b) doesn't indicate this in the Content-Type header
# so Django cannot automatically detect it.
logger.warning(
'IPN received with charset=windows1252, however '
'the request encoding does not match. It may be '
'impossible to verify this IPN if the data contains '
'non-ASCII characters. Please either '
'a) update your PayPal preferences to use UTF-8 '
'b) configure your site so that IPN requests are '
'not ready before they reach the hanlder'
)
PAYPAL = settings.PAYPAL
if PAYPAL['LIVE']:
PP_URL = "https://www.paypal.com/cgi-bin/webscr"
else:
PP_URL = "https://www.sandbox.paypal.com/cgi-bin/webscr"
parameters = None
try:
parameters = request.POST.copy()
parameters_repr = repr(parameters).encode('utf-8')
if parameters:
logger.info(
'IPN: Processing request data %s' % parameters_repr)
querystring = 'cmd=_notify-validate&%s' % (
request.POST.urlencode()
)
status = urllib2.urlopen(PP_URL, querystring).read()
if not status == "VERIFIED":
logger.error(
'IPN: Received status %s, '
'could not verify parameters %s' % (
status,
parameters_repr
)
)
logger.debug('Destination: %r ? %r', PP_URL, querystring)
logger.debug('Request: %r', request)
return HttpResponseForbidden('Unable to verify')
if parameters:
logger.info('IPN: Verified request %s' % parameters_repr)
reference = parameters['txn_id']
invoice_id = parameters['invoice']
currency = parameters['mc_currency']
amount = parameters['mc_gross']
try:
order, order_id, payment_id = invoice_id.split('-')
except ValueError:
logger.error(
'IPN: Error getting order for %s' % invoice_id)
return HttpResponseForbidden('Malformed order ID')
try:
order = self.shop.order_model.objects.get(pk=order_id)
except (self.shop.order_model.DoesNotExist, ValueError):
logger.error('IPN: Order %s does not exist' % order_id)
return HttpResponseForbidden(
'Order %s does not exist' % order_id)
try:
payment = order.payments.get(pk=payment_id)
except (order.payments.model.DoesNotExist, ValueError):
payment = order.payments.model(
order=order,
payment_module=u'%s' % self.name,
)
payment.status = OrderPayment.PROCESSED
payment.currency = currency
payment.amount = Decimal(amount)
payment.data = request.POST.copy()
payment.transaction_id = reference
payment.payment_method = payment.payment_module
if parameters['payment_status'] == 'Completed':
payment.authorized = timezone.now()
payment.status = OrderPayment.AUTHORIZED
payment.save()
order = order.reload()
logger.info(
'IPN: Successfully processed IPN request for %s' % order)
if payment.authorized and plata.settings.PLATA_STOCK_TRACKING:
StockTransaction = plata.stock_model()
self.create_transactions(
order,
_('sale'),
type=StockTransaction.SALE,
negative=True,
payment=payment)
if not order.balance_remaining:
self.order_paid(order, payment=payment, request=request)
return HttpResponse("Ok")
except Exception, e:
logger.error('IPN: Processing failure %s' % unicode(e))
raise
def process_order_confirmed(self, request, order):
OGONE = settings.OGONE
if not order.balance_remaining:
return self.already_paid(order, request=request)
logger.info("Processing order %s using Ogone" % order)
payment = self.create_pending_payment(order)
if plata.settings.PLATA_STOCK_TRACKING:
StockTransaction = plata.stock_model()
self.create_transactions(
order,
_("payment process reservation"),
type=StockTransaction.PAYMENT_PROCESS_RESERVATION,
negative=True,
payment=payment,
)
# params that will be hashed
form_params = {
"PSPID":
OGONE["PSPID"],
"orderID":
"Order-%d-%d" % (order.id, payment.id),
"amount":
"%s" %
int(order.balance_remaining.quantize(Decimal("0.00")) * 100),
"currency":
order.currency,
"language":
locale.normalize(to_locale(get_language())).split(".")[0],
"CN":
"%s %s" % (order.billing_first_name, order.billing_last_name),
"EMAIL":
order.email,
"ownerZIP":
order.billing_zip_code,
"owneraddress":
order.billing_address,
"ownertown":
order.billing_city,
"accepturl":
"http://%s%s" %
(request.get_host(), reverse("plata_order_success")),
"declineurl":
"http://%s%s" %
(request.get_host(), reverse("plata_order_payment_failure")),
"exceptionurl":
"http://%s%s" %
(request.get_host(), reverse("plata_order_payment_failure")),
"cancelurl":
"http://%s%s" %
(request.get_host(), reverse("plata_order_payment_failure")),
}
# create hash
value_strings = [
"{0}={1}{2}".format(key.upper(), value, OGONE["SHA1_IN"])
for key, value in form_params.items()
]
hash_string = "".join(sorted(value_strings))
encoded_hash_string = sha1(hash_string.encode("utf-8")).hexdigest()
# add hash and additional params
form_params.update({
"SHASign": encoded_hash_string.upper(),
"mode": OGONE["LIVE"] and "prod" or "test",
})
return self.shop.render(
request,
"payment/%s_form.html" % self.key,
{
"order": order,
"HTTP_HOST": request.get_host(),
"form_params": form_params,
"locale": form_params["language"],
},
)
def process_order_confirmed(self, request, order):
if not order.balance_remaining:
return self.already_paid(order)
logger.info(
"Processing order %s using bank transfer in advance (prepay)" %
order)
payment = self.create_pending_payment(order)
order.notes = str(uuid4())
order.save()
if plata.settings.PLATA_STOCK_TRACKING:
StockTransaction = plata.stock_model()
self.create_transactions(
order,
_("sale"),
type=StockTransaction.SALE,
negative=True,
payment=payment,
)
current_site = Site.objects.get_current()
confirm_link = "https://%s%s" % (
current_site.domain,
reverse("plata_payment_prepay_confirm",
kwargs={"uuid": order.notes}),
)
message = _(
"""The order %(order)s has been confirmed for bank transfer in advance.
Customer: %(first_name)s %(last_name)s <%(email)s>
Items: %(items)s
Amount due: %(remaining)s %(currency)s
Click on this link when the payment is received: %(confirm_link)s
""" % {
"order": order,
"first_name": order.user.first_name,
"last_name": order.user.last_name,
"email": order.email,
"items": ", ".join(
("%s" % item) for item in order.items.all()),
"remaining": order.balance_remaining,
"currency": order.currency,
"confirm_link": confirm_link,
})
try:
notification_emails = settings.PLATA_PAYMENT_PREPAY_NOTIFICATIONS.get(
order.currency)
except KeyError:
notification_emails = settings.PLATA_PAYMENT_PREPAY_NOTIFICATIONS
except AttributeError:
raise Exception(
_("Configure the notification emails in the"
" PLATA_PAYMENT_PREPAY_NOTIFICATIONS setting"))
send_mail(
_(
"%(prefix)sNew order on bank transfer (%(order)s)" % {
"prefix": getattr(settings, "EMAIL_SUBJECT_PREFIX", ""),
"order": order,
}),
message,
settings.SERVER_EMAIL,
notification_emails,
)
return self.shop.render(
request,
"payment/prepay_informations.html",
{
"order": order,
"payment": payment,
"HTTP_HOST": request.META.get("HTTP_HOST"),
},
)
def ipn(self, request):
if not request._read_started:
if "windows-1252" in request.body.decode("windows-1252", "ignore"):
if request.encoding != "windows-1252":
request.encoding = "windows-1252"
else: # middleware (or something else?) has triggered request reading
if request.POST.get("charset") == "windows-1252":
if request.encoding != "windows-1252":
# since the POST data has already been accessed,
# unicode characters may have already been lost and
# cannot be re-encoded.
# -- see https://code.djangoproject.com/ticket/14035
# Unfortunately, PayPal:
# a) defaults to windows-1252 encoding (why?!)
# b) doesn't indicate this in the Content-Type header
# so Django cannot automatically detect it.
logger.warning(
"IPN received with charset=windows1252, however "
"the request encoding does not match. It may be "
"impossible to verify this IPN if the data contains "
"non-ASCII characters. Please either "
"a) update your PayPal preferences to use UTF-8 "
"b) configure your site so that IPN requests are "
"not ready before they reach the handler"
)
PAYPAL = settings.PAYPAL
if PAYPAL["LIVE"]:
PP_URL = "https://www.paypal.com/cgi-bin/webscr"
else:
PP_URL = "https://www.sandbox.paypal.com/cgi-bin/webscr"
parameters = None
try:
parameters = request.POST.copy()
parameters_repr = repr(parameters).encode("utf-8")
if parameters:
logger.info("IPN: Processing request data %s" % parameters_repr)
querystring = "cmd=_notify-validate&%s" % (request.POST.urlencode())
status = urlopen(PP_URL, querystring).read()
if not status == b"VERIFIED":
logger.error(
"IPN: Received status %s, "
"could not verify parameters %s" % (status, parameters_repr)
)
logger.debug("Destination: %r ? %r", PP_URL, querystring)
logger.debug("Request: %r", request)
return HttpResponseForbidden("Unable to verify")
if parameters:
logger.info("IPN: Verified request %s" % parameters_repr)
reference = parameters["txn_id"]
invoice_id = parameters["invoice"]
currency = parameters["mc_currency"]
amount = parameters["mc_gross"]
try:
order, order_id, payment_id = invoice_id.split("-")
except ValueError:
logger.error("IPN: Error getting order for %s" % invoice_id)
return HttpResponseForbidden("Malformed order ID")
try:
order = self.shop.order_model.objects.get(pk=order_id)
except (self.shop.order_model.DoesNotExist, ValueError):
logger.error("IPN: Order %s does not exist" % order_id)
return HttpResponseForbidden("Order %s does not exist" % order_id)
try:
payment = order.payments.get(pk=payment_id)
except (order.payments.model.DoesNotExist, ValueError):
payment = order.payments.model(
order=order, payment_module="%s" % self.name
)
payment.status = OrderPayment.PROCESSED
payment.currency = currency
payment.amount = Decimal(amount)
payment.data = request.POST.copy()
payment.transaction_id = reference
payment.payment_method = payment.payment_module
if parameters["payment_status"] == "Completed":
payment.authorized = timezone.now()
payment.status = OrderPayment.AUTHORIZED
payment.save()
order = order.reload()
logger.info("IPN: Successfully processed IPN request for %s" % order)
if payment.authorized and plata.settings.PLATA_STOCK_TRACKING:
StockTransaction = plata.stock_model()
self.create_transactions(
order,
_("sale"),
type=StockTransaction.SALE,
negative=True,
payment=payment,
)
if not order.balance_remaining:
self.order_paid(order, payment=payment, request=request)
return HttpResponse("Ok")
except Exception as e:
logger.error("IPN: Processing failure %s" % e)
raise
else:
logger.warning("IPN received without POST parameters")
return HttpResponseForbidden("No parameters provided")
def process_order_confirmed(self, request, order):
OGONE = settings.OGONE
if not order.balance_remaining:
return self.already_paid(order)
logger.info('Processing order %s using Ogone' % order)
payment = self.create_pending_payment(order)
if plata.settings.PLATA_STOCK_TRACKING:
StockTransaction = plata.stock_model()
self.create_transactions(
order,
_('payment process reservation'),
type=StockTransaction.PAYMENT_PROCESS_RESERVATION,
negative=True,
payment=payment)
# params that will be hashed
form_params = {
'PSPID':
OGONE['PSPID'],
'orderID':
'Order-%d-%d' % (order.id, payment.id),
'amount':
u'%s' %
int(order.balance_remaining.quantize(Decimal('0.00')) * 100),
'currency':
order.currency,
'language':
locale.normalize(to_locale(get_language())).split('.')[0],
'CN':
u'%s %s' % (order.billing_first_name, order.billing_last_name),
'EMAIL':
order.email,
'ownerZIP':
order.billing_zip_code,
'owneraddress':
order.billing_address,
'ownertown':
order.billing_city,
'accepturl':
u'http://%s%s' %
(request.META.get('HTTP_HOST'), reverse('plata_order_success')),
'declineurl':
u'http://%s%s' % (request.META.get('HTTP_HOST'),
reverse('plata_order_payment_failure')),
'exceptionurl':
u'http://%s%s' % (request.META.get('HTTP_HOST'),
reverse('plata_order_payment_failure')),
'cancelurl':
u'http://%s%s' % (request.META.get('HTTP_HOST'),
reverse('plata_order_payment_failure')),
}
# create hash
value_strings = [
u'{0}={1}{2}'.format(key.upper(), value, OGONE['SHA1_IN'])
for key, value in form_params.items()
]
hash_string = u''.join(sorted(value_strings))
encoded_hash_string = sha1(hash_string.encode('utf-8')).hexdigest()
# add hash and additional params
form_params.update({
'SHASign': encoded_hash_string.upper(),
'mode': OGONE['LIVE'] and 'prod' or 'test',
})
return self.shop.render(
request, 'payment/%s_form.html' % self.key, {
'order': order,
'HTTP_HOST': request.META.get('HTTP_HOST'),
'form_params': form_params,
'locale': form_params['language'],
})
def ipn(self, request):
OGONE = settings.OGONE
try:
parameters_repr = repr(request.POST.copy()).encode('utf-8')
logger.info('IPN: Processing request data %s' % parameters_repr)
try:
orderID = request.POST['orderID']
currency = request.POST['currency']
amount = request.POST['amount']
STATUS = request.POST['STATUS']
PAYID = request.POST['PAYID']
BRAND = request.POST['BRAND']
SHASIGN = request.POST['SHASIGN']
except KeyError, e:
logger.error('IPN: Missing data in %s' % parameters_repr)
return HttpResponseForbidden('Missing data')
value_strings = [
u'{0}={1}{2}'.format(key.upper(), value, OGONE['SHA1_OUT'])
for key, value in request.POST.iteritems()
if value and not key == 'SHASIGN'
]
sha1_out = sha1(
(u''.join(sorted(value_strings))).encode('utf-8')).hexdigest()
if sha1_out.lower() != SHASIGN.lower():
logger.error('IPN: Invalid hash in %s' % parameters_repr)
return HttpResponseForbidden('Hash did not validate')
try:
order, order_id, payment_id = orderID.split('-')
except ValueError:
logger.error('IPN: Error getting order for %s' % orderID)
return HttpResponseForbidden('Malformed order ID')
# Try fetching the order and order payment objects
# We create a new order payment object in case the old one
# cannot be found.
try:
order = self.shop.order_model.objects.get(pk=order_id)
except self.shop.order_model.DoesNotExist:
logger.error('IPN: Order %s does not exist' % order_id)
return HttpResponseForbidden('Order %s does not exist' %
order_id)
try:
payment = order.payments.get(pk=payment_id)
except order.payments.model.DoesNotExist:
payment = order.payments.model(
order=order,
payment_module=u'%s' % self.name,
)
payment.status = OrderPayment.PROCESSED
payment.currency = currency
payment.amount = Decimal(amount)
payment.data = request.POST.copy()
payment.transaction_id = PAYID
payment.payment_method = BRAND
payment.notes = STATUS_DICT.get(STATUS)
if STATUS in ('5', '9'):
payment.authorized = timezone.now()
payment.status = OrderPayment.AUTHORIZED
payment.save()
order = order.reload()
logger.info('IPN: Successfully processed IPN request for %s' %
order)
if payment.authorized and plata.settings.PLATA_STOCK_TRACKING:
StockTransaction = plata.stock_model()
self.create_transactions(order,
_('sale'),
type=StockTransaction.SALE,
negative=True,
payment=payment)
if not order.balance_remaining:
self.order_paid(order, payment=payment, request=request)
return HttpResponse('OK')
def ipn(self, request):
OGONE = settings.OGONE
try:
parameters_repr = repr(request.POST.copy()).encode('utf-8')
logger.info('IPN: Processing request data %s' % parameters_repr)
try:
orderID = request.POST['orderID']
currency = request.POST['currency']
amount = request.POST['amount']
STATUS = request.POST['STATUS']
PAYID = request.POST['PAYID']
BRAND = request.POST['BRAND']
SHASIGN = request.POST['SHASIGN']
except KeyError, e:
logger.error('IPN: Missing data in %s' % parameters_repr)
return HttpResponseForbidden('Missing data')
value_strings = [
u'{0}={1}{2}'.format(key.upper(), value, OGONE['SHA1_OUT'])
for key, value in request.POST.iteritems()
if value and not key == 'SHASIGN']
sha1_out = sha1(
(u''.join(sorted(value_strings))).encode('utf-8')).hexdigest()
if sha1_out.lower() != SHASIGN.lower():
logger.error('IPN: Invalid hash in %s' % parameters_repr)
return HttpResponseForbidden('Hash did not validate')
try:
order, order_id, payment_id = orderID.split('-')
except ValueError:
logger.error('IPN: Error getting order for %s' % orderID)
return HttpResponseForbidden('Malformed order ID')
# Try fetching the order and order payment objects
# We create a new order payment object in case the old one
# cannot be found.
try:
order = self.shop.order_model.objects.get(pk=order_id)
except self.shop.order_model.DoesNotExist:
logger.error('IPN: Order %s does not exist' % order_id)
return HttpResponseForbidden(
'Order %s does not exist' % order_id)
try:
payment = order.payments.get(pk=payment_id)
except order.payments.model.DoesNotExist:
payment = order.payments.model(
order=order,
payment_module=u'%s' % self.name,
)
payment.status = OrderPayment.PROCESSED
payment.currency = currency
payment.amount = Decimal(amount)
payment.data = request.POST.copy()
payment.transaction_id = PAYID
payment.payment_method = BRAND
payment.notes = STATUS_DICT.get(STATUS)
if STATUS in ('5', '9'):
payment.authorized = timezone.now()
payment.status = OrderPayment.AUTHORIZED
payment.save()
order = order.reload()
logger.info(
'IPN: Successfully processed IPN request for %s' % order)
if payment.authorized and plata.settings.PLATA_STOCK_TRACKING:
StockTransaction = plata.stock_model()
self.create_transactions(
order, _('sale'),
type=StockTransaction.SALE, negative=True, payment=payment)
if not order.balance_remaining:
self.order_paid(order, payment=payment, request=request)
return HttpResponse('OK')
def ipn(self, request):
POSTFINANCE = settings.POSTFINANCE
try:
parameters_repr = repr(request.POST.copy()).encode('utf-8')
logger.info('IPN: Processing request data %s' % parameters_repr)
try:
orderID = request.POST['orderID']
currency = request.POST['currency']
amount = request.POST['amount']
PM = request.POST['PM']
ACCEPTANCE = request.POST['ACCEPTANCE']
STATUS = request.POST['STATUS']
CARDNO = request.POST['CARDNO']
PAYID = request.POST['PAYID']
NCERROR = request.POST['NCERROR']
BRAND = request.POST['BRAND']
SHASIGN = request.POST['SHASIGN']
except KeyError:
logger.error('IPN: Missing data in %s' % parameters_repr)
return HttpResponseForbidden('Missing data')
sha1_source = u''.join((
orderID,
currency,
amount,
PM,
ACCEPTANCE,
STATUS,
CARDNO,
PAYID,
NCERROR,
BRAND,
POSTFINANCE['SHA1_OUT'],
))
sha1_out = sha1(sha1_source).hexdigest()
if sha1_out.lower() != SHASIGN.lower():
logger.error('IPN: Invalid hash in %s' % parameters_repr)
return HttpResponseForbidden('Hash did not validate')
try:
order, order_id, payment_id = orderID.split('-')
except ValueError:
logger.error('IPN: Error getting order for %s' % orderID)
return HttpResponseForbidden('Malformed order ID')
# Try fetching the order and order payment objects
# We create a new order payment object in case the old one
# cannot be found.
try:
order = self.shop.order_model.objects.get(pk=order_id)
except self.shop.order_model.DoesNotExist:
logger.error('IPN: Order %s does not exist' % order_id)
return HttpResponseForbidden(
'Order %s does not exist' % order_id)
try:
payment = order.payments.get(pk=payment_id)
except order.payments.model.DoesNotExist:
payment = order.payments.model(
order=order,
payment_module=u'%s' % self.name,
)
payment.status = OrderPayment.PROCESSED
payment.currency = currency
payment.amount = Decimal(amount)
payment.data = request.POST.copy()
payment.transaction_id = PAYID
payment.payment_method = BRAND
payment.notes = STATUS_DICT.get(STATUS)
if STATUS in ('5', '9'):
payment.authorized = timezone.now()
payment.status = OrderPayment.AUTHORIZED
payment.save()
order = order.reload()
logger.info(
'IPN: Successfully processed IPN request for %s' % order)
if payment.authorized and plata.settings.PLATA_STOCK_TRACKING:
StockTransaction = plata.stock_model()
self.create_transactions(
order, _('sale'),
type=StockTransaction.SALE, negative=True, payment=payment)
if not order.balance_remaining:
self.order_paid(order, payment=payment, request=request)
return HttpResponse('OK')
except Exception, e:
logger.error('IPN: Processing failure %s' % unicode(e))
raise
def ipn(self, request):
if not request._read_started:
if 'windows-1252' in request.body:
if request.encoding != 'windows-1252':
request.encoding = 'windows-1252'
else: # middleware (or something else?) has triggered request reading
if request.POST.get('charset') == 'windows-1252':
if request.encoding != 'windows-1252':
# since the POST data has already been accessed,
# unicode characters may have already been lost and
# cannot be re-encoded.
# -- see https://code.djangoproject.com/ticket/14035
# Unfortunately, PayPal:
# a) defaults to windows-1252 encoding (why?!)
# b) doesn't indicate this in the Content-Type header
# so Django cannot automatically detect it.
logger.warning(
'IPN received with charset=windows1252, however '
'the request encoding does not match. It may be '
'impossible to verify this IPN if the data contains '
'non-ASCII characters. Please either '
'a) update your PayPal preferences to use UTF-8 '
'b) configure your site so that IPN requests are '
'not ready before they reach the hanlder')
PAYPAL = settings.PAYPAL
if PAYPAL['LIVE']:
PP_URL = "https://www.paypal.com/cgi-bin/webscr"
else:
PP_URL = "https://www.sandbox.paypal.com/cgi-bin/webscr"
parameters = None
try:
parameters = request.POST.copy()
parameters_repr = repr(parameters).encode('utf-8')
if parameters:
logger.info('IPN: Processing request data %s' %
parameters_repr)
querystring = 'cmd=_notify-validate&%s' % (
request.POST.urlencode())
status = urllib2.urlopen(PP_URL, querystring).read()
if not status == "VERIFIED":
logger.error('IPN: Received status %s, '
'could not verify parameters %s' %
(status, parameters_repr))
logger.debug('Destination: %r ? %r', PP_URL, querystring)
logger.debug('Request: %r', request)
return HttpResponseForbidden('Unable to verify')
if parameters:
logger.info('IPN: Verified request %s' % parameters_repr)
reference = parameters['txn_id']
invoice_id = parameters['invoice']
currency = parameters['mc_currency']
amount = parameters['mc_gross']
try:
order, order_id, payment_id = invoice_id.split('-')
except ValueError:
logger.error('IPN: Error getting order for %s' %
invoice_id)
return HttpResponseForbidden('Malformed order ID')
try:
order = self.shop.order_model.objects.get(pk=order_id)
except (self.shop.order_model.DoesNotExist, ValueError):
logger.error('IPN: Order %s does not exist' % order_id)
return HttpResponseForbidden('Order %s does not exist' %
order_id)
try:
payment = order.payments.get(pk=payment_id)
except (order.payments.model.DoesNotExist, ValueError):
payment = order.payments.model(
order=order,
payment_module=u'%s' % self.name,
)
payment.status = OrderPayment.PROCESSED
payment.currency = currency
payment.amount = Decimal(amount)
payment.data = request.POST.copy()
payment.transaction_id = reference
payment.payment_method = payment.payment_module
if parameters['payment_status'] == 'Completed':
payment.authorized = timezone.now()
payment.status = OrderPayment.AUTHORIZED
payment.save()
order = order.reload()
logger.info('IPN: Successfully processed IPN request for %s' %
order)
if payment.authorized and plata.settings.PLATA_STOCK_TRACKING:
StockTransaction = plata.stock_model()
self.create_transactions(order,
_('sale'),
type=StockTransaction.SALE,
negative=True,
payment=payment)
if not order.balance_remaining:
self.order_paid(order, payment=payment, request=request)
return HttpResponse("Ok")
except Exception, e:
logger.error('IPN: Processing failure %s' % unicode(e))
raise
def datatrans_success(self, request):
DATATRANS = settings.DATATRANS
if DATATRANS.get("LIVE", True):
DT_URL = "https://payment.datatrans.biz/upp/jsp/XML_status.jsp"
else:
DT_URL = "https://pilot.datatrans.biz/upp/jsp/XML_status.jsp"
parameters = None
try:
response = None
parameters = request.POST.copy()
parameters_repr = repr(parameters).encode("utf-8")
if parameters:
logger.info("IPN: Processing request data %s" %
parameters_repr)
xml = """<?xml version="1.0" encoding="UTF-8" ?>
<statusService version="1">
<body merchantId="%(merchant_id)s">
<transaction>
<request>
<uppTransactionId>%(transaction_id)s</uppTransactionId>
</request>
</transaction>
</body>
</statusService>
""" % {
"transaction_id": parameters["uppTransactionId"],
"merchant_id": DATATRANS["MERCHANT_ID"],
}
params = urllib.urlencode({"xmlRequest": xml})
xml_response = urllib.urlopen(DT_URL, params).read()
tree = ET.fromstring(xml_response)
response = tree.find("body/transaction/response")
response_code = response.find("responseCode").text
if response_code not in ("1", "2", "3"):
logger.error(
"IPN: Received response_code %s, could not verify parameters %s"
% (response_code, parameters_repr))
parameters = None
if response:
refno = response.find("refno").text
currency = response.find("currency").text
amount = response.find("amount").text
try:
order_id, payment_id = refno.split("-")
except ValueError:
logger.error("IPN: Error getting order for %s" % refno)
return HttpResponseForbidden("Malformed order ID")
try:
order = self.shop.order_model.objects.get(pk=order_id)
except self.shop.order_model.DoesNotExist:
logger.error("IPN: Order %s does not exist" % order_id)
return HttpResponseForbidden("Order %s does not exist" %
order_id)
try:
payment = order.payments.get(pk=payment_id)
except order.payments.model.DoesNotExist:
return HttpResponseForbidden("Payment %s does not exist" %
payment_id)
payment.status = OrderPayment.PROCESSED
payment.currency = currency
payment.amount = Decimal(float(amount) / SMALLEST_UNIT_FACTOR)
payment.data = request.POST.copy()
payment.transaction_id = refno
payment.payment_method = payment.payment_module
payment.authorized = now()
payment.status = OrderPayment.AUTHORIZED
payment.save()
order = order.reload()
logger.info("IPN: Successfully processed IPN request for %s" %
order)
if payment.authorized and plata.settings.PLATA_STOCK_TRACKING:
StockTransaction = plata.stock_model()
self.create_transactions(
order,
_("sale"),
type=StockTransaction.SALE,
negative=True,
payment=payment,
)
if not order.balance_remaining:
self.order_paid(order, payment=payment)
return redirect("plata_order_success")
except Exception as e:
logger.error("IPN: Processing failure %s" % e)
raise
def ipn(self, request):
POSTFINANCE = settings.POSTFINANCE
try:
parameters_repr = repr(request.POST.copy()).encode('utf-8')
logger.info('IPN: Processing request data %s' % parameters_repr)
try:
orderID = request.POST['orderID']
currency = request.POST['currency']
amount = request.POST['amount']
PM = request.POST['PM']
ACCEPTANCE = request.POST['ACCEPTANCE']
STATUS = request.POST['STATUS']
CARDNO = request.POST['CARDNO']
PAYID = request.POST['PAYID']
NCERROR = request.POST['NCERROR']
BRAND = request.POST['BRAND']
SHASIGN = request.POST['SHASIGN']
except KeyError:
logger.error('IPN: Missing data in %s' % parameters_repr)
return HttpResponseForbidden('Missing data')
sha1_source = ''.join((
orderID,
currency,
amount,
PM,
ACCEPTANCE,
STATUS,
CARDNO,
PAYID,
NCERROR,
BRAND,
POSTFINANCE['SHA1_OUT'],
))
sha1_out = sha1(sha1_source.encode('utf-8')).hexdigest()
if sha1_out.lower() != SHASIGN.lower():
logger.error('IPN: Invalid hash in %s' % parameters_repr)
return HttpResponseForbidden('Hash did not validate')
try:
order, order_id, payment_id = orderID.split('-')
except ValueError:
logger.error('IPN: Error getting order for %s' % orderID)
return HttpResponseForbidden('Malformed order ID')
# Try fetching the order and order payment objects
# We create a new order payment object in case the old one
# cannot be found.
try:
order = self.shop.order_model.objects.get(pk=order_id)
except self.shop.order_model.DoesNotExist:
logger.error('IPN: Order %s does not exist' % order_id)
return HttpResponseForbidden(
'Order %s does not exist' % order_id)
try:
payment = order.payments.get(pk=payment_id)
except order.payments.model.DoesNotExist:
payment = order.payments.model(
order=order,
payment_module=u'%s' % self.name,
)
payment.status = OrderPayment.PROCESSED
payment.currency = currency
payment.amount = Decimal(amount)
payment.data = request.POST.copy()
payment.transaction_id = PAYID
payment.payment_method = BRAND
payment.notes = STATUS_DICT.get(STATUS)
if STATUS in ('5', '9'):
payment.authorized = timezone.now()
payment.status = OrderPayment.AUTHORIZED
payment.save()
order = order.reload()
logger.info(
'IPN: Successfully processed IPN request for %s' % order)
if payment.authorized and plata.settings.PLATA_STOCK_TRACKING:
StockTransaction = plata.stock_model()
self.create_transactions(
order, _('sale'),
type=StockTransaction.SALE, negative=True, payment=payment)
if not order.balance_remaining:
self.order_paid(order, payment=payment, request=request)
return HttpResponse('OK')
except Exception as e:
logger.error('IPN: Processing failure %s' % e)
raise
def psnotify(self, request):
request.encoding = "ISO-8859-1"
PAGSEGURO = settings.PAGSEGURO
data = None
try:
data = request.POST.copy()
data = dict((k, v.encode("ISO-8859-1")) for k, v in data.items())
if data:
logger.info("Pagseguro: Processing request data %s" % data)
if PAGSEGURO.get("LOG"):
f = open(PAGSEGURO["LOG"], "a+")
f.write("%s - notification: %s\n" % (time.ctime(), data))
f.close()
notificationCode = data["notificationCode"]
result = urllib.urlopen(
"https://ws.pagseguro.uol.com.br/v2/transactions/notifications/%s?email=%s&token=%s" # noqa
% (notificationCode, PAGSEGURO["EMAIL"],
PAGSEGURO["TOKEN"])).read()
if PAGSEGURO.get("LOG"):
f = open(PAGSEGURO["LOG"], "a")
f.write("%s - notification check: %s" %
(time.ctime(), result))
f.close()
xml = minidom.parseString(result)
try:
xmlTag = xml.getElementsByTagName("status")[0].toxml()
status = xmlTag.replace("<status>",
"").replace("</status>", "")
xmlTag = xml.getElementsByTagName("reference")[0].toxml()
reference = xmlTag.replace("<reference>",
"").replace("</reference>", "")
xmlTag = xml.getElementsByTagName("grossAmount")[0].toxml()
amount = xmlTag.replace("<grossAmount>",
"").replace("</grossAmount>", "")
except (ValueError, IndexError):
logger.error("Pagseguro: Can't verify notification: %s" %
result.decode("ISO-8859-1"))
return HttpResponseForbidden("Order verification failed")
if PAGSEGURO.get("LOG"):
f = open(PAGSEGURO.get("LOG"), "a")
f.write(
"%s - status: %s, ref: %s, code: %s\n" %
(time.ctime(), status, reference, notificationCode))
f.close()
logger.info("Pagseguro: Verified request %s" % result)
try:
order, order_id, payment_id = reference.split("-")
except ValueError:
logger.error("Pagseguro: Error getting order for %s" %
reference)
return HttpResponseForbidden(_("Malformed order ID"))
try:
order = self.shop.order_model.objects.get(pk=order_id)
except self.shop.order_model.DoesNotExist:
logger.error("Pagseguro: Order %s does not exist" %
order_id)
return HttpResponseForbidden(
_("Order %s does not exist" % order_id))
try:
payment = order.payments.get(pk=payment_id)
except order.payments.model.DoesNotExist:
payment = order.payments.model(order=order,
payment_module="%s" %
self.name)
payment.status = OrderPayment.PROCESSED
payment.amount = Decimal(amount)
payment.data = request.POST.copy()
payment.transaction_id = notificationCode
payment.payment_method = payment.payment_module
if status == "3":
payment.authorized = datetime.now()
payment.status = OrderPayment.AUTHORIZED
payment.save()
order = order.reload()
payment.amount = Decimal(amount)
logger.info(
"Pagseguro: Successfully processed request for %s" % order)
if payment.authorized and plata.settings.PLATA_STOCK_TRACKING:
StockTransaction = plata.stock_model()
self.create_transactions(
order,
_("sale"),
type=StockTransaction.SALE,
negative=True,
payment=payment,
)
if not order.balance_remaining:
self.order_paid(order, payment=payment)
return HttpResponse("OK")
except Exception:
logger.exception("Pagseguro: Processing failure")
raise
return HttpResponseForbidden("Bad request")
def ipn(self, request):
request.encoding = 'windows-1252'
PAYPAL = settings.PAYPAL
if PAYPAL['LIVE']:
PP_URL = "https://www.paypal.com/cgi-bin/webscr"
else:
PP_URL = "https://www.sandbox.paypal.com/cgi-bin/webscr"
parameters = None
try:
parameters = request.POST.copy()
parameters_repr = repr(parameters).encode('utf-8')
if parameters:
logger.info('IPN: Processing request data %s' % parameters_repr)
postparams = {'cmd': '_notify-validate'}
for k, v in parameters.iteritems():
postparams[k] = v.encode('windows-1252')
status = urllib.urlopen(PP_URL, urllib.urlencode(postparams)).read()
if not status == "VERIFIED":
logger.error('IPN: Received status %s, could not verify parameters %s' % (
status, parameters_repr))
parameters = None
if parameters:
logger.info('IPN: Verified request %s' % parameters_repr)
reference = parameters['txn_id']
invoice_id = parameters['invoice']
currency = parameters['mc_currency']
amount = parameters['mc_gross']
try:
order, order_id, payment_id = invoice_id.split('-')
except ValueError:
logger.error('IPN: Error getting order for %s' % invoice_id)
return HttpResponseForbidden('Malformed order ID')
try:
order = self.shop.order_model.objects.get(pk=order_id)
except self.shop.order_model.DoesNotExist:
logger.error('IPN: Order %s does not exist' % order_id)
return HttpResponseForbidden('Order %s does not exist' % order_id)
try:
payment = order.payments.get(pk=payment_id)
except order.payments.model.DoesNotExist:
payment = order.payments.model(
order=order,
payment_module=u'%s' % self.name,
)
payment.status = OrderPayment.PROCESSED
payment.currency = currency
payment.amount = Decimal(amount)
payment.data = request.POST.copy()
payment.transaction_id = reference
payment.payment_method = payment.payment_module
if parameters['payment_status'] == 'Completed':
payment.authorized = timezone.now()
payment.status = OrderPayment.AUTHORIZED
payment.save()
order = order.reload()
logger.info('IPN: Successfully processed IPN request for %s' % order)
if payment.authorized and plata.settings.PLATA_STOCK_TRACKING:
StockTransaction = plata.stock_model()
self.create_transactions(order, _('sale'),
type=StockTransaction.SALE, negative=True, payment=payment)
if not order.balance_remaining:
self.order_paid(order, payment=payment)
return HttpResponse("Ok")
except Exception, e:
logger.error('IPN: Processing failure %s' % unicode(e))
raise
def ipn(self, request):
POSTFINANCE = settings.POSTFINANCE
try:
parameters_repr = repr(request.POST.copy()).encode("utf-8")
logger.info("IPN: Processing request data %s" % parameters_repr)
try:
orderID = request.POST["orderID"]
currency = request.POST["currency"]
amount = request.POST["amount"]
PM = request.POST["PM"]
ACCEPTANCE = request.POST["ACCEPTANCE"]
STATUS = request.POST["STATUS"]
CARDNO = request.POST["CARDNO"]
PAYID = request.POST["PAYID"]
NCERROR = request.POST["NCERROR"]
BRAND = request.POST["BRAND"]
SHASIGN = request.POST["SHASIGN"]
except KeyError:
logger.error("IPN: Missing data in %s" % parameters_repr)
return HttpResponseForbidden("Missing data")
sha1_source = "".join((
orderID,
currency,
amount,
PM,
ACCEPTANCE,
STATUS,
CARDNO,
PAYID,
NCERROR,
BRAND,
POSTFINANCE["SHA1_OUT"],
))
sha1_out = sha1(sha1_source.encode("utf-8")).hexdigest()
if sha1_out.lower() != SHASIGN.lower():
logger.error("IPN: Invalid hash in %s" % parameters_repr)
return HttpResponseForbidden("Hash did not validate")
try:
order, order_id, payment_id = orderID.split("-")
except ValueError:
logger.error("IPN: Error getting order for %s" % orderID)
return HttpResponseForbidden("Malformed order ID")
# Try fetching the order and order payment objects
# We create a new order payment object in case the old one
# cannot be found.
try:
order = self.shop.order_model.objects.get(pk=order_id)
except self.shop.order_model.DoesNotExist:
logger.error("IPN: Order %s does not exist" % order_id)
return HttpResponseForbidden("Order %s does not exist" %
order_id)
try:
payment = order.payments.get(pk=payment_id)
except order.payments.model.DoesNotExist:
payment = order.payments.model(order=order,
payment_module="%s" % self.name)
payment.status = OrderPayment.PROCESSED
payment.currency = currency
payment.amount = Decimal(amount)
payment.data = request.POST.copy()
payment.transaction_id = PAYID
payment.payment_method = BRAND
payment.notes = STATUS_DICT.get(STATUS)
if STATUS in ("5", "9"):
payment.authorized = timezone.now()
payment.status = OrderPayment.AUTHORIZED
payment.save()
order = order.reload()
logger.info("IPN: Successfully processed IPN request for %s" %
order)
if payment.authorized and plata.settings.PLATA_STOCK_TRACKING:
StockTransaction = plata.stock_model()
self.create_transactions(
order,
_("sale"),
type=StockTransaction.SALE,
negative=True,
payment=payment,
)
if not order.balance_remaining:
self.order_paid(order, payment=payment, request=request)
return HttpResponse("OK")
except Exception as e:
logger.error("IPN: Processing failure %s" % e)
raise
