def setUp(self):
# set up the test DB
self.db = tested_db
self.db.create_all()
self.db.session.add(Person(id=1, name="Alice"))
self.db.session.add(Person(id=2, name="Bob"))
self.db.session.add(
Payment(payment_id=1, payment_amount=10.5, client_id=1))
self.db.session.add(
Payment(payment_id=2, payment_amount=12.5, client_id=2))
self.db.session.commit()
self.app = tested_app.test_client()
def make_payment(self, contact_id=None, date_cursor=None, amount=0):
if not date_cursor: # If date_cursor is equal to the default value (None) or null, set it equal to the current date
date_cursor = datetime.now().date()
if not contact_id: # If there is no contact_id or it is equal to the default value (None), set it equal to the named insured of the policy
try:
contact_id = self.policy.named_insured
except:
pass
payment = Payment(self.policy.id, # Create a payment using the method parameters
contact_id,
amount,
date_cursor)
invoices = Invoice.query.filter_by(policy_id=self.policy.id).all() # Get a list of invoices
for invoice in invoices: # For each invoice...
if invoice.amount_due != 0: # That is not paid (i.e not equal to 0)...
invoice.amount_due -= amount # Subtract the amount paid from the invoice amount due
break # We want to execute the break statement because we found our invoice that was decremented and don't want to modify any other ones
db.session.add(payment) # Add the payment to the database
db.session.commit() # Commit the changes (save)
return payment
def make_payment(self, contact_id=None, date_cursor=None, amount=0):
"""
Add new payment data to database.
Use current date if date_cursor argument is not provided
Use named insured id as contact id if not provided
"""
if not date_cursor:
date_cursor = datetime.now().date()
if not contact_id:
try:
contact_id = self.policy.named_insured
except:
pass
# If a policy is in cancellation pending due to non_pay, only an
# agent should be able to make a payment on it
if self.evaluate_cancellation_pending_due_to_non_pay(
date_cursor) and contact_id is not self.policy.agent:
print "Contact your agent for making payment"
return None
else:
payment = Payment(self.policy.id, contact_id, amount, date_cursor)
db.session.add(payment)
db.session.commit()
return payment
def menu_charge(request, request_id=0):
if request.method == "POST":
stripe.api_key = settings.STRIPE_API_KEY
card = request.POST.get("stripeToken")
m = []
food_request = get_request(request_id)
payment = Payment()
payment.amount = food_request.total
payment.paidBy = request.user
payment.description = "food delivery: " #+ item_list
x = payment.amount * 100 #Convert from dolars to cents
y = (x / 100) * 2.9 #Adjust stripe fees
print card
success, instance = payment.charge(int((x + y) + 30), card)
if not success:
raise forms.ValidationError("Error: %s" % instance.message)
else:
instance.amount = payment.amount
instance.save()
food_request.paid = True
food_request.save()
return HttpResponseRedirect("/")
else:
context = {'user': request.user, 'stripe_key': settings.STRIPE_PUB_KEY}
return render(request, 'pay.html', context)
def create_payment():
form = PaymentForm()
if form.validate_on_submit():
payment = request.get_json()
if not is_exists_invoices(invoice_list=[
payment['number_invoice_provider'],
payment['number_invoice_reciever']
]):
return send_response(
content={'message': 'Invoices does not exists'},
status_code=404)
key = get_payment_key()
code_confirm = randint(100, 1000)
db.session.add(
Payment(key=key,
amount_money=payment['amount_money'],
number_invoice_provider=payment['number_invoice_provider'],
number_invoice_reciever=payment['number_invoice_reciever'],
code_confirm=code_confirm,
status_id=1))
db.session.commit()
send_code_confirm_payment_to_client(code=code_confirm)
return send_response(content={'message': 'ok'}, status_code=200)
return send_response(content=form.errors, status_code=400)
def make_payment(self, contact_id=None, date_cursor=None, amount=0):
if not date_cursor:
date_cursor = datetime.now().date()
if not contact_id:
try:
contact_id = self.policy.named_insured
except:
logging.exception('Encountered an issue with generating insured name for make_payment')
return None
# If cancellation due to non pay, an agent must make the payment
if self.evaluate_cancellation_pending_due_to_non_pay(date_cursor):
contact = Contact.query.filter_by(id=contact_id)\
.one()
if contact.role != 'Agent':
print 'Due to the current status of this policy, an agent is needed to make payment'
return
# Create payment
payment = Payment(self.policy.id,
contact_id,
amount,
date_cursor)
db.session.add(payment)
db.session.commit()
return payment
def create_consult(request):
if request.POST:
aid = request.POST['id']
a = Appointment.objects.filter(a_id=aid)
a1 = Appointment.objects.get(a_id=aid)
patient = a[0].user_id
pname = a[0].patient_name
doctor = a[0].doctor
dept = a[0].dept
dnm = a[0].doc_name
a1.active = False
a1.save()
c = Consultation(c_id=uuid.uuid4(),
patient=patient,
patient_name=pname,
doctor=doctor,
dept=dept,
doc_name=dnm,
comments="Consultation started",
active=True)
c.save()
p = Payment(payment_id=uuid.uuid4(),
item_id="Consultation Fees",
user=patient,
payment_type="Debit Card",
status=0,
active=True,
date=date.today(),
amount=200)
p.save()
return render_to_response('consultsuccess.html')
def make_payment(self, contact_id=None, date_cursor=None, amount=0):
""" Make a payment against the policy """
# Default to current date
if not date_cursor:
date_cursor = datetime.now().date()
# If no contact_id was provided, assign contact to the
# policy's name_insured. Will be used as the contact for the payment
if not contact_id:
try:
contact_id = self.policy.named_insured
except:
pass
# Create the payment
payment = Payment(
self.policy.id, # policy
contact_id, # contact
amount, # amount paid
date_cursor) # transaction date
# Commit changes to database
db.session.add(payment)
db.session.commit()
return payment
def ExecutePayment(self, request, context):
payment = None
try:
payment = paypalrestsdk.Payment.find(request.paymentId)
except paypalrestsdk.ResourceNotFound:
context.set_code(grpc.StatusCode.INVALID_ARGUMENT)
context.set_details('Invalid payment id')
return ExecutePaymentResponse()
if not payment.execute({'payer_id': request.payerId}):
context.set_code(grpc.StatusCode.INVALID_ARGUMENT)
context.set_details('Invalid payer id')
return ExecutePaymentResponse()
session = self._Session()
enrollment_id = self._get_sku_from_payment(payment)
enrollment = session.query(Enrollment).\
filter_by(id=enrollment_id).first()
enrollment.payment = Payment()
enrollment.course.creator.week_profit += enrollment.course.price
session.add(enrollment)
session.commit()
session.close()
return ExecutePaymentResponse()
def make_payment(self, contact_id=None, date_cursor=None, amount=0):
"""
if date_cursor is null
then Initialize date_cursor with the current date
"""
if not date_cursor:
date_cursor = datetime.now().date()
"""
If contact_id is NULL then contact_id = named_insured
"""
if not contact_id:
try:
contact_id = self.policy.named_insured
except:
logging.exception("contact_id cannot be NULL")
return
if self.evaluate_cancellation_pending_due_to_non_pay(date_cursor):
contact = Contact.query.filter_by(id=contact_id).one()
if 'Agent' != contact.role:
print 'At This Stage, Only an agent can make the payment.'
return
"""
Creating a new payment with the previous Information and persisting it
"""
payment = Payment(self.policy.id, contact_id, amount, date_cursor)
db.session.add(payment)
db.session.commit()
return payment
def make_payment(self, contact_id=None, date_cursor=None, amount=0):
"""
Create a new payment method,
this method will evaluate each policy
if it's cancellation pending only agents
will be able to make payments.
"""
if not date_cursor:
date_cursor = datetime.now().date()
if self.evaluate_cancellation_pending_due_to_non_pay(date_cursor):
contact = Contact.query.get(contact_id)
if contact.role != 'Agent':
print
'You need to be an agent to pay this policy.'
return False
else:
if not contact_id:
try:
contact_id = self.policy.named_insured
except:
pass
payment = Payment(self.policy.id, contact_id, amount, date_cursor)
db.session.add(payment)
db.session.commit()
return payment
def make_payment(self, contact_id=None, date_cursor=None, amount=0):
# In case a date is not passed the current date is used
if not date_cursor:
date_cursor = datetime.now().date()
# In case the contact id is not passed it uses the id referenced in the Policy table
if not contact_id:
try:
if self.policy.named_insured:
contact_id = self.policy.named_insured
else:
contact_id = self.policy.agent
except:
logging.info('No contact found during the payment')
try:
# Creates the payment object
payment = Payment(self.policy.id, contact_id, amount, date_cursor)
db.session.add(payment)
db.session.commit()
logging.info('Payment made')
return payment
except Exception as error:
db.session.rollback()
logging.error(error)
def create_payment(booking, offerer, amount, author='test author', reimbursement_rule='remboursement à 100%',
reimbursement_rate=Decimal(0.5), payment_message=None, payment_message_name=None,
transaction_end_to_end_id=None,
transaction_label='pass Culture Pro - remboursement 2nde quinzaine 07-2018',
status=TransactionStatus.PENDING, idx=None, iban='FR7630007000111234567890144', bic='BDFEFR2LCCB'):
payment = Payment()
payment.booking = booking
payment.amount = amount
payment.author = author
payment.iban = iban
payment.bic = bic
payment.recipientName = offerer.name
payment.recipientSiren = offerer.siren
payment_status = PaymentStatus()
payment_status.status = status
payment_status.date = datetime.utcnow()
payment.statuses = [payment_status]
payment.reimbursementRule = reimbursement_rule
payment.reimbursementRate = reimbursement_rate
if payment_message_name:
payment.paymentMessage = create_payment_message(payment_message_name)
elif payment_message:
payment.paymentMessage = payment_message
payment.transactionEndToEndId = transaction_end_to_end_id
payment.transactionLabel = transaction_label
payment.id = idx
return payment
def _div_to_payment(self, div):
price_xpath = './/span[contains(@data-pageobject,"price")]'
cost_str = text_at_xpath(div, price_xpath)
cost = text_to_cost(cost_str)
def parse_date(date_str, format_str):
return datetime.strptime(date_str, format_str).date()
date_xpath = './/span[@data-pageobject="statement-date"]'
date_str = text_at_xpath(div, date_xpath)
date = parse_date(date_str, "%d/%m/%Y")
p = Payment(cost, date)
def has_element(d, xpath_str):
return first(d.xpath(xpath_str)) is not None
warning_xpath = './/img[contains(@class, "warning-icon")]'
p.warning = has_element(div, warning_xpath)
autocompleted_xpath = './/img[contains(@class, "autocompleted")]'
p.autocompleted = has_element(div, autocompleted_xpath)
capped_xpath = './/img[contains(@class, "capped")]'
p.capped = has_element(div, capped_xpath)
p.journeys = self._div_to_journeys(div)
return p
def fill_in_tables(num_records=1):
for _ in range(num_records):
person_rec, payment_rec = generate_user()
p_1 = Person.objects.create(**person_rec)
pay = Payment(**payment_rec)
p_1.payment_set.add(pay, bulk=False)
# fill_in_tables()
def insert_data():
#Contacts
contacts = []
mary_sue_client = Contact('Mary Sue', "Client")
contacts.append(mary_sue_client)
john_doe_agent = Contact('John Doe', 'Agent')
contacts.append(john_doe_agent)
john_doe_insured = Contact('John Doe', 'Named Insured')
contacts.append(john_doe_insured)
bob_smith = Contact('Bob Smith', 'Agent')
contacts.append(bob_smith)
anna_white = Contact('Anna White', 'Named Insured')
contacts.append(anna_white)
joe_lee = Contact('Joe Lee', 'Agent')
contacts.append(joe_lee)
ryan_bucket = Contact('Ryan Bucket', 'Named Insured')
contacts.append(ryan_bucket)
for contact in contacts:
db.session.add(contact)
db.session.commit()
policies = []
p1 = Policy('Policy One', date(2015, 1, 1), 365)
p1.billing_schedule = 'Annual'
p1.agent = bob_smith.id
policies.append(p1)
p2 = Policy('Policy Two', date(2015, 2, 1), 1600)
p2.billing_schedule = 'Quarterly'
p2.named_insured = anna_white.id
p2.agent = joe_lee.id
policies.append(p2)
p3 = Policy('Policy Three', date(2015, 1, 1), 1200)
p3.billing_schedule = 'Monthly'
p3.named_insured = ryan_bucket.id
p3.agent = john_doe_agent.id
policies.append(p3)
p4 = Policy("Policy Four", date(2015, 2, 1), 500)
p4.billing_schedule = 'Two-Pay'
p4.named_insured = ryan_bucket.id
p4.agent = john_doe_agent.id
policies.append(p4)
for policy in policies:
db.session.add(policy)
db.session.commit()
for policy in policies:
PolicyAccounting(policy.id)
payment_for_p2 = Payment(p2.id, anna_white.id, 400, date(2015, 2, 1))
db.session.add(payment_for_p2)
db.session.commit()
def insert_data():
# Contacts
contacts = []
john_doe_agent = Contact("John Doe", "Agent")
contacts.append(john_doe_agent)
john_doe_insured = Contact("John Doe", "Named Insured")
contacts.append(john_doe_insured)
bob_smith = Contact("Bob Smith", "Agent")
contacts.append(bob_smith)
anna_white = Contact("Anna White", "Named Insured")
contacts.append(anna_white)
joe_lee = Contact("Joe Lee", "Agent")
contacts.append(joe_lee)
ryan_bucket = Contact("Ryan Bucket", "Named Insured")
contacts.append(ryan_bucket)
for contact in contacts:
db.session.add(contact)
db.session.commit()
policies = []
p1 = Policy("Policy One", date(2015, 1, 1), 365)
p1.billing_schedule = "Annual"
p1.named_insured = john_doe_insured.id
p1.agent = bob_smith.id
policies.append(p1)
p2 = Policy("Policy Two", date(2015, 2, 1), 1600)
p2.billing_schedule = "Quarterly"
p2.named_insured = anna_white.id
p2.agent = joe_lee.id
policies.append(p2)
p3 = Policy("Policy Three", date(2015, 1, 1), 1200)
p3.billing_schedule = "Monthly"
p3.named_insured = ryan_bucket.id
p3.agent = john_doe_agent.id
policies.append(p3)
p4 = Policy("Policy Four", date(2015, 2, 1), 500)
p4.billing_schedule = "Two-Pay"
p4.named_insured = ryan_bucket.id
p4.agent = john_doe_agent.id
policies.append(p4)
for policy in policies:
db.session.add(policy)
db.session.commit()
for policy in policies:
PolicyAccounting(policy.id)
payment_for_p2 = Payment(p2.id, anna_white.id, 400, date(2015, 2, 1))
db.session.add(payment_for_p2)
db.session.commit()
def _reward_create(user, reason, category, recipient, amount, message):
proposal = Proposal(user, reason)
proposal.categories.append(category)
proposal.authorize(user)
db.session.add(proposal)
email = recipient if utils.is_email(recipient) else None
mobile = recipient if utils.is_mobile(recipient) else None
address = recipient if utils.is_address(recipient) else None
payment = Payment(proposal, mobile, email, address, message, amount)
db.session.add(payment)
return proposal, payment
def test_payments(self):
payment = Payment(amount=100, date=date(2011, 6, 15))
expected = [(payment.date, payment.amount)]
actual = payments_to_cashflows(date(2011, 6, 15), [payment])
actual2 = map(cashflow_to_tuple, list(actual))
self.assertEqual(expected, actual2, "payments are counted as positive")
self.assertEqual([],
list(
payments_to_cashflows(date(2011, 6, 14),
[payment])),
"payments are counted only after current date")
def payment():
payment= request.get_json()
payment = Payment(
card_num =payment["card_num"],
card_cvv = payment["card_cvv"],
card_exp= payment ["card_exp"],
card_name=payment["card_name"]
)
db.session.add(payment)
db.session.commit()
return 'payment was succesful'
async def handler(message: types.Message):
if message.text.isdigit():
user = session.query(User).get(1)
payment = Payment(amount=float(message.text),
user_id=user.id,
goal='soe')
session.add(payment)
session.commit()
await message.answer([i.amount for i in session.query(Payment).all()])
def command_execute(table, service_provider, service, service_name,
service_type, amount, status, date, time):
if table == 'payment':
db.session.add(
Payment(service_provider, service, service_name, service_type,
float(amount), status, date, time))
elif table == 'cashback':
db.session.add(
Cashback(service_provider, service, service_name, service_type,
float(amount), status, date, time))
else:
pass
def pay_order(id):
parser = reqparse.RequestParser()
parser.add_argument('pay_type', type=str)
parser.add_argument('amount', type=float)
parser.add_argument('card_info', type=str)
args = parser.parse_args()
pay_type = args.get("pay_type")
amount = args.get("amount")
card_info = None
if pay_type not in ['card', 'cash']:
return jsonify(error='Wrong payment type. (card or cash)'), 400
if pay_type == 'card':
card_info = args.get("card_info")
# print(pay_type, amount, card_info)
for order in orders:
if order.order_id == id:
if order.status == "Cancelled":
return jsonify(error="You order has been cancelled."), 409
for p in payments:
if p.order_id == id:
return jsonify(
error="You already paid for your coffee."), 409
else:
if amount == order.cost:
pay_time = time.ctime()
payments.append(
Payment(id, pay_type, amount, pay_time, card_info))
if pay_type == 'card':
order.payment = {
"pay_time": pay_time,
"pay_type": pay_type,
"card_info": card_info
}
return jsonify(order_id=id,
pay_type=pay_type,
amount=amount,
pay_time=pay_time,
card_info=card_info), 201
else:
order.payment = {
"pay_time": pay_time,
"pay_type": pay_type
}
return jsonify(order_id=id,
pay_type=pay_type,
amount=amount,
pay_time=pay_time), 201
else:
return jsonify(
error="Sorry. The cost is not correct."), 400
return jsonify(order_id=False), 404
def add_payment_in_db(update, context):
""" Add new record with payment in db """
existing_user = identify_user(update)
new_payment = Payment(
price=context.user_data['price'],
payment_info=context.user_data['payment_info'],
category=context.user_data['category'],
date=datetime.today()
)
existing_user.payments.append(new_payment)
existing_user.save()
def update_client(self, client): count = 0 newClient = False clientObj = Client.get_by_id(client.auth.email) if ( clientObj is None ): newClient = True for c in client.child_list: d = datetime.datetime.now() next_month = datetime.datetime(d.year, d.month+1, 1) next_month_string = next_month.isoformat() + '.0000' pay = Payment() pay.start_date = datetime.datetime.strptime(next_month_string, "%Y-%m-%dT%H:%M:%S.%f") pay.end_date = datetime.datetime.strptime(next_month_string, "%Y-%m-%dT%H:%M:%S.%f") pay.pay_date = datetime.datetime.strptime(next_month_string, "%Y-%m-%dT%H:%M:%S.%f") c.payment = pay.put() client.key = ndb.Key(Client, client.auth.email) client.email = client.auth.email for c in client.child_list: KindergartenKey = ndb.Key(Kindergarten, c.kindergarten_id) c.kindergarten_key = KindergartenKey c.parent_id = client.email #c.put() kindergarten = Kindergarten.get_by_id(c.kindergarten_id) for kc in kindergarten.child_list: if ( client.email == kc.parent_id ): kindergarten.child_list.remove(kc) client.put() for c in client.child_list: count = count +1 kindergarten = Kindergarten.get_by_id(c.kindergarten_id) # c.client_email = client.auth.email # c.put() kindergarten.child_list.append(c) if ( count == len( client.child_list) ): kindergarten.put() return client
def create_payment(self, commit=True, *args, **kwargs):
'''
Creates a new payment. Always use this method instead of manually
creating a Payment instance directly.
All arguments are passed directly to Payment constructor.
When implementing a new payment provider, you may overload this method
to return a specialized version of Payment instead.
'''
from models import Payment
payment = Payment(variant=self._variant, *args, **kwargs)
if commit:
payment.save()
return payment
def make_payment(self, contact_id=None, date_cursor=None, amount=0):
if not date_cursor:
date_cursor = datetime.now().date()
if not contact_id:
try:
contact_id = self.policy.named_insured
except:
pass
payment = Payment(self.policy.id, contact_id, amount, date_cursor)
db.session.add(payment)
db.session.commit()
return payment
def __init__(self, table_p, parent, type_=None, payment=None, *args, **kwargs):
QDialog.__init__(self, parent, *args, **kwargs)
self.type_ = type_
self.payment = payment
self.parent = parent
self.table_p = table_p
if self.payment:
self.new = False
self.type_ = payment.type_
self.payment_date_field = FormatDate(self.payment.date)
self.payment_date_field.setEnabled(False)
self.title = u"Modification de {} {}".format(self.payment.type_,
self.payment.libelle)
self.succes_msg = u"{} a été bien mise à jour".format(
self.payment.type_)
if self.type_ == Payment.CREDIT:
amount = payment.credit
elif self.type_ == Payment.DEBIT:
amount = payment.debit
else:
self.new = True
amount = ""
self.payment_date_field = FormatDate(QDate.currentDate())
self.succes_msg = u"Client a été bien enregistré"
self.title = u"Création d'un nouvel client"
self.payment = Payment()
self.setWindowTitle(self.title)
self.amount_field = IntLineEdit(unicode(amount))
self.libelle_field = QTextEdit(self.payment.libelle)
vbox = QVBoxLayout()
formbox = QFormLayout()
formbox.addRow(FormLabel(u"Date : *"), self.payment_date_field)
formbox.addRow(FormLabel(u"Libelle :"), self.libelle_field)
formbox.addRow(FormLabel(u"Montant : *"), self.amount_field)
butt = ButtonSave(u"Enregistrer")
butt.clicked.connect(self.save_edit)
formbox.addRow("", butt)
vbox.addLayout(formbox)
self.setLayout(vbox)
def payments(id=None):
if request.method == 'GET':
if id is not None:
payment = Payment.query.get(
id) # None por defecto si no consigue el registro
if payment:
return jsonify(payment.serialize()), 200
return jsonify({"msg": "Financing Agreement not found"}), 404
else:
payment = Payment.query.all()
payment = list(map(lambda payment: payment.serialize(), payment))
return jsonify(payment), 200
if request.method == 'POST':
urlPDF = request.json.get("urlPDF", None)
amount = request.json.get("amount", None)
bank = request.json.get("bank", None)
payment_method = request.json.get("payment_method", None)
rut = request.json.get("rut", None)
if not urlPDF:
return jsonify({"msg": "URL is required"}), 400
if not amount:
return jsonify({"msg": "Amount is required"}), 400
if not bank:
return jsonify({"msg": "Bank is required"}), 400
if not payment_method:
return jsonify({"msg": "Payment Method is required"}), 400
if not rut:
return jsonify({"msg": "RUT is required"}), 400
payment = Payment.query.filter_by(id=id).first()
if payment:
return jsonify({"msg": "Payment already exists"}), 400
payment = Payment()
payment.urlPDF = urlPDF
payment.amount = amount
payment.bank = bank
payment.payment_method = payment_method
payment.rut = rut
payment.save()
return jsonify({"success": "Payment Register Successfully"}), 200
def payment():
form = PaymentForm(request.form)
users = User.query.filter(User.activated).order_by(User.email.asc())
if request.method == 'POST' and form.validate():
user = User.query.filter(User.id == request.form['user_id']).first()
payment = Payment(user, form.value.data)
dbs.add(payment)
dbs.commit()
flash('Payment added successfully.', 'alert alert-success')
return redirect(url_for('payment'))
else:
data = {'nav_urls': get_urls(), 'active_url': url_for('payment')}
return render_template('payment_add.html',
data=data,
form=form,
users=users)
