def _two_checkout_payment(request):
pst = request.POST
order_id = pst.get('vendor_order_id')
if not order_id:
return
try:
order = Task.objects.all().filter(id=order_id)
except (TypeError, ValueError):
# order_id is not an integer
return
order = order and order[0]
if order:
vals = {
'sale_id': request.POST.get('sale_id'),
'customer_ip': request.POST.get('customer_ip'),
'amount': request.POST.get('invoice_usd_amount')
}
order.status = co.UNPROCESSED
order.save()
payment = Payment(powner=order.owner,
ptask=order,
values=json.dumps(vals),
payment_status=co.IN_PROCESS,
payment_type=co.TWOCHECKOUT)
payment.save()
def test_seat_with_0_amount_paid(self, appointment):
ser = s.AppointmentSerializer()
seat = Seat(appointment=appointment, birth_date=timezone.now())
seat.save()
payment = Payment(amount=0, seat=seat, paid_at=timezone.now())
payment.save()
assert ser.get_all_seats_paid(appointment) is True
def test_is_frozen_if_paid_internally(self):
order = Order(**self.data)
order.is_paid = True
order.save()
payment_method = PaymentMethod(name='Internal Test', is_internal=True)
payment_method.save()
pref = PaymentPreference(payment_method=payment_method,
user=order.user,
identifier='InternalTestIdentifier')
pref.save()
payment = Payment(payment_preference=pref,
amount_cash=order.amount_cash,
order=order,
user=order.user,
currency=order.currency)
payment.save()
order = Order.objects.last()
# it's paid
self.assertTrue(order.is_paid)
# therefore it's frozen
self.assertTrue(order.payment_status_frozen)
# even though deadline is in the future
self.assertTrue(order.payment_deadline >= timezone.now())
def test_can_set_as_paid_if_has_withdraw_address_internal(self):
# Creates an withdraw address fro this user
address = Address(user=self.user,
type='W',
address='17NdbrSGoUotzeGCcMMCqnFkEvLymoou9j')
address.save()
payment_method = PaymentMethod(name='Internal Test', is_internal=True)
payment_method.save()
pref = PaymentPreference(payment_method=payment_method,
user=self.order.user,
identifier='InternalTestIdentifier')
pref.save()
payment = Payment(payment_preference=pref,
amount_cash=self.order.amount_cash,
order=self.order,
currency=self.RUB,
user=self.order.user)
payment.save()
# Creates an Transaction for the Order, using the user Address
transaction = Transaction(order=self.order,
address_to=address,
address_from=address)
transaction.save()
# Set Order as Paid
response = self.client.post(self.url, {'paid': 'true'})
expected = {"frozen": True, "paid": True, "status": "OK"}
self.assertJSONEqual(
json.dumps(expected),
str(response.content, encoding='utf8'),
)
def save_payments_list_view(a_request, username):
if a_request.method != 'POST':
return HttpResponseNotFound('<h1>No Page Here</h1>')
csv_data = a_request.POST.get('csv_text')
# assert False
# stripped_csv_data = (item.strip() for item in csv_data.split())
payments = PaymentCsvModel.import_data(csv_data.split('\r\n'))
for csv_model in payments:
corporation = Corporation.objects.get(cid=csv_model.corporation)
assert corporation != None
p = Payment(
corporation=corporation,
owner=a_request.user,
amount=csv_model.amount,
title=csv_model.title,
due_date=csv_model.due_date,
supply_date=csv_model.supply_date,
order_date=csv_model.order_date,
pay_date=csv_model.pay_date
)
p.save()
return HttpResponseRedirect(reverse_lazy('payments',
kwargs={'username': username})
)
def test_buy_periodic_release_only_for_paid_orders(self, coverable,
run_release):
coverable.return_value = True
self._create_order(pair_name='BTCEUR')
pref = PaymentPreference(
provider_system_id='wawytha',
payment_method=PaymentMethod.objects.get(
name__icontains='Safe Charge'
)
)
pref.save()
payment = Payment(
order=self.order,
currency=self.order.pair.quote,
payment_preference=pref,
amount_cash=self.order.amount_quote,
is_success=True,
is_redeemed=False
)
payment.save()
buy_order_release_reference_periodic.apply_async()
run_release.assert_not_called()
self.order.status = Order.PAID
self.order.save()
buy_order_release_reference_periodic.apply_async()
run_release.assert_called_once()
def test_delete_payment(self):
sender = User.objects.create_user(username=USER_TEST1['username'],
email=USER_TEST1['email'],
password=USER_TEST1['password'])
recipient = User.objects.create_user(username=USER_TEST2['username'],
email=USER_TEST2['email'],
password=USER_TEST2['password'])
TEST_PAYMENT_DATA = {
'amount': 25000,
'details': 'Payment Description',
'sender': sender,
'recipient': recipient
}
self.assertTrue(Payment.objects.count() == 0)
payment = Payment(**TEST_PAYMENT_DATA)
payment.save()
self.assertTrue(Payment.objects.count() == 1)
self.assertTrue(
Payment.objects.filter(payment_uuid=payment.payment_uuid,
is_validated=False).exists())
payment.delete()
self.assertTrue(Payment.objects.count() == 0)
self.assertFalse(
Payment.objects.filter(payment_uuid=payment.payment_uuid,
is_validated=False).exists())
def payment(request, plan_type):
user_email = request.user.email
if request.method == 'POST':
stripe_token = request.POST['stripeToken']
logger.error(plan_type)
customer = stripe.Customer.create(
email = user_email,
description = '{request.user.first_name} { request.user.last_name} - { user_email}',
card = stripe_token,
plan = plan_type
)
payment = Payment(
user_id = request.user.id,
stripe_id = customer.id,
card_type = customer.active_card.type,
card_digits = customer.active_card.last4,
plan_type = plan_type,
is_active = 1,
)
try:
payment.save()
except IntegrityError:
messages.error(request, 'Your payment information could not be saved. #33')
else:
messages.success(request, 'Payment information has been saved.')
return redirect('payments.views.index')
return render_to_response(
'payments/payment.html',
{
'plan_type': plan_type,
'publishable': settings.STRIPE_PUBLISHABLE,
'sub_nav_path': 'partials/settings_sub_nav.html',
},
context_instance=RequestContext(request))
def charge(self):
cleaned_data = self.clean()
cause = Cause.objects.get(pk=cleaned_data['cause_id'])
amount = int(cleaned_data['amount'] * 100)
if amount < self.resource.min_price:
raise forms.ValidationError('You hacker!')
stripe.api_key = settings.STRIPE_API_SECRET_KEY
token = cleaned_data['stripeToken']
payment = Payment(
user=self.user,
resource=self.resource,
amount=amount,
cause=cause,
token=token,
)
try:
stripe.Charge.create(
amount=amount,
currency='bgn',
card=token,
description=str(payment)
)
except stripe.CardError as e:
raise forms.ValidationError(e)
payment.save()
def test_payment_delete_view(self):
payment = Payment(amount=10)
payment.save()
url = reverse('payments-delete', args=[payment.id])
response = self.client.get(url)
self.assertEqual(response.status_code, 302)
def save(self, *args, **kwargs):
res = super(NewTaskForm, self).save(*args, **kwargs)
# Add unpaid payment.
payment = Payment(powner=self.request.user,
ptask=self.instance,
values='{}',
payment_status=co.UNPAID)
payment.save()
return res
def payment_failed(payment: Payment):
"""
Save a failed payment
:param payment: Payment object(Model)
"""
payment.paid = False
payment.waiting = False
payment.cancelled = False
payment.failed = True
payment.save()
def make_a_booking(request, pk):
route = TravelRoute.objects.get(pk=pk)
user = CustomUser()
if not request.user.is_authenticated:
messages.info(request, "Please login to proceed with booking.")
elif request.method == "POST":
form = request.POST
# get form values
booking = Booking()
# get route price
route = TravelRoute.objects.get(pk=pk)
price = route.price
booking.route = route
booking.bus_details = Bus.objects.get(pk=form["bus_id"])
booking.customer_details = CustomUser.objects.get(pk=form["user_id"])
booking.number_of_tickets = request.POST["number_of_tickets"]
booking.date_of_booking = request.POST["date_of_booking"]
booking.amount_paid = int(booking.number_of_tickets) * int(price)
cl = MpesaClient()
token = cl.access_token
print(token)
# Use a Safaricom phone number that you have access to, for you to be able to view the prompt.
phone_number = request.POST["mobile_number"]
print(phone_number)
amount = booking.amount_paid
account_reference = "Msafiri Ticket"
transaction_desc = "Description"
callback_url = request.build_absolute_uri(
reverse("mpesa_stk_push_callback"))
print(callback_url)
response = cl.stk_push(phone_number, amount, account_reference,
transaction_desc, callback_url)
# stay on payment page then redirect if successful
# return HttpResponse(response.text)
# payment
payment = Payment()
payment.customer_details = booking.customer_details
payment.amount_paid = booking.amount_paid
payment.mode_of_payment = ModeOfPayment.objects.get(pk=1)
payment.payment_for = booking
booking.save()
payment.save()
messages.success(request, "Booking successful.")
return redirect("bookings:booking_detail", booking.pk)
bookings = Booking.objects.all()
context = {
"route": route,
"bookings": bookings,
}
return render(request, "bookings/booking.html", context)
def rsvp(request):
response = {'errors': {}}
form = WebRSVPForm(request.POST)
if form.is_valid():
cd = form.cleaned_data
for key, value in request.POST.items():
words = key.split('_')
if words[0] == 'unnamed':
guest = Guest.objects.get(pk=int(words[-1]))
if words[1] == 'first':
guest.first_name = value
elif words[1] == 'last':
guest.last_name = value
guest.save()
guest = Guest.objects.get(id=cd['guest_id'])
payment = None
if cd['attending'] and cd['nights_onsite'] > 0:
# The guest(s) will be staying onsite, so we need payment
amount = lodging_cost(cd['guests'], cd['nights_onsite'])
try:
stripe_kwargs = {
'amount': int(amount * 100), # Convert dollars to cents
'currency': 'usd',
'source': cd['stripe_token'],
'description': "Lodging for Tony & Haya's Wedding"}
if guest.email:
stripe_kwargs['receipt_email'] = guest.email
charge = stripe.Charge.create(**stripe_kwargs)
payment = Payment(
amount=amount,
payer=Payer.objects.get_or_create(guest=guest)[0],
category=PaymentCategory.objects.get(name='Lodging'),
stripe_id=charge.id)
payment.save()
except stripe.error.CardError as card_error:
# There was an error processing the credit card
card_error = str(card_error)
if 'Request req' in card_error:
card_error = card_error.split(':', 1)[1].strip()
response['errors']['rsvp_cc'] = [card_error]
if not response['errors']:
rsvp = form.save()
if payment:
rsvp.payment = payment
rsvp.save()
else:
# The form is invalid
response['errors'] = form.errors
return JsonResponse(response)
def test_is_created(self):
payment = Payment(
**self.payment_data,
to_account=self.bob_account,
direction=PaymentDirections.OUTGOING.name,
)
payment.full_clean()
payment.save()
payments = Payment.objects.filter(account=self.alice_account.id)
self.assertEqual(len(payments.all()), 1)
def test_two_seats_all_paid(self, appointment):
ser = s.AppointmentSerializer()
seat1 = Seat(appointment=appointment, birth_date=timezone.now())
seat1.save()
payment1 = Payment(amount=200, seat=seat1, paid_at=timezone.now())
payment1.save()
seat2 = Seat(appointment=appointment, birth_date=timezone.now())
seat2.save()
payment2 = Payment(amount=200, seat=seat2, paid_at=timezone.now())
payment2.save()
assert ser.get_all_seats_paid(appointment) is True
def update_payment_status(ptype, task, request, data=None):
data = data or {}
status = co.IN_PROCESS
if ptype == co.LIQPAY:
from liqpay.liqpay import LiqPay
liq = LiqPay(co.LIQ_PUB_KEY, co.LIQ_PRIV_KEY)
liq = liq.api("payment/status", {"order_id": task.id})
try:
values = json.dumps(liq)
except:
values = '{}'
if liq.get('result') == 'ok' and liq.get('status') in [
'success', 'sandbox'
]:
fraud = float(task.get_price()) - float(liq.get('amount',
0.00)) > 0.03
status = co.PAID
if fraud:
status = co.UNDERPAID
elif ptype == co.TWOCHECKOUT:
import twocheckout
# mode: production, mode:sandbox
twocheckout.Api.auth_credentials({
'private_key': co.TWO_PRIV_KEY,
'seller_id': co.TWOSID
})
twocheckout.Api.credentials({
'username': co.TWO_USERNAME,
'password': co.TWO_PASSWORD
})
sale_id = data.get('sale_id')
try:
sale_status = twocheckout.Sale.find({'sale_id': sale_id
})['invoices'][0]['status']
amount = twocheckout.Sale.find({'sale_id': sale_id
})['invoices'][0]['usd_total']
except (twocheckout.error.TwocheckoutError, KeyError, IndexError):
return
if sale_status in ['deposited']:
fraud = float(task.get_price()) - float(amount) > 0.03
status = co.PAID
if fraud:
status = co.UNDERPAID
payment = Payment(powner=task.owner,
ptask=task,
values=json.dumps(data),
payment_status=status,
payment_type=ptype)
payment.save()
def pay_for_the_order(self, **kwargs):
error_msg = _('Something went wrong. Order is not paid.')
success_msg = _('Order is paid successfully!')
self.order = Order.objects.get(unique_reference=kwargs['orderid'])
if self.validate_order(self.order, **kwargs):
try:
res = self.create_transaction(**kwargs)
except KeyError as e:
error_msg = _('Bad Credit Card credentials')
return {'status': 0, 'msg': error_msg}
if res['status'] == '1':
# FIXME: CANCEL CARDPMT because it doesnt work
self.order.cancel()
self.order.refresh_from_db()
if res['transaction_id'] == '0' or res['transaction_id'] is \
None:
error_msg = _('Order payment status is unclear, please '
'contact administrator!')
return {'status': 0, 'msg': error_msg}
if not self.check_unique_transaction_id(res['transaction_id']):
return {'status': 0, 'msg': error_msg}
# FIXME: CANCEL CARDPMT because it doesnt work
self.order.cancel()
self.order.refresh_from_db()
pref = self.create_payment_preference(self.order, **kwargs)
currency = Currency.objects.get(code=kwargs['currency'])
payment = Payment(is_success=res['status'],
payment_system_id=res['transaction_id'],
reference=self.order.unique_reference,
amount_cash=kwargs['amount'],
payment_preference=pref,
order=self.order,
user=self.order.user if self.order else None,
currency=currency)
payment.save()
return {'status': 1, 'msg': success_msg}
elif 'msg' in res:
return res
else:
self.logger.error(
'Bad Payment status. response:{},order:{}'.format(
res, self.order))
return {'status': 0, 'msg': error_msg}
else:
if self.order.status == Order.PAID:
error_msg = _("This order is already paid")
return {'status': 0, 'msg': error_msg}
def checkout(order: Order, payment_method: str):
# Checkout order/create Payment
payment = Payment(order=order,
payment_method=payment_method,
amount=order.get_total(),
paid=False,
waiting=True,
cancelled=False,
failed=False)
try:
payment.save()
except Exception as e:
payment_failed(payment)
raise Exception(e)
else:
return make_payment(payment)
def save_payment(payment_entity):
payment = Payment(payment_id=payment_entity['id'])
payment.amount = payment_entity['amount']
payment.currency = payment_entity['currency']
payment.status = payment_entity['status']
payment.order_id = payment_entity['order_id']
payment.invoice_id = payment_entity['invoice_id']
payment.international = payment_entity['international']
payment.amount_refunded = payment_entity['amount_refunded']
payment.refund_status = payment_entity['refund_status']
payment.email = payment_entity['email']
payment.contact = payment_entity['contact']
payment.fee = payment_entity['fee']
payment.service_tax = payment_entity['service_tax']
payment.created_at = str(payment_entity['created_at'])
payment.save()
def get_context_data(self, **kwargs):
context = super(DetailTaskView, self).get_context_data(**kwargs)
order = self.get_object()
# Simple order procesing after payment. Shouldn't be there.
if self.request.GET.get(
'merchant_order_id') and order.status == co.DRAFT:
messages.success(self.request,
'An order has been successfully performed.')
# Add processing payment.
payment = Payment(powner=self.request.user,
ptask=order,
values='{}',
payment_status=co.IN_PROCESS,
payment_type=self.request.GET.get(
'ptype', co.TWOCHECKOUT))
payment.save()
# Move an order to UNPROCESSED.
order.status = co.UNPROCESSED
order.save()
context['order'] = order
context['object'] = order
send_mail(
'Thanks for buying an order', co.ORDER_BUY_MAIL % {
'order_title': order.paper_title,
'first_name': order.owner.first_name
}, co.ADMIN_EMAIL, [order.owner.email])
task_id = order.pk
task_payments = context['payments'].get(task_id)
if task_payments and task_payments[1] in [co.IN_PROCESS]:
update_payment_status(task_payments[3], self.get_object(),
self.request, task_payments[-1])
context['msgs'] = get_msgs_for_task(self.request, task_id)
task_q = Q(ftask_id__exact=task_id)
or_q = Q(access_level__in=(co.PUBLIC_ACCESS, ))
not_owner_q = ~Q(fowner_id__exact=self.request.user.id)
w_ups = []
if order.status == co.COMPLETED:
w_ups = Upload.objects.filter(task_q, or_q, not_owner_q)
m_ups = Upload.objects.filter(task_q,
Q(fowner_id__exact=self.request.user.id))
ups = []
ups.extend(m_ups)
ups.extend(w_ups)
context['uploads'] = ups
return context
def verifyPayment(request):
request_body = json.loads(request.body.decode('utf-8'))
print(request_body)
params = {}
try:
params['razorpay_payment_id'] = request_body['payment_id']
params['razorpay_signature'] = request_body['signature']
except KeyError:
return Response({'message': 'Provide both payment_id and signature'})
try:
params['razorpay_order_id'] = orders[request.user.email]['id']
except KeyError:
return Response({'message': 'No order found for this user'})
env = environ.Env(
DEBUG=(bool, False)
)
environ.Env.read_env()
RAZORPAY_ID = env('RAZORPAY_ID')
RAZORPAY_SECRET_KEY = env('RAZORPAY_SECRET_KEY')
client = razorpay.Client(auth=(RAZORPAY_ID, RAZORPAY_SECRET_KEY))
result = 1
try:
client.utility.verify_payment_signature(params)
except razorpay.errors.SignatureVerificationError:
result = 0
if result == 1:
order = client.order.fetch(params['razorpay_order_id'])
invoice = Invoice(type='bill', order_id=order['id'])
invoice.save()
payment = Payment(buyer=request.user, invoice=invoice, amount=order['amount'] / 100)
payment.save()
bill = Bill.objects.get(id=order['notes']['bill_id'])
bill.is_paid = True
bill.save()
return Response({'success': result})
def test_payment_detail(self):
self.assertFalse(Payment.objects.exists())
payment = Payment(**self.TEST_DETAIL_PAYMENT_DATA)
payment.full_clean()
payment.save()
self.assertTrue(Payment.objects.exists())
self.assertTrue(
Payment.objects.filter(payment_uuid=payment.payment_uuid).exists())
payment_url = payment.get_absolute_url()
request = self.factory.get(payment_url)
request.user = self.anonymeUser
request = add_middledware_to_request(request, SessionMiddleware)
request.session.save()
response = views.payment_details(request, payment.payment_uuid)
self.assertEqual(response.status_code, 302)
request = self.factory.get(payment_url)
request.user = self.sender
request = add_middledware_to_request(request, SessionMiddleware)
request.session.save()
response = views.payment_details(request, payment.payment_uuid)
self.assertEqual(response.status_code, 200)
request = self.factory.get(payment_url)
request.user = self.recipient
request = add_middledware_to_request(request, SessionMiddleware)
request.session.save()
response = views.payment_details(request, payment.payment_uuid)
self.assertEqual(response.status_code, 200)
request = self.factory.get(payment_url)
request.user = self.no_payment_user
request = add_middledware_to_request(request, SessionMiddleware)
request.session.save()
self.assertRaises(Http404,
views.payment_details,
request=request,
payment_uuid=payment.payment_uuid)
def test_payment_get(self):
empty_response = self.client.get('/api/payments/')
self.assertEqual(empty_response.status_code, 200)
self.assertEqual(empty_response.data, [])
payment1 = Payment(
sender=self.sender_user, receiver=self.receiver_user, amount=10
)
payment1.save()
payment2 = Payment(
sender=self.receiver_user, receiver=self.sender_user, amount=50
)
payment2.save()
payment3 = Payment(
sender=self.receiver_user,
receiver=self.friend_of_receiver,
amount=50,
)
payment3.save()
response = self.client.get('/api/payments/')
self.assertEqual(len(response.data), 2)
first_payment = response.data[0]
self.assertEqual(first_payment['sender']['username'], 'admin')
self.assertEqual(first_payment['receiver']['username'], 'oriol')
self.assertEqual(first_payment['amount'], '10.00')
second_payment = response.data[1]
self.assertEqual(second_payment['sender']['username'], 'oriol')
self.assertEqual(second_payment['receiver']['username'], 'admin')
self.assertEqual(second_payment['amount'], '50.00')
def add_payment(self, payment):
member = self.detect_member(payment)
new_payment = Payment(
date=payment['date'],
amount=payment['amount'],
payment_type=payment['type'],
constant_symbol=payment['constant_symbol'],
variable_symbol=payment['variable_symbol'],
specific_symbol=payment['specific_symbol'],
identification=payment['identification'],
message=payment['recipient_message'])
if member:
print('new payment (%s) from %s [%.2f]' % (payment['date'],
member, payment['amount']))
new_payment.user = member
else:
print('new payment (%s) - %s - %s [%.2f]'% (payment['date'],
payment['type'], payment['identification'], payment['amount']))
new_payment.save()
def add_payment(self, payment):
member = self.detect_member(payment)
new_payment = Payment(
date=payment.arrival,
amount=payment.amount,
payment_type=payment.payment_type,
constant_symbol=payment.ks,
variable_symbol=payment.vs,
specific_symbol=payment.ss,
identification=payment.identification,
message=payment.message)
if member:
print('new payment (%s) from %s [%.2f]' % (payment.arrival,
member, payment.amount))
new_payment.user = member
else:
print('new payment (%s) - %s - %s [%.2f]'% (payment.arrival,
payment.payment_type, payment.identification, payment.amount))
new_payment.save()
def payment_ajax(request):
template = get_template('core/partials/success_payment.html')
curr = request.POST.get("currency_from", "RUB")
amount_cash = request.POST.get("amount-cash")
order_id = request.POST.get("order_id")
currency = Currency.objects.filter(code=curr)[0]
user = request.user
order = Order.objects.get(pk=order_id)
payment = Payment(amount_cash=amount_cash,
currency=currency,
user=user,
order=order)
payment.save()
uniq_ref = payment.unique_reference
my_action = _("Result")
return HttpResponse(
template.render({
'unique_ref': uniq_ref,
'action': my_action,
}, request))
def test_buy_release_do_not_change_parameters_on_failure(self, coverable):
coverable.return_value = True
self._create_order(pair_name='BTCEUR')
pref = PaymentPreference(
provider_system_id='wawytha',
payment_method=PaymentMethod.objects.get(
name__icontains='Safe Charge'
),
user=self.order.user
)
pref.save()
self.order.payment_preference = pref
withdraw_address = Address.objects.filter(
type=Address.WITHDRAW, currency=self.order.pair.base
).first()
self.order.withdraw_address = withdraw_address
self.order.save()
payment = Payment(
order=self.order,
currency=self.order.pair.quote,
payment_preference=pref,
amount_cash=self.order.amount_quote,
is_success=True,
is_redeemed=False,
reference=self.order.unique_reference,
user=self.order.user
)
payment.save()
buy_order_release_by_reference_invoke.apply_async([payment.pk])
payment_from_db = Payment.objects.latest('pk')
for param in ['is_redeemed', 'is_success', 'is_complete']:
self.assertEqual(
getattr(payment, param),
getattr(payment_from_db, param),
'{}'.format(param)
)
def confirm_member(request):
if hasattr(request.user, 'member'):
return redirect('/account-info')
elif request.method == 'POST':
response = get_confirm_response(request)
if response == 'confirm':
try:
credit_card = CreditCard.objects.get(
customer=request.user.customer)
except CreditCard.DoesNotExist:
messages.warning(request, 'You must add a credit card')
return redirect('/account-payments')
member = Member(user=request.user)
payment = Payment(paid_by=credit_card, amount=10) # 10 bucks
member.save()
payment.save()
messages.success(request,
'Your membership was successfully created!')
# cancel and success
return redirect('/account-info')
return render(request, 'accounts/member.html', {'user': request.user})
def checkout(order: Order, payment_method: str):
"""
Pay for order.
:param order: Order model object
:param payment_method: Payment.payment_method
:return: make_payment()
"""
# Create Payment
payment = Payment(order=order,
payment_method=payment_method,
amount=order.get_total(),
paid=False,
waiting=True,
cancelled=False,
failed=False)
try:
payment.save()
except Exception as e:
payment_failed(payment)
raise Exception(e)
else:
return make_payment(payment)
def record_payment(params, author, company):
try:
print('Recording ...', params, author, company)
pa = params['payer_account']
payer_account = pa if pa.startswith('255') else f'255{pa}'
payment = Payment(trans_id=params['trans_id'],
payer_account=payer_account,
payer_name=params['payer_name'],
payee_account=company.account,
payee_name=company.name,
amount=params['amount'].replace(',', ''),
trans_date=datetime.datetime.strptime(
params['trans_date'].strip(), '%d/%m/%y %H:%M'),
author=author,
company=company,
channel=params['channel'],
receipt_no=params['receipt_no'])
# print('Unsaved', payment)
payment.save()
print('Saved: ', payment)
return True
except Exception as e:
print('Error during saving? ', e)
return False
def directory_set_inv_payment(user, directory, **kwargs):
if get_setting('module', 'directories', 'directoriesrequirespayment'):
if not directory.invoice:
inv = Invoice()
inv.object_type = ContentType.objects.get(app_label=directory._meta.app_label,
model=directory._meta.module_name)
inv.object_id = directory.id
profile = user.get_profile()
inv.title = "Directory Add Invoice"
inv.bill_to = '%s %s' % (user.first_name, user.last_name)
inv.bill_to_first_name = user.first_name
inv.bill_to_last_name = user.last_name
inv.bill_to_company = profile.company
inv.bill_to_address = profile.address
inv.bill_to_city = profile.city
inv.bill_to_state = profile.state
inv.bill_to_zip_code = profile.zipcode
inv.bill_to_country = profile.country
inv.bill_to_phone = profile.phone
inv.bill_to_fax = profile.fax
inv.bill_to_email = profile.email
inv.ship_to = inv.bill_to
inv.ship_to_first_name = user.first_name
inv.ship_to_last_name = user.last_name
inv.ship_to_company = profile.company
inv.ship_to_address = profile.address
inv.ship_to_city = profile.city
inv.ship_to_state = profile.state
inv.ship_to_zip_code = profile.zipcode
inv.ship_to_country = profile.country
inv.ship_to_phone = profile.phone
inv.ship_to_fax = profile.fax
inv.ship_to_email = profile.email
inv.terms = "Due on Receipt"
inv.due_date = datetime.now()
inv.ship_date = datetime.now()
inv.message = 'Thank You.'
inv.status = True
inv.total = get_directory_price(user, directory)
inv.subtotal = inv.total
inv.balance = inv.total
inv.estimate = 1
inv.status_detail = 'estimate'
inv.save(user)
# update job
directory.invoice = inv
directory.save()
if is_admin(user):
if directory.payment_method in ['paid - cc', 'paid - check', 'paid - wire transfer']:
boo_inv = inv.tender(user)
# payment
payment = Payment()
boo = payment.payments_pop_by_invoice_user(user, inv, inv.guid)
payment.mark_as_paid()
payment.method = directory.payment_method
payment.save(user)
# this will make accounting entry
inv.make_payment(user, payment.amount)
def corp_memb_inv_add(user, corp_memb, **kwargs):
"""
Add an invoice for this corporate membership
"""
renewal = kwargs.get('renewal', False)
renewal_total = kwargs.get('renewal_total', 0)
renew_entry = kwargs.get('renew_entry', None)
if not corp_memb.invoice or renewal:
inv = Invoice()
if renew_entry:
inv.object_type = ContentType.objects.get(app_label=renew_entry._meta.app_label,
model=renew_entry._meta.module_name)
inv.object_id = renew_entry.id
else:
inv.object_type = ContentType.objects.get(app_label=corp_memb._meta.app_label,
model=corp_memb._meta.module_name)
inv.object_id = corp_memb.id
inv.title = "Corporate Membership Invoice"
inv.bill_to = corp_memb.name
inv.bill_to_company = corp_memb.name
inv.bill_to_address = corp_memb.address
inv.bill_to_city = corp_memb.city
inv.bill_to_state = corp_memb.state
inv.bill_to_zip_code = corp_memb.zip
inv.bill_to_country = corp_memb.country
inv.bill_to_phone = corp_memb.phone
inv.bill_to_email = corp_memb.email
inv.ship_to = corp_memb.name
inv.ship_to_company = corp_memb.name
inv.ship_to_address = corp_memb.address
inv.ship_to_city = corp_memb.city
inv.ship_to_state = corp_memb.state
inv.ship_to_zip_code = corp_memb.zip
inv.ship_to_country = corp_memb.country
inv.ship_to_phone = corp_memb.phone
inv.ship_to_email =corp_memb.email
inv.terms = "Due on Receipt"
inv.due_date = datetime.now()
inv.ship_date = datetime.now()
inv.message = 'Thank You.'
inv.status = True
if not renewal:
inv.total = corp_memb.corporate_membership_type.price
else:
inv.total = renewal_total
inv.subtotal = inv.total
inv.balance = inv.total
inv.estimate = 1
inv.status_detail = 'estimate'
inv.save(user)
if is_admin(user):
# if offline payment method
if not corp_memb.get_payment_method().is_online:
inv.tender(user) # tendered the invoice for admin if offline
# mark payment as made
payment = Payment()
payment.payments_pop_by_invoice_user(user, inv, inv.guid)
payment.mark_as_paid()
payment.method = corp_memb.get_payment_method()
payment.save(user)
# this will make accounting entry
inv.make_payment(user, payment.amount)
return inv
return None
p.accepted = True
p.save()
pid_map[int(m[0])] = u
def fix(inp):
if inp==u'': return 0
return int(inp)
def fixfloat(inp):
if type(inp) == float:
return inp
return float(inp)
for p in ps:
user = None
if fix(p[5]) in pid_map:
user = pid_map[fix(p[5])]
p = Payment(
date=date(*map(int, p[1].split('-'))),
amount=fixfloat(p[2]),
payment_type=p[3],
constant_symbol=fix(p[4]),
variable_symbol=fix(p[5]),
specific_symbol=fix(p[6]),
identification=p[7],
message=p[8],
user=user)
p.save()
def job_set_inv_payment(user, job, pricing):
if get_setting('module', 'jobs', 'jobsrequirespayment'):
if not job.invoice:
inv = Invoice()
inv.object_type = ContentType.objects.get(app_label=job._meta.app_label,
model=job._meta.module_name)
inv.object_id = job.id
inv.title = "Job Add Invoice"
inv.bill_to = job.contact_name
first_name = ''
last_name = ''
if job.contact_name:
name_list = job.contact_name.split(' ')
if len(name_list) >= 2:
first_name = name_list[0]
last_name = ' '.join(name_list[1:])
inv.bill_to_first_name = first_name
inv.bill_to_last_name = last_name
inv.bill_to_company = job.contact_company
inv.bill_to_address = job.contact_address
inv.bill_to_city = job.contact_city
inv.bill_to_state = job.contact_state
inv.bill_to_zip_code = job.contact_zip_code
inv.bill_to_country = job.contact_country
inv.bill_to_phone = job.contact_phone
inv.bill_to_fax = job.contact_fax
inv.bill_to_email = job.contact_email
inv.ship_to = job.contact_name
inv.ship_to_first_name = first_name
inv.ship_to_last_name = last_name
inv.ship_to_company = job.contact_company
inv.ship_to_address = job.contact_address
inv.ship_to_city = job.contact_city
inv.ship_to_state = job.contact_state
inv.ship_to_zip_code = job.contact_zip_code
inv.ship_to_country = job.contact_country
inv.ship_to_phone = job.contact_phone
inv.ship_to_fax = job.contact_fax
inv.ship_to_email =job.contact_email
inv.terms = "Due on Receipt"
inv.due_date = datetime.now()
inv.ship_date = datetime.now()
inv.message = 'Thank You.'
inv.status = True
inv.total = get_job_price(user, job, pricing)
inv.subtotal = inv.total
inv.balance = inv.total
inv.estimate = 1
inv.status_detail = 'estimate'
inv.save(user)
# update job
job.invoice = inv
job.save()
if is_admin(user):
if job.payment_method in ['paid - cc', 'paid - check', 'paid - wire transfer']:
boo_inv = inv.tender(user)
# payment
payment = Payment()
boo = payment.payments_pop_by_invoice_user(user, inv, inv.guid)
payment.mark_as_paid()
payment.method = job.payment_method
payment.save(user)
# this will make accounting entry
inv.make_payment(user, payment.amount)
class PaymentReleaseTestCase(UserBaseTestCase, OrderBaseTestCase):
def setUp(self):
super(PaymentReleaseTestCase, self).setUp()
self.method_data = {"is_internal": 1, 'name': 'Robokassa'}
amount_cash = Decimal(30000.00)
self.payment_method = PaymentMethod(name='ROBO')
self.payment_method.save()
self.addr_data = {
'type': 'W',
'name': '17NdbrSGoUotzeGCcMMCqnFkEvLymoou9j',
'address': '17NdbrSGoUotzeGCcMMCqnFkEvLymoou9j',
}
self.addr = Address(**self.addr_data)
self.addr.user = self.user
self.addr.save()
pref_data = {
'user': self.user,
'comment': 'Just testing',
'payment_method': self.payment_method
}
pref = PaymentPreference(**pref_data)
pref.save('internal')
self.data = {
'amount_cash': amount_cash,
'amount_btc': Decimal(1.00),
'currency': self.RUB,
'user': self.user,
'admin_comment': 'test Order',
'unique_reference': '12345',
'payment_preference': pref,
'is_paid': True
}
self.order = Order(**self.data)
self.order.save()
self.pay_data = {
'amount_cash': self.order.amount_cash,
'currency': self.RUB,
'user': self.user,
'payment_preference': pref,
}
self.payment = Payment(**self.pay_data)
self.payment.save()
tx_id_ = '76aa6bdc27e0bb718806c93db66525436' \
'fa621766b52bad831942dee8b618678'
self.transaction = Transaction(tx_id=tx_id_,
order=self.order,
address_to=self.addr)
self.transaction.save()
def test_bad_release_payment(self):
for o in Order.objects.filter(is_paid=True, is_released=False):
p = Payment.objects.filter(user=o.user,
amount_cash=o.amount_cash,
payment_preference=o.payment_preference,
is_complete=False,
currency=o.currency).first()
if p is not None:
tx_id_ = release_payment(o.withdraw_address, o.amount_btc)
self.assertEqual(tx_id_, None)
def test_orders_with_approved_payments(self):
for o in Order.objects.filter(is_paid=True, is_released=False):
p = Payment.objects.filter(user=o.user,
amount_cash=o.amount_cash,
payment_preference=o.payment_preference,
is_complete=False,
currency=o.currency).first()
if p is not None:
o.is_released = True
o.save()
p.is_complete = True
p.save()
self.assertTrue(o.is_released)
self.assertTrue(p.is_complete)
def checker_transactions(self):
if check_transaction(self.transaction.tx_id):
self.transaction.is_completed = True
self.transaction.save()
self.assertTrue(self.transaction.is_completed)
