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)