def __init__(self, shop): self.shop = shop # Hook the payment was successful listener on the appropriate signal sent # by django-paypal (success_signal) assert settings.PAYPAL_RECEIVER_EMAIL, "You need to define a PAYPAL_RECEIVER_EMAIL in settings with the money recipient's email addresss" assert settings.PAYPAL_CURRENCY_CODE, "You need to define a PAYPAL_CURRENCY_CODE in settings with the currency code" success_signal.connect(self.payment_was_successful, weak=False) flagged_signal.connect(self.payment_was_flagged, weak=False) subscription_cancel_signal.connect(self.subscription_cancelled, weak=False) subscription_eot_signal.connect(self.subscription_expired, weak=False) subscription_modify_signal.connect(self.subscription_modified, weak=False) subscription_signup_signal.connect(self.subscription_signup_success, weak=False) recurring_create_signal.connect(self.recurring_created, weak=False) recurring_payment_signal.connect(self.recurring_payment, weak=False) recurring_cancel_signal.connect(self.recurring_cancelled, weak=False)
def show_me_the_money(sender, **kwargs): ipn_obj = sender # Undertake some action depending upon `ipn_obj`. if ipn_obj.payment_status == ST_PP_COMPLETED: print('Payment is completed') user_infor = ast.literal_eval(ipn_obj.custom) if ipn_obj.receiver_email == settings.PAYPAL_RECEIVER_EMAIL: print('And Payment is valid') # generate and send an email with pdf certificate file to the user's email user_infor = ast.literal_eval(ipn_obj.custom) user_info = { "name": user_infor['name'], "hours": user_infor['hours'], "taggedArticles": user_infor['taggedArticles'], "email": user_infor['email'], "date": user_infor['date'], } html = render_to_string('users/certificate_template.html', {'user': user_info}) response = HttpResponse(content_type='application/pdf') response['Content-Disposition'] = 'filename=certificate_{}'.format( user_info['name']) + '.pdf' pdf = weasyprint.HTML( string=html, base_url=settings.host + '/users/process/').write_pdf(stylesheets=[ weasyprint.CSS(string='body { font-family: serif}') ]) to_emails = [str(user_infor['email'])] subject = "Certificate from Nami Montana" email = EmailMessage(subject, body=pdf, from_email=settings.EMAIL_HOST_USER, to=to_emails) email.attach("certificate_{}".format(user_infor['name']) + '.pdf', pdf, "application/pdf") email.content_subtype = "pdf" # Main content is now text/html email.encoding = 'us-ascii' email.send() else: payment_was_flagged.connect(do_not_show_me_the_money)
digits.append(d) return digits def __unicode__(self): return "%s: %s" % (str(self.date), str(self.value)) def successful_payment(sender, **kwargs): ipn_obj = sender deal_pk = ipn_obj.custom deal = Deal.objects.get(pk=deal_pk) payer_email = ipn_obj.payer_email purchase = Purchase(deal=deal, first_name=ipn_obj.first_name, last_name=ipn_obj.last_name, email=payer_email, purchase_complete=True) purchase.save() def flagged_payment(sender, **kwargs): ipn_obj = sender deal_pk = ipn_obj.custom deal = Deal.objects.get(pk=deal_pk) payer_email = ipn_obj.payer_email purchase = Purchase(deal=deal, first_name=ipn_obj.first_name, last_name=ipn_obj.last_name, email=payer_email, purchase_complete=False) purchase.save() payment_was_successful.connect(successful_payment) payment_was_flagged.connect(flagged_payment)
} @property def service_url(self): if self.test_mode: return SANDBOX_POSTBACK_ENDPOINT return POSTBACK_ENDPOINT def get_urls(self): urlpatterns = patterns( '', (r'^', include('paypal.standard.ipn.urls')), ) return urlpatterns def unsuccessful_txn_handler(sender, **kwargs): transaction_was_unsuccessful.send(sender=sender.__class__, type="purchase", response=None) def successful_txn_handler(sender, **kwargs): transaction_was_successful.send(sender=sender.__class__, type="purchase", response=None) payment_was_flagged.connect(unsuccessful_txn_handler) payment_was_successful.connect(successful_txn_handler)
payment_date = ipn_obj.payment_date if created: profile.first_name = ipn_obj.first_name profile.last_name = ipn_obj.last_name start_date = datetime.date(payment_date.year, payment_date.month, payment_date.day) profile.member_since = start_date end_date = datetime.date(payment_date.year, (payment_date.month + 1) % 12, payment_date.day) if payment_date.month == 12: end_date = end_date.replace(year=payment_date.year + 1) profile.member_until = end_date profile.save() payment_was_successful.connect(paypal_to_profile, dispatch_uid="paypal_to_profile_unique_string") def email_admins(sender, **kwargs): send_mail( "[psone] flagged payment", "A payment was flagged, go investigate. http://psone-manager.herokuapp.com/admin/", "*****@*****.**", [a[1] for a in settings.ADMINS], fail_silently=False, ) payment_was_flagged.connect(email_admins, dispatch_uid="email_admins_unique_string") # class Membership(models.Model):
user_profile.credits += payment.credits user_profile.save() payment.set_paid() payment.save() if payment.coupon: log.info("Coupon code %s has been used by user %s" % (payment.coupon.code, payment.user)) if payment.coupon.used: log.error("It was already used by someone else. Fraud warning!") coupon = payment.coupon coupon.set_used() coupon.save() log.info("User %s has paid at price %s" % (payment.user, payment.price)) #if sub.price != pay.price: #log.error("Payment price is different than subscription price. Fraud warning!") #send_mail('Tariff changed', Template(open('./tariff.txt').read()).render(Context({'user':u})), settings.DEFAULT_FROM_EMAIL, [user.user.email], fail_silently=False) def payment_flagged(sender, **kwargs): log.warning("Paypal flagged transaction %s, please investigate!" % sender.invoice) payment_was_successful.connect(payment_ok) payment_was_flagged.connect(payment_flagged)
from django.db import models from paypal.standard.ipn.signals import payment_was_flagged import logging def flagged_signal(sender, **kwargs): log = logging.getLogger("dev.ttagit.logger") log.debug("SIGNAL!!!!-----FLAGGED SIGNAL") payment_was_flagged.connect(flagged_signal)
send_confirmation_email(purchase) purchase_paid.connect(send_mail_on_paiement) # ~~~ Payment handling class IPNHandler(object): import logging log = logging.getLogger("IPN handler") def __init__(self, sender=None, **kwargs): self.ERROR = None self.ipn = sender purchase = TicketPurchase.objects.get( invoice_id = self.ipn.invoice) if self.ipn.test_ipn: return #assert not purchase.paid, "This ticket is already marked as paid..." assert self.ipn.payment_status == "Completed", \ "Payment status is " + self.ipn.payment_status assert purchase.price() <= self.ipn.mc_gross, "Wrong amount: %f instead of %d" % (self.ipn.mc_gross, purchase.price()) purchase.mark_as_paid() self.log.info("TicketPurchase %i paid with paypal" % purchase.pk ) payment_was_successful.connect(IPNHandler) def alert_flagged_payment(sender,**kwargs): mail_admins("Flagged IPN", "Paypal IPN has been flagged.\n" + \ "https://tickets.fscons.org/admin/ipn/paypalipn/%d/\n" % sender.pk + \ "https://tickets.fscons.org/admin/ticketapp/ticketpurchase/?q=%s\n" % sender.invoice ) payment_was_flagged.connect(alert_flagged_payment)
ipn_obj = sender if ipn_obj: order = None if ipn_obj.payment_status == ST_PP_COMPLETED: order = mark_payment(ipn_obj, PAYMENT_FLAGGED) else: order = mark_payment(ipn_obj, PAYMENT_FAILED) if order is not None: transaction, created = PayPalOrderTransaction.objects.get_or_create(order=order) transaction.ipn.add(ipn_obj) transaction.save() else: logging.warning("unsuccessful ipn payment, no order found for uuid %s"%ipn_obj.custom) else: logging.warning("unsuccessful ipn payment signal with no ipn object") def successful_pdt(sender, **kwargs): logging.info("successful pdt payment") pdt_obj = sender order = mark_payment(pdt_obj, True) def unsuccesful_pdt(sender, **kwargs): logging.info("unsuccessful pdt payment") pdt_obj = sender order = mark_payment(pdt_obj, False) payment_was_successful.connect(successful_payment, dispatch_uid="Order.ipn_successful") payment_was_flagged.connect(unsuccessful_payment, dispatch_uid="Order.ipn_unsuccessful") pdt_successful.connect(successful_pdt, dispatch_uid="Order.pdt_successful") pdt_failed.connect(unsuccesful_pdt, dispatch_uid="Order.pdt_unsuccessful")
return HttpResponse('OKAY') def confirm_payment(sender, **kwargs): # make Order, put in db # look for invoice_id try: send_mail('confirm_payment', str(sender), '*****@*****.**', ['*****@*****.**'], fail_silently=False) unpaid_order = UnpaidOrder.objects.get(invoice_id=sender.invoice) dropoff_pickup_time = unpaid_order.dropoff_pickup_time dropoff_pickup_time.n_boxes_bought += unpaid_order.n_boxes_bought dropoff_pickup_time.save() order = Order(user=unpaid_order.user, cell_number=unpaid_order.cell_number, dropoff_pickup_time=unpaid_order.dropoff_pickup_time, proxy_name=unpaid_order.proxy_name, proxy_email=unpaid_order.proxy_email, n_boxes_bought=unpaid_order.n_boxes_bought, invoice_id=unpaid_order.invoice_id, signature=unpaid_order.signature) order.save() except Exception as e: send_mail('confirm_payment', 'something went wrong sending: ' + str(e), '*****@*****.**', ['*****@*****.**'], fail_silently=False) payment_was_successful.connect(confirm_payment) def handle_flagged(sender, **kwargs): send_mail('Subject here', 'Here is the message. (Flagged!)', '*****@*****.**', ['*****@*****.**'], fail_silently=False) payment_was_flagged.connect(handle_flagged)
# make Order, put in db # look for invoice_id try: send_mail('confirm_payment', str(sender), '*****@*****.**', ['*****@*****.**'], fail_silently=False) unpaid_order = UnpaidOrder.objects.get(invoice_id=sender.invoice) ''' # THIS IS NOW DONE ABOVE dropoff_pickup_time = unpaid_order.dropoff_pickup_time dropoff_pickup_time.n_boxes_bought += unpaid_order.n_boxes_bought dropoff_pickup_time.save() ''' order = Order(user=unpaid_order.user, cell_number=unpaid_order.cell_number, dropoff_pickup_time=unpaid_order.dropoff_pickup_time, proxy_name=unpaid_order.proxy_name, proxy_email=unpaid_order.proxy_email, n_boxes_bought=unpaid_order.n_boxes_bought, invoice_id=unpaid_order.invoice_id, signature=unpaid_order.signature) order.save() except Exception as e: send_mail('confirm_payment', 'something went wrong sending: ' + str(e), '*****@*****.**', ['*****@*****.**'], fail_silently=False) payment_was_successful.connect(confirm_payment) def handle_flagged(sender, **kwargs): send_mail('Subject here', 'Here is the message. (Flagged!)', '*****@*****.**', ['*****@*****.**'], fail_silently=False) payment_was_flagged.connect(handle_flagged)
valid = False elif ipn_obj.mc_amount3 != trans.gross_amount: valid = False if not valid: subject, from_email = 'DA admin - Paypal subscription error', 'Directo al Artista <*****@*****.**>' message = render_to_string('email/paypal_subs_error.html', { 'trans': trans, 'object': ipn_obj.item_name, }) html_content = render_to_string('email/global/template.html', { 'email_title': 'DA admin - Paypal subscription error', 'email_content': message, }) html_content = transform(html_content) text_content = strip_tags(html_content) msg = EmailMultiAlternatives(subject, text_content, from_email, ['*****@*****.**']) msg.attach_alternative(html_content, "text/html") msg.send(fail_silently=True) return valid payment_was_successful.connect(payment_success) payment_was_flagged.connect(payment_success_flagged) payment_was_refunded.connect(paypal_refund_payment) subscription_cancel.connect(paypal_subscription_canceled) subscription_signup.connect(paypal_validate_plan_signup) subscription_eot.connect(paypal_subscription_eot)
update_order(request, order, cart) order.total = 0 for line in order.orderline_set.all(): order.total += line.line_price order.total =+ order.total + Decimal(order.delivery.price) order.save() return order def play_signals(sender, **kwargs): ipn = sender order = Order.objects.get(pk=ipn.invoice) order.transaction_id = str(ipn.txn_id) order.payment_status = str(ipn.payment_status) order.payer_email = str(ipn.payer_email) order.payer_full_name = "%s %s" % (ipn.first_name, ipn.last_name) if order.payment_status == "Completed": if not ipn.flag: send_order_confirmation_email(order) order.save() return payment_was_successful.connect(play_signals) payment_was_flagged.connect(play_signals) def paypal_signal(ipn): pass
for line in order.orderline_set.all(): order.total += line.line_price order.total = +order.total + Decimal(order.delivery.price) order.save() return order def play_signals(sender, **kwargs): ipn = sender order = Order.objects.get(pk=ipn.invoice) order.transaction_id = str(ipn.txn_id) order.payment_status = str(ipn.payment_status) order.payer_email = str(ipn.payer_email) order.payer_full_name = "%s %s" % (ipn.first_name, ipn.last_name) if order.payment_status == "Completed": if not ipn.flag: send_order_confirmation_email(order) order.save() return payment_was_successful.connect(play_signals) payment_was_flagged.connect(play_signals) def paypal_signal(ipn): pass
def paypal_payment_was_flagged_handler(sender, **kwargs): logger = logging.getLogger("cardstories.paypal") logger.error("Paypal Payment Failed! %r; %r" % (sender.flag_code, sender.flag_info)) def send_bought_cards_confirmation_mail(user_id): """ Builds and sends the 'Thank you for buying cards' email to user specified by `user_id`. """ user = User.objects.get(id=user_id) email = user.username template = "bought_cards_confirmation" subject = "Thank you for purchasing a deck of cards!" message = mailing.message.build_mail(template, subject, email) smtp = get_connection(fail_silently=False) smtp.open() smtp.send_messages([message]) smtp.close() # Registers creation of user profile on post_save signal. post_save.connect(create_user_profile, sender=User) # Registers Paypal's IPN signals. payment_was_successful.connect(paypal_payment_was_successful_handler) payment_was_flagged.connect(paypal_payment_was_flagged_handler)
from paypal.standard.ipn.signals import payment_was_flagged def show_me_the_flag(sender, **kwargs): ipn_obj = sender # You need to check 'payment_status' of the IPN print str(ipn_obj.flag) + " --- " + str(ipn_obj.flag_info) payment_was_flagged.connect(show_me_the_flag)
logger.error("Error handling transaction from %r" % sender.payer_email) logger.error('-'*60 + '\n' + traceback.format_exc() + '\n' + '-'*60) return False def paypal_payment_was_flagged_handler(sender, **kwargs): logger = logging.getLogger('cardstories.paypal') logger.error("Paypal Payment Failed! %r; %r" % (sender.flag_code, sender.flag_info)) def send_bought_cards_confirmation_mail(user_id): """ Builds and sends the 'Thank you for buying cards' email to user specified by `user_id`. """ user = User.objects.get(id=user_id) email = user.username template = 'bought_cards_confirmation' subject = 'Thank you for purchasing a deck of cards!' message = mailing.message.build_mail(template, subject, email) smtp = get_connection(fail_silently=False) smtp.open() smtp.send_messages([message]) smtp.close() # Registers creation of user profile on post_save signal. post_save.connect(create_user_profile, sender=User) # Registers Paypal's IPN signals. payment_was_successful.connect(paypal_payment_was_successful_handler) payment_was_flagged.connect(paypal_payment_was_flagged_handler)
def reset_by_upgrade_variant_or_choice_set(sender, instance, created=False, **kwargs): if instance.item: reset_menu_json(instance.item.site) def reset_by_choice(sender, instance, created=False, **kwargs): if instance.group.item: reset_menu_json(instance.group.item.site) payment_was_successful.connect(register_paypal_payment) payment_was_flagged.connect(register_paypal_payment) post_save.connect(new_site_setup) post_save.connect(item_social_handler, sender=Item) post_save.connect(pdf_caching_handler, sender=Item) post_save.connect(create_defaults, sender=Item) post_save.connect(reset_by_section_or_item, sender=Item) post_save.connect(reset_by_section_or_item, sender=Section) post_save.connect(reset_by_upgrade_variant_or_choice_set, sender=Upgrade) post_save.connect(reset_by_upgrade_variant_or_choice_set, sender=Variant) post_save.connect(reset_by_upgrade_variant_or_choice_set, sender=SideDishGroup) post_save.connect(reset_by_choice, sender=SideDish) pre_delete.connect(reset_by_section_or_item, sender=Item) pre_delete.connect(reset_by_section_or_item, sender=Section) pre_delete.connect(reset_by_upgrade_variant_or_choice_set, sender=Upgrade)
# IF THERE WAS A SINGLE USE DISCOUNT, UPDATE IT if order.discount: if order.discount.single_use == True: order.discount.is_active = False order.discount.save() # SEND THE EMAILS if ipn_obj.flag == True: from emailer.views import _payment_flagged _payment_flagged(order) else: from emailer.views import _payment_success _payment_success(order) # NOW CREATE A CUSTOMER PACKAGE from logistics.views import _create_customer_package _create_customer_package(order) payment_was_successful.connect(show_me_the_money) payment_was_flagged.connect(show_me_the_money)
def reset_menu_json(site): KeyChain.menu_json.invalidate(site.id) def reset_by_section_or_item(sender, instance, created=False, **kwargs): reset_menu_json(instance.site) def reset_by_upgrade_variant_or_choice_set(sender, instance, created=False, **kwargs): if instance.item: reset_menu_json(instance.item.site) def reset_by_choice(sender, instance, created=False, **kwargs): if instance.group.item: reset_menu_json(instance.group.item.site) payment_was_successful.connect(register_paypal_payment) payment_was_flagged.connect(register_paypal_payment) post_save.connect(new_site_setup) post_save.connect(item_social_handler, sender=Item) post_save.connect(pdf_caching_handler, sender=Item) post_save.connect(create_defaults, sender=Item) post_save.connect(reset_by_section_or_item, sender=Item) post_save.connect(reset_by_section_or_item, sender=Section) post_save.connect(reset_by_upgrade_variant_or_choice_set, sender=Upgrade) post_save.connect(reset_by_upgrade_variant_or_choice_set, sender=Variant) post_save.connect(reset_by_upgrade_variant_or_choice_set, sender=SideDishGroup) post_save.connect(reset_by_choice, sender=SideDish) pre_delete.connect(reset_by_section_or_item, sender=Item) pre_delete.connect(reset_by_section_or_item, sender=Section) pre_delete.connect(reset_by_upgrade_variant_or_choice_set, sender=Upgrade)
if order.status == Order.STATUS_PAID or order.status == Order.STATUS_PAYMENT_FLAGGED: return # UPDATE THE ORDER DETAILS order.status = Order.STATUS_PAID order.date_paid = ipn_obj.payment_date order.is_paid = True order.save() # IF THERE WAS A SINGLE USE DISCOUNT, UPDATE IT if order.discount: if order.discount.single_use == True: order.discount.is_active = False order.discount.save() # SEND THE EMAILS if ipn_obj.flag == True: from emailer.views import _payment_flagged _payment_flagged(order) else: from emailer.views import _payment_success _payment_success(order) # NOW CREATE A CUSTOMER PACKAGE from logistics.views import _create_customer_package _create_customer_package(order) payment_was_successful.connect(show_me_the_money) payment_was_flagged.connect(show_me_the_money)
if not valid: subject, from_email = 'DA admin - Paypal subscription error', 'Directo al Artista <*****@*****.**>' message = render_to_string('email/paypal_subs_error.html', { 'trans': trans, 'object': ipn_obj.item_name, }) html_content = render_to_string( 'email/global/template.html', { 'email_title': 'DA admin - Paypal subscription error', 'email_content': message, }) html_content = transform(html_content) text_content = strip_tags(html_content) msg = EmailMultiAlternatives(subject, text_content, from_email, ['*****@*****.**']) msg.attach_alternative(html_content, "text/html") msg.send(fail_silently=True) return valid payment_was_successful.connect(payment_success) payment_was_flagged.connect(payment_success_flagged) payment_was_refunded.connect(paypal_refund_payment) subscription_cancel.connect(paypal_subscription_canceled) subscription_signup.connect(paypal_validate_plan_signup) subscription_eot.connect(paypal_subscription_eot)
from registration.models import RegistrationProfile from registration.views import ActivationView def payment_signal(sender, **kwargs): ipn_object = sender #if ipn_object.payment_status == ST_PP_COMPLETED: if payment_status == 'Completed': print "payment_status == ST_PP_COMPLETED" """ Here use django-registration to authenticate the User """ activate_user(activation_key) activation_key = ACTIVATED #ActivationView.activate() else: print str(ipn_object.payment_status) print "error" valid_ipn_received.connect(payment_signal) payment_was_flagged.connect(payment_signal) print "SIGNALS MODULE IMPORTED"
# write the actual message message = "ID: " + str(ipn_obj.id) + "\n" if err_on_success: message += "Error from process_err_ipn_signal: " + err_on_success + "\n" if ipn_obj.flag: message += "Flag info: " + ipn_obj.flag_info + "\n" message += "\n" message += "Response: " + ipn_obj.response + "\n" message += "Transaction Subject: " + ipn_obj.transaction_subject + "\n" message += "Custom: " + ipn_obj.custom + "\n" message += "Quantity: " + str(ipn_obj.quantity) + "\n" message += "Option Name1: " + unicode(ipn_obj.option_name1) + "\n" message += "Payer Status: " + unicode(ipn_obj.payer_status) + "\n" message += "Payment Date: " + unicode(ipn_obj.payment_date) + "\n" message += "Payment Gross: " + unicode(ipn_obj.payment_gross) + "\n" message += "Payment Status: " + unicode(ipn_obj.payment_status) + "\n" message += "Payment Type: " + unicode(ipn_obj.payment_type) + "\n" message += "Name: " + unicode(ipn_obj.first_name) + " " + unicode(ipn_obj.last_name) + "\n" message += "Payer Email: " + unicode(ipn_obj.payer_email) + "\n" message += "Payer ID: " + unicode(ipn_obj.payer_id) + "\n" message += "MC Currency: " + unicode(ipn_obj.mc_currency) + "\n" message += "MC Fee: " + unicode(ipn_obj.mc_fee) + "\n" message += "MC Gross: " + unicode(ipn_obj.mc_gross) + "\n" message += "\n\n\n\n" message += "query: " + unicode(ipn_obj.query) + "\n" send_mail(subject, message, news_settings.NEWS_PAY_ERR_MAIL_FROM, [news_settings.NEWS_PAY_ERR_MAIL_TO]) payment_was_flagged.connect(process_err_ipn_signal)
return POSTBACK_ENDPOINT def get_urls(self): urlpatterns = patterns('', (r'^', include('paypal.standard.ipn.urls')), ) return urlpatterns def form_class(self): if self.encrypted: return PayPalEncryptedPaymentsForm return PayPalPaymentsForm def generate_form(self): return self.form_class()(initial=self.fields) def unsuccessful_txn_handler(sender, **kwargs): transaction_was_unsuccessful.send(sender=sender.__class__, type="purchase", response=sender) def successful_txn_handler(sender, **kwargs): transaction_was_successful.send(sender=sender.__class__, type="purchase", response=sender) payment_was_flagged.connect(unsuccessful_txn_handler) payment_was_successful.connect(successful_txn_handler)
if self.engine == "paypal": return self.project.paymentgatewayselector.paypal_gateway.notification_email elif self.engine == "ideal": return self.project.paymentgatewayselector.mollie_gateway.notification_email @property def donation_fee(self): return (self.amount - self.amount_received) def __unicode__(self): return u'Invoice %(invoice_id)s (Project: %(project_name)s)' % { 'invoice_id': self.id, 'project_name': self.project } class Meta: app_label = 'rsr' verbose_name = u'invoice' ordering = ['-id', ] # PayPal IPN listener def process_paypal_ipn(sender, **kwargs): ipn = sender if ipn.payment_status == 'Completed': invoice = Invoice.objects.get(pk=int(ipn.invoice)) invoice.amount_received = invoice.amount - ipn.mc_fee invoice.ipn = ipn.txn_id invoice.status = 3 invoice.save() payment_was_flagged.connect(process_paypal_ipn)
def payment_flagged(sender, **kwargs): ipn_obj = sender order = get_object_or_404(Order, invoice_id=ipn_obj.invoice) order.status = Order.STATUS_PAYMENT_FLAGGED order.save() # create and send an email to me invoice_id = order.invoice_id email = order.owner.email recipient = '*****@*****.**' body = render_to_string('shop/emails/order_confirm_admin.txt', {'email': email, 'invoice_id': invoice_id, 'order_items': order.items.all()}) subject_line = "FLAGGED ORDER - %s" % invoice_id email_sender = '*****@*****.**' send_mail( subject_line, body, email_sender, [recipient], fail_silently=False ) payment_was_flagged.connect(payment_flagged)
mail_managers( "Book sold", "Book copy with id: %d has sold.\n IPN id: %d" % (book_copy.id, ipn_obj.id)) payment_was_successful.connect(book_copy_just_sold) def book_copy_sale_flagged(sender, **kwargs): ipn_obj = sender mail_managers( "Book payment flagged.", "A book payment has been flagged.\n IPN id: %d." % ipn_obj.id) payment_was_flagged.connect(book_copy_sale_flagged) class Author(models.Model): name = models.CharField(max_length=100) def __unicode__(self): return self.name class Subject(MPTTModel): name = models.CharField(max_length=50) bnid = models.CharField(max_length=50, blank=True) hidden = models.BooleanField(default=False) parent = models.ForeignKey('self', null=True,