def testConnectPaypalSignalReceiver(self):
payment_was_successful.connect(show_me_the_money)
class ipn_obj:
custom = 'atyala'
payment_was_successful.send(sender=ipn_obj, message="Hello", level=1, object=self)
def __init__(self, shop):
self.shop = shop
# Hook the payment was successful listener on the appropriate signal sent
# by django-paypal (success_signal)
success_signal.connect(self.payment_was_successful, weak=False)
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"
def my_ipn(request):
try:
send_mail('my_ipn', 'in my_ipn', '*****@*****.**', ['*****@*****.**'], fail_silently=False)
toReturn = ipn.views.ipn(request)
payment_was_successful.connect(confirm_payment)
return toReturn
except Exception as e:
send_mail('my_ipn', str(e), '*****@*****.**', ['*****@*****.**'], fail_silently=False)
return HttpResponse('OKAY')
def testConnectingSignals(self):
payment_was_successful.connect(SimpleReceiver)
self.assertFalse(self._signalReceived)
payment_was_successful.send(sender="Sender", message="Hello", level=1, object=self)
self.assertTrue(self._signalReceived)
# test disconnect signal
self._signalReceived = False
payment_was_successful.disconnect(SimpleReceiver)
payment_was_successful.send(sender="Sender", message="Hello", level=1, object=self)
self.assertFalse(self._signalReceived)
def __init__(self, shop):
self.shop = shop
# Hook the payment was successful listener on the appropriate signal
# sent by django-paypal (success_signal)
unique_key = 'django-shop-paypal_offsite_payment-successful'
success_signal.connect(self.payment_was_successful, weak=False,
dispatch_uid=unique_key)
assert settings.PAYPAL_RECEIVER_EMAIL, "You need to define " \
"PAYPAL_RECEIVER_EMAIL in " \
"settings with the " \
"recipient's email addresss"
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 donation_successful(sender, **kwargs):
"""
@param sender: PayPalStandardBase
@param kwargs:
"""
ipn_obj = sender
# Undertake some action depending upon `ipn_obj`.
username = ipn_obj.custom or ipn_obj.item_name.replace("Donazione da parte di: ", '')
d, created = Donation.objects.get_or_create(from_email=ipn_obj.payer_email,
from_username=username,
amount=ipn_obj.auth_amount,
memo=ipn_obj.memo)
d.status=ipn_obj.auth_status
d.save()
payment_was_successful.connect(donation_successful)
def ready(self):
from paypal.standard.ipn.signals import payment_was_successful
payment_was_successful.connect(signals.payment_received, dispatch_uid='shop.payment_received')
# 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)
body=email_body,
from_email='*****@*****.**',
to=[user.email],
bcc=['*****@*****.**'])
mail.attach_alternative(email_body_html, 'text/html')
mail.send()
# Signal handler
def verify_and_process_payment(sender, **kwargs):
ipn_obj = sender
invoice = ipn_obj.invoice
acknowledge_payment_received(invoice)
payment_was_successful.connect(verify_and_process_payment)
@user_passes_test(logged_in_and_active)
@user_passes_test(is_service_available, login_url='/comebacksoon/')
def submit(request):
def render_page(request,
order,
selectdiscountform=None,
claimdiscountform=None,
dropforms=None):
context = {}
if float(
order.get_full_price()
) < 0.01: # Free service. Don't show discount forms. Clear coupons so they are not wasted.
context['show_discounts'] = False
except User.DoesNotExist:
ipn_obj.set_flag("Payment attempted for user who does not exist: %s" % user_id)
try:
ct = ContentType.objects.get(app_label=app_label, model=model)
except ContentType.DoesNotExist:
ipn_obj.set_flag("Payment attempted for content type which does not exist: %s.%s" % (app_label, model))
else:
try:
obj = ct.get_object_for_this_type(id=object_id)
except ct.model_class().DoesNotExist:
ipn_obj.set_flag("Payment attempted for %s with id %s which does not exist." % (ct.model_class().__name__, object_id))
# Should this process even if the ipn is flagged?
if not ipn_obj.flag:
payment = Payment(
payment_for = obj,
user = user,
paid = ipn_obj.mc_gross,
payment_method = 'online',
payment_made = datetime.datetime.now(),
ipn = ipn_obj
)
payment.save()
else:
ipn_obj.save()
else:
ipn_obj.set_flag("Security data does not match passthrough variables.")
ipn_obj.save()
payment_was_successful.connect(process_payment)
ipn_obj = sender
# logging.debug(ipn_obj.mc_gross)
amt = float(ipn_obj.mc_gross)
if amt == 10.0:
credit_amt = 10.0
elif amt == 25.0:
credit_amt = 27.0
elif amt == 50.0:
credit_amt = 55.0
elif amt == 100.0:
credit_amt = 115.0
elif amt == 500.0:
credit_amt = 600.0
elif amt == 1.0:
credit_amt = 28.0
company = Company.objects.get(slug=ipn_obj.custom)
new_credit = InvoiceHistory(company=company, credit_added=credit_amt)
new_credit.save()
# Actuall add credit to company
credit_obj = Credit.objects.get(company=company)
credit_obj.credit_left = credit_obj.credit_left + float(credit_amt)
credit_obj.save()
payment_was_successful.connect(notify_credit)
return
test_ipn = getattr(settings, 'PAYPAL_TEST', False)
if ipn_obj.test_ipn != test_ipn:
# per Asheesh, make sure that the test_ipn setting matches the PAYPAL_TEST setting
return
tier_info = TierInfo.objects.get_current()
current_tier_obj = SiteLocation.objects.get_current().get_tier()
if float(ipn_obj.payment_gross) != current_tier_obj.dollar_cost():
raise ValueError(
"User paid %f instead of %f" %
(ipn_obj.payment_gross, current_tier_obj.dollar_cost()))
subscription_start = PayPalIPN.objects.filter(
subscr_id=ipn_obj.subscr_id, flag=False,
test_ipn=test_ipn).exclude(period1="").order_by('-id')[0]
num, format = subscription_start.period1.split(' ', 1)
num = int(num)
if format.upper() != 'D':
raise ValueError('invalid repeat period: %r' %
subscription_start.period1)
tier_info.payment_due_date += datetime.timedelta(days=num)
tier_info.save()
payment_was_successful.connect(handle_successful_payment)
.order_by('-price')
def vat_value(self):
return self.price - self.net_price()
def net_price(self):
return self.price / (1 + self.vat.value / 100)
if 'paypal.standard.ipn' in dsettings.INSTALLED_APPS:
from paypal.standard.ipn.signals import payment_was_successful as paypal_payment_was_successful
def confirm_order(sender, **kwargs):
ipn_obj = sender
o = Order.objects.get(code=ipn_obj.custom)
o.confirm_order(ipn_obj.payment_date)
paypal_payment_was_successful.connect(confirm_order)
class CreditNote(models.Model):
invoice = models.ForeignKey(Invoice, related_name='credit_notes')
code = models.CharField(max_length=20, unique=True)
assopy_id = models.CharField(max_length=22, null=True)
emit_date = models.DateField()
price = models.DecimalField(max_digits=6, decimal_places=2)
def __unicode__(self):
return ' #%s' % self.code
def note_items(self):
return self.refund.items.all()\
.values('code','description') \
.annotate(price=models.Sum('price'), count=models.Count('price')) \
"charset": "utf-8",
}
paypal_form = PayPalPaymentsForm(initial=paypal_dict)
submit_js = "<script>document.forms['paypalsubmit'].submit()</script>"
return render(request, 'usercenter/checkout.html', {
'content': paypal_form.render(),
'submit_js': submit_js
})
# 支付成功的回调函数
def do_business(sender, **kwargs):
baseutil.well_print('ipn received')
ipn_obj = sender
out_trade_no = ipn_obj.invoice # 本站订单号
total_fee = ipn_obj.mc_gross
trade = get_object_or_404(Transaction, out_trade_no=out_trade_no)
# send mail to admin
mail_content = u"Bluessh有新用户付款成功，用户名为 %s, 付款金额为 $%s"\
% (trade.user.username,total_fee)
mail_admins(u"Bluessh有新用户付款成功", mail_content, fail_silently=True)
#创建账单对应的ssh帐号，并保存到UserProduct
baseutil.well_print("username:%s, total_fee:%s" %
(trade.user.username, total_fee))
create_ssh_user(trade)
# connect signal
payment_was_successful.connect(do_business)
end_at = datetime.now() + timedelta(days=365)
if time_units == 'M':
end_at = datetime.now() + timedelta(days=30)
if Plan.objects.filter(txn_id=ipn_obj.txn_id).count() == 0:
plan = Plan(user=user,
type=plan_type,
end_at=end_at,
payed=True,
status='active',
txn_id=ipn_obj.txn_id)
plan.save()
plan.notify_user_of_payment()
profile = helpers.get_profile_for_user_id(user_id)
if profile:
package = helpers.create_push_package_for_profile(profile)
else: # there already is a plan for this transaction. Ignore.
pass
else:
#send email to MANAGERS
emails = [person[1] for person in settings.MANAGERS]
subject = 'A payment failed: payment id ' + str(ipn_obj.id)
message = 'Check it out in the admin'
send_mail(subject,
message,
settings.EMAIL_HOST_USER,
emails,
fail_silently=False)
payment_was_successful.connect(mark_payment)
# Zoook. OpenERP e-sale, e-commerce Open Source Management Solution
# Copyright (C) 2011 Zikzakmedia S.L. (<http://www.zikzakmedia.com>). All Rights Reserved
# $Id$
#
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU Affero General Public License as
# published by the Free Software Foundation, either version 3 of the
# License, or (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU Affero General Public License for more details.
#
# You should have received a copy of the GNU Affero General Public License
# along with this program. If not, see <http://www.gnu.org/licenses/>.
#
############################################################################################
from django.db import models
from paypal.standard.ipn.signals import payment_was_successful
#signals
def paypal_confirm(sender, **kwargs):
pass
payment_was_successful.connect(paypal_confirm)
import logging
from paypal.standard.ipn.signals import payment_was_successful
from wallet.models import Invoice
def wallet_deposit(sender, **kwargs):
logger = logging.getLogger('wallet')
logger.debug('PayPal Signal Handler')
invoice_id = sender.invoice
invoice_id = int(invoice_id)
logger.debug('Invoice ID: %d' % invoice_id)
invoice = Invoice.objects.get(id=invoice_id)
logger.debug('Invoice: %s' % invoice)
wallet = invoice.user.wallets.all()[0]
logger.debug('Wallet: %s' % wallet)
invoice.transaction = wallet.deposit(invoice.option.wallet_amount)
invoice.save()
logger.debug('PayPal IPN Complete')
payment_was_successful.connect(wallet_deposit)
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
from datetime import datetime, timedelta
from django.utils.timezone import utc
from django.conf import settings
# signals
from paypal.standard.ipn.signals import payment_was_successful
def validPayment(sender, **kwargs):
#user = Users.objects.get(email=sender.invoice)
print 'youhou'
payment_was_successful.connect(validPayment)
class SlotBooked(models.Model):
user = models.ForeignKey(User, unique=True)
slot = models.ForeignKey(Slot, unique=True)
dateBooked = models.DateTimeField('Date Booked')
datePaid = models.DateTimeField('Date Paid', null=True, blank=True)
def __unicode__(self):
return unicode(self.slot)
def isPaid(self):
if self.datePaid is None:
return False
else:
pass
else:
variation.update_stock(item.quantity * -1)
variation.product.actions.purchased()
code = session.get('discount_code')
if code:
DiscountCode.objects.active().filter(code=code) \
.update(uses_remaining=F('uses_remaining') - 1)
cart.delete()
except Order.DoesNotExist:
pass
except Cart.DoesNotExist:
pass
payment_was_successful.connect(payment_complete)
class HomePage(Page, RichText):
'''
A page representing the format of the home page
'''
content_heading = models.CharField(max_length=200,
default="About us!")
featured_portfolio = models.ForeignKey("Portfolio", blank=True, null=True,
help_text="If selected items from this portfolio will be featured "
"on the home page.")
class Meta:
from django.db import models
from django.contrib.auth import get_user_model
# Register Signals
from paypal.standard.ipn.signals import payment_was_successful
from orders import signals
payment_was_successful.connect(signals.order_paid, dispatch_uid="paypal_payment_success")
class Supplier(models.Model):
name = models.CharField(max_length=255)
def __str__(self):
return self.name
class _UnitSizeSack(object):
name = "sack"
description = "Sack (25Kg)"
def plural(self, quantity):
unit_size = self.name
if quantity is not 1:
unit_size = self.name + "s"
return "%d %s" % (quantity, unit_size)
class _UnitSizeKg(object):
name = "Kg"
description = "1 Kg"
from django.db import models
#from paypal.pro.signals import payment_was_successful
from paypal.standard.ipn.signals import payment_was_successful
def show_me_the_money(sender, **kwargs):
ipn_obj = sender
# Undertake some action depending upon `ipn_obj`.
print "TODO OK !"
payment_was_successful.connect(show_me_the_money ,dispatch_uid="somethjjing-rational-here")
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)
# for item in items:
# total += item.amount
return render_to_response(template_name,{
"form":form,
"PAYPAL_URL": settings.PAYPAL_URL,
"total": total,
},context_instance=RequestContext(request))
else:
print "An user is not registered"
from paypal.standard.ipn.signals import payment_was_successful
def my_payment_was_successful_handler(sender, **kwargs):
print 'successful payment'
payment_was_successful.connect(my_payment_was_successful_handler)
def payment_successful(request):
'''
handles the "IPN" from paypal. That is, when there is a successful paypal
transaction, paypal calls this url with some info. The most important
value here is POST['custom'], which is a comma seperated list of CartItem
ids (ending in ,) that have been paid for.
sends a list of cart_items to cart.signals.pp_ipn
'''
logging.debug('handling paypal IPN:')
if request.method == 'POST':
logging.debug('is post')
itemids = request.POST['custom'].split(',')
logging.debug('itemids:')
logging.debug(itemids)
self.object_pk = obj.pk
self.content_type = ContentType.objects.get_for_model(obj).natural_key()
super(Custom, self).__init__()
def get_object(self):
return ContentType.objects.get_by_natural_key(*self.content_type).get_object_for_this_type(pk=self.object_pk)
def get_user(self):
queryset = User.objects.filter(id=self.user_id)
return queryset.get() if queryset else None
def serialize(self):
pickled = pickle.dumps(self, pickle.HIGHEST_PROTOCOL)
return base64.urlsafe_b64encode(pickled).decode("utf-8")
@staticmethod
def deserialize(serialized):
b64 = base64.urlsafe_b64decode(serialized.encode("utf-8"))
return pickle.loads(b64)
# Handle PayPal signals
def handle_payment_was_successful(sender, **kwargs):
"""Extends object and user objects from PayPal IPN receipt and sends a paid signal"""
custom = Custom.deserialize(sender.custom)
obj = custom.get_object()
paid.send(type(obj), user=custom.get_user(), obj = obj, receipt=sender)
payment_was_successful.connect(handle_payment_was_successful)
user = models.OneToOneField(UserSocialAuth)
message = models.CharField(max_length=1000)
link = models.CharField(max_length=100)
def __unicode__(self):
return self.message
class Meta:
verbose_name_plural = "Facebook Messages"
class TwitterPostMessage(models.Model):
user = models.OneToOneField(UserSocialAuth)
tweet = models.CharField(max_length=140)
def __unicode__(self):
return self.tweet
class Meta:
verbose_name_plural = "Twitter Tweets"
def paypal_ipn_return(sender, **kwargs):
import logging
log = logging.getLogger(__name__)
log.debug(">>>>>>>>>>>>>>>>>>IPN RETURNED " + str(kwargs))
payment_was_successful.connect(paypal_ipn_return)
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)
order=order)
transaction.ipn.add(ipn_obj)
transaction.save()
else:
logger.warning(
"PayPal: unsuccessful ipn payment, no order found for uuid %s"
% ipn_obj.custom)
else:
logger.warning(
"PayPal: unsuccessful ipn payment signal with no ipn object")
def successful_pdt(sender, **kwargs):
logger.info("PayPal: successful pdt payment")
pdt_obj = sender
mark_payment(pdt_obj, True)
def unsuccesful_pdt(sender, **kwargs):
logger.info("PayPal: unsuccessful pdt payment")
pdt_obj = sender
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")
@receiver(models.signals.post_save,sender=RaffleEntry) def raffleEntrySaved(sender, instance, **kwargs): instance.user.profile.tickets = -sum(foo.tickets for foo in instance.user.entries.all()) instance.user.profile.save() instance.raffle.tickets = sum(foo.tickets for foo in instance.raffle.entries.all()) instance.raffle.save() @receiver(models.signals.pre_save,sender=UserProfile) def userProfileSaving(sender, instance, **kwargs): instance.tickets = -sum(foo.tickets for foo in instance.user.entries.all()) instance.points = -sum(foo.points for foo in instance.user.transactions.all()) @receiver(models.signals.post_save,sender=PointTransaction) def pointTransactionSaved(sender, instance, **kwargs): instance.user.profile.points = -sum(foo.points for foo in instance.user.transactions.all()) instance.user.profile.save() instance.game.points = sum(foo.points for foo in instance.game.transactions.all()) instance.game.save() def paypal_payment_was_successful(sender, **kwargs): ipn_obj = sender ipn_hash = ipn_obj.custom.strip() donation = get_object_or_404(Donation, ipn_hash=ipn_hash) donation.approved = True donation.save() payment_was_successful.connect(paypal_payment_was_successful)
"""
return self.price_in_local_currency - self.vat_in_local_currency
@property
def price_in_local_currency(self):
return normalize_price(self.price * self.exchange_rate)
if 'paypal.standard.ipn' in dsettings.INSTALLED_APPS:
from paypal.standard.ipn.signals import payment_was_successful as paypal_payment_was_successful
def confirm_order(sender, **kwargs):
ipn_obj = sender
o = Order.objects.get(code=ipn_obj.custom)
o.confirm_order(ipn_obj.payment_date)
paypal_payment_was_successful.connect(confirm_order)
class CreditNote(models.Model):
invoice = models.ForeignKey(Invoice, related_name='credit_notes')
code = models.CharField(max_length=20, unique=True)
assopy_id = models.CharField(max_length=22, null=True)
emit_date = models.DateField()
price = models.DecimalField(max_digits=6, decimal_places=2)
def __unicode__(self):
return ' #%s' % self.code
def note_items(self):
return self.refund.items.all()\
.values('code','description') \
.annotate(price=models.Sum('price'), count=models.Count('price')) \
from django.http import QueryDict def receive_point_buy(sender, **kwargs): # FIXME: handle errors? ipn = sender if ipn.item_number == ITEM_PREFIX: query = QueryDict(ipn.query) quantity = int(query['option_selection1']) for units, price in PREPAID_UNIT_PACKS: if quantity == units: if ipn.mc_gross == Decimal(price): user = auth.models.User.objects.get(username=ipn.custom) UnitPack.credit(user, quantity, reason=RECHARGE_TEXT) break payment_was_successful.connect(receive_point_buy) class ValidUnitPackManager(models.Manager): def get_query_set(self): return super(ValidUnitPackManager, self).get_query_set().filter( expires__gt=datetime.date.today(), quantity__gt=0) def _default_expires(): if hasattr(settings,'PREPAID_DEFAULT_EXPIRY_PERIOD'): return datetime.date.today() + datetime.timedelta( settings.PREPAID_DEFAULT_EXPIRY_PERIOD) class UnitPack(models.Model): # Normally we only deal with not expired and not empty unit packs, # but sometimes we need to peek into expired. all_objects = models.Manager()
from django.contrib.auth.models import User
from room.models import Slot
from datetime import datetime, timedelta
from django.utils.timezone import utc
from django.conf import settings
# signals
from paypal.standard.ipn.signals import payment_was_successful
def validPayment(sender, **kwargs):
#user = Users.objects.get(email=sender.invoice)
print 'youhou'
payment_was_successful.connect(validPayment)
class SlotBooked(models.Model):
user = models.ForeignKey(User, unique=True)
slot = models.ForeignKey(Slot, unique=True)
dateBooked = models.DateTimeField('Date Booked')
datePaid = models.DateTimeField('Date Paid', null=True, blank=True)
def __unicode__(self):
return unicode(self.slot)
def isPaid(self):
if self.datePaid is None:
return False
else:
return True
def show_me_the_money(sender, **kwargs):
ipn_obj = sender
#Undertake some action depending upon `ipn_obj`.
if ipn_obj.custom == "Upgrade all users!":
UsersInfo.objects.update(paid=True)
payment_was_successful.connect(show_me_the_money)
############################################################################################
#
# Zoook. OpenERP e-sale, e-commerce Open Source Management Solution
# Copyright (C) 2011 Zikzakmedia S.L. (<http://www.zikzakmedia.com>). All Rights Reserved
# $Id$
#
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU Affero General Public License as
# published by the Free Software Foundation, either version 3 of the
# License, or (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU Affero General Public License for more details.
#
# You should have received a copy of the GNU Affero General Public License
# along with this program. If not, see <http://www.gnu.org/licenses/>.
#
############################################################################################
from django.db import models
from paypal.standard.ipn.signals import payment_was_successful
#signals
def paypal_confirm(sender, **kwargs):
pass
payment_was_successful.connect(paypal_confirm)
for foo in instance.raffle.entries.all())
instance.raffle.save()
@receiver(models.signals.pre_save, sender=UserProfile)
def userProfileSaving(sender, instance, **kwargs):
instance.tickets = -sum(foo.tickets for foo in instance.user.entries.all())
instance.points = -sum(foo.points
for foo in instance.user.transactions.all())
@receiver(models.signals.post_save, sender=PointTransaction)
def pointTransactionSaved(sender, instance, **kwargs):
instance.user.profile.points = -sum(
foo.points for foo in instance.user.transactions.all())
instance.user.profile.save()
instance.game.points = sum(foo.points
for foo in instance.game.transactions.all())
instance.game.save()
def paypal_payment_was_successful(sender, **kwargs):
ipn_obj = sender
ipn_hash = ipn_obj.custom.strip()
donation = get_object_or_404(Donation, ipn_hash=ipn_hash)
donation.approved = True
donation.save()
payment_was_successful.connect(paypal_payment_was_successful)
null=True,
blank=True)
id_pago = models.CharField(max_length=100, blank=True, null=True)
fecha = models.DateTimeField(auto_now_add=True, db_index=True)
metodo_pago = models.ForeignKey(MetodoPago, blank=True, null=True)
descripcion = models.CharField(max_length=100, blank=True, null=True)
transaccion = models.CharField(max_length=100, blank=True, null=True)
def __unicode__(self):
return self.id_pago
from paypal.standard.models import ST_PP_COMPLETED
from paypal.standard.ipn.signals import valid_ipn_received, payment_was_successful
def show_me_the_money(sender, **kwargs):
ipn_obj = sender
if ipn_obj.payment_status == ST_PP_COMPLETED:
if ipn_obj.custom == "Comprando los mejores productos!":
pago = Pago(cantidad=ipn_obj.mc_gross,
descripcion=ipn_obj.payment_status,
transaccion=ipn_obj.txn_id)
pago.save()
else:
print 'Salio Mal'
valid_ipn_received.connect(show_me_the_money)
payment_was_successful.connect(show_me_the_money)
from django.db import models
from django.conf import settings
from django.utils import timezone
# Create your models here.
class Magazine(models.Model):
name = models.CharField(max_length=254, default="")
description = models.TextField()
price = models.DecimalField(max_digits=6, decimal_places=2)
def __unicode__(self):
return self.name
class Purchase(models.Model):
user = models.ForeignKey(settings.AUTH_USER_MODEL,
related_name="purchases")
magazine = models.ForeignKey(Magazine)
subscription_end = models.DateTimeField(default=timezone.now)
from signals import subscription_created, subscription_was_cancelled, subscription_extended
from paypal.standard.ipn.signals import valid_ipn_received, payment_was_successful
valid_ipn_received.connect(subscription_created)
valid_ipn_received.connect(subscription_was_cancelled)
payment_was_successful.connect(subscription_extended)
token.save()
# ShoppingToken.objects.filter(payed=False).exclude(date__gte=(datetime.now() - timedelta(days=1)).date()).delete()
form = PayPalPaymentsForm(
initial={
'business': settings.PAYPAL_RECEIVER_EMAIL,
'amount': '2.00',
'item_name': 'All themes for IDEA',
'invoice': token.value,
'notify_url': ROOT_URL + reverse('paypal-ipn'),
'return_url': ROOT_URL + '/themes/download-all/',
'cancel_return': ROOT_URL + '/themes/download-all/',
})
request.session['shopping_token'] = token.value
return render(request, 'themes/download-all.html', {'form': form})
def payment_successful_handler(sender, **kwargs):
if sender.payment_status == "Completed":
try:
token = ShoppingToken.objects.get(value=sender.invoice)
token.payed = True
token.save()
except ObjectDoesNotExist:
pass
payment_was_successful.connect(payment_successful_handler)
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)
# someone's account.
points = ipn_obj.mc_gross * 100
if points <= 0 or points != int(points) or not points.is_finite():
kwargs['err_on_success'] = \
"comment points are less than 0, or there are some decimal points."
return process_err_ipn_signal(sender, **kwargs)
userprofile.comment_points += int(points)
userprofile.save()
import sys
print >>sys.stderr, "Received payment, for " + str(ipn_obj.mc_gross) + \
" from " + unicode(ipn_obj.custom)
payment_was_successful.connect(process_successful_ipn_signal)
def process_err_ipn_signal(sender, **kwargs):
"""
Process an error in a Paypal payment.
Send an email with error reporting stuff.
"""
ipn_obj = sender
import sys
print >>sys.stderr, "Payment error, ipn id " + str(ipn_obj.id)
# if err_on_success is in kwargs, that means the payment was otherwise
# successful, but there was an error in the things process_successful_ipn_signal
"invoice": out_trade_no, # 本站订单号
"notify_url": "%s%s" % (settings.SITE_URL, '/paypal/ipn_pengzhao/'),
"return_url": "%s/usercenter/" % settings.SITE_URL,
"currency_code":"USD", # 人民币CNY，美元USD
"charset":"utf-8",
}
paypal_form = PayPalPaymentsForm(initial=paypal_dict)
submit_js = "<script>document.forms['paypalsubmit'].submit()</script>"
return render(request,'usercenter/checkout.html',
{'content':paypal_form.render(),'submit_js':submit_js})
# 支付成功的回调函数
def do_business(sender, **kwargs):
baseutil.well_print('ipn received')
ipn_obj = sender
out_trade_no = ipn_obj.invoice # 本站订单号
total_fee = ipn_obj.mc_gross
trade = get_object_or_404(Transaction,out_trade_no=out_trade_no)
# send mail to admin
mail_content = u"Bluessh有新用户付款成功，用户名为 %s, 付款金额为 $%s"\
% (trade.user.username,total_fee)
mail_admins(u"Bluessh有新用户付款成功",
mail_content,
fail_silently=True)
#创建账单对应的ssh帐号，并保存到UserProduct
baseutil.well_print("username:%s, total_fee:%s" % (trade.user.username,total_fee))
create_ssh_user(trade)
# connect signal
payment_was_successful.connect(do_business)
salt = sha.new(str(random.random())).hexdigest()[:5]
confirmation_key = sha.new(salt+user.email).hexdigest()
return confirmation_key
def get_confirmation_key_expiration():
key_expires = datetime.datetime.utcnow().replace(tzinfo=timezone.utc) + datetime.timedelta(7)
return key_expires
# Signal handler
def verify_and_process_payment(sender, **kwargs):
ipn_obj = sender
invoice = ipn_obj.invoice
acknowledge_payment_received(invoice)
payment_was_successful.connect(verify_and_process_payment)
def acknowledge_payment_received(invoice):
try:
order = models.ManuscriptOrder.objects.get(invoice_id=invoice)
except models.ManuscriptOrder.DoesNotExist:
raise Exception('Invalid invoice id #%s' % invoice)
order.is_payment_complete = True
order.order_received_now()
order.save()
user = order.customer
email_subject = _('Thank you! Your order to Science Writing Experts is complete')
t = loader.get_template('payment_received.txt')
t_html = loader.get_template('payment_received.html')
c = Context(
from paypal.standard.models import ST_PP_COMPLETED
from django.contrib.auth.models import User
import donomo.billing.models
import os
import logging
logging = logging.getLogger(os.path.splitext(os.path.basename(__file__))[0])
def on_payment_successful(sender, **kwargs):
logging.info('payment complete : %s status=%s' %
(kwargs, sender.payment_status))
invoice = donomo.billing.models.Invoice.objects.get(pk=sender.invoice)
account = donomo.billing.models.Account.objects.get_or_create(
owner=invoice.owner, defaults={'balance': 0})[0]
if sender.payment_status == ST_PP_COMPLETED:
# TODO pass purchase plan code via the payment object instead of
# having refill_account figure it out based on the gross amount
donomo.billing.models.refill_account(account, float(sender.mc_gross))
payment_was_successful.connect(on_payment_successful)
def on_payment_flagged(sender, **kwargs):
logging.info('payment flagged : %s flag=%s, payment_status=%s' %
(kwargs, sender.flag, sender.payment_status))
payment_was_flagged.connect(on_payment_flagged)
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)
}
@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)
""" Information about service delivery """
name = models.CharField(max_length=50)
price = models.DecimalField(max_digits=5,
decimal_places=2)
time = models.TimeField()
def get_service_for_user(self):
return self.objects.all()
class State(models.Model):
name = models.CharField(max_length=50)
def __unicode__(self):
return "".join(self.name)
def paypall_success(sender, **kwargs):
new_hash = Order.generate_hash(sender.item_number, sender.mc_gross)
try:
order = Order.objects.get(id=sender.item_number)
old_hash = Order.generate_hash(order.id, order.get_total_price_with_shiping())
if old_hash == new_hash:
order.confirm()
else:
print 'error'
except Order.DoesNotExist:
pass
payment_was_successful.connect(paypall_success)
#logging.debug(ipn_obj.mc_gross)
amt = float(ipn_obj.mc_gross)
if amt == 10.0:
credit_amt = 10.0
elif amt == 25.0:
credit_amt = 27.0
elif amt == 50.0:
credit_amt = 55.0
elif amt == 100.0:
credit_amt = 115.0
elif amt == 500.0:
credit_amt = 600.0
elif amt == 1.0:
credit_amt = 28.0
company = Company.objects.get(slug=ipn_obj.custom)
new_credit = InvoiceHistory(company=company,
credit_added=credit_amt,
)
new_credit.save()
# Actuall add credit to company
credit_obj = Credit.objects.get(company=company)
credit_obj.credit_left = credit_obj.credit_left + float(credit_amt)
credit_obj.save()
payment_was_successful.connect(notify_credit)
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")
from paypal.standard.ipn.signals import payment_was_successful, payment_was_flagged
from paypal.standard.models import ST_PP_COMPLETED
from django.contrib.auth.models import User
import donomo.billing.models
import os
import logging
logging = logging.getLogger(os.path.splitext(os.path.basename(__file__))[0])
def on_payment_successful(sender, **kwargs):
logging.info('payment complete : %s status=%s' % (kwargs, sender.payment_status))
invoice = donomo.billing.models.Invoice.objects.get(pk = sender.invoice)
account = donomo.billing.models.Account.objects.get_or_create(owner = invoice.owner, defaults={'balance' : 0})[0]
if sender.payment_status == ST_PP_COMPLETED:
# TODO pass purchase plan code via the payment object instead of
# having refill_account figure it out based on the gross amount
donomo.billing.models.refill_account(account, float(sender.mc_gross))
payment_was_successful.connect(on_payment_successful)
def on_payment_flagged(sender, **kwargs):
logging.info('payment flagged : %s flag=%s, payment_status=%s' % (kwargs, sender.flag, sender.payment_status))
payment_was_flagged.connect(on_payment_flagged)
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)
(profile, created) = UserProfile.objects.get_or_create(paypal_id=ipn_obj.payer_id)
profile.paypal_email = ipn_obj.payer_email
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")
from paypal.standard.ipn.signals import payment_was_successful
import logging
def show_me_the_money(sender, **kwargs):
log = logging.getLogger("dev.ttagit.logger")
log.debug("SIGNAL!!!!!---Successful Payment")
payment_was_successful.connect(show_me_the_money)
ipn_obj = sender
# Undertake some action depending upon `ipn_obj`.
try:
book_copy = Book_Copy.objects.get(pk=ipn_obj.custom)
book_copy.sold = True
book_copy.save()
except Book_Copy.DoesNotExist:
pass
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)
