def transaction_equals(self):
# success
obj1 = models.Transaction()
obj2 = models.Transaction()
self.assertTrue(obj1 == obj2)
# failure
obj2.id = 532
self.assertFalse(obj1 == obj2)
def ParseLine(self, line_dict): date_str = line_dict[self.DATE_FIELD] date = datetime.datetime.strptime(date_str, self.DATE_FORMAT).date() amount = float(line_dict[self.AMOUNT_FIELD]) description = line_dict[self.DESC_FIELD] type = line_dict[self.TYPE_FIELD] if self.TYPE_FIELD else None return models.Transaction(date, amount, description, type)
def show_depo_money():
accntid = request.form['accntid']
accountone = models.Account.query.filter_by(accntid=accntid).first()
account = models.Account.query.filter_by(accntid=accntid).all()
depositeamt = int(request.form['depositeamt'])
temp = accountone.ammount + depositeamt
accountone.ammount = temp
db.session.commit()
transaction = models.Transaction(accnt_id=accntid,
customer_cid=accountone.customer_cid,
ammount=depositeamt,
transaction_date=datetime.now(),
mode="Deposite",
source_acc_type=accountone.accnt_type,
target_acc_type=accountone.accnt_type)
if (transaction is not None):
db.session.add(transaction)
db.session.commit()
flash("Transaction Created successfully!", "success")
else:
flash("Transaction creation failed.", "danger")
db.session.add(transaction)
db.session.commit()
flash("Ammount Deposited,Successfully", "sucess")
return render_template("Cashier/show_acc_info.html", data=account)
def action(self, profile, ledger):
participant_profiles = ledger.participant_profiles()
creditor_profile = models.Profile.get_by_key_name(
self.request.get('creditor'))
debtor_profile = models.Profile.get_by_key_name(
self.request.get('debtor'))
if not (creditor_profile and debtor_profile):
return {'add_error': 'User can not be found'}
if creditor_profile.key() == debtor_profile.key():
return {'add_error': 'From and To profiles cannot be the same'}
if not (any(creditor_profile.key() == p.key()
for p in participant_profiles)
and any(debtor_profile.key() == p.key()
for p in participant_profiles)):
return {'add_error': 'Profile is not a member of this ledger'}
try:
amount = decimal.Decimal(self.request.get('amount'))
if amount <= 0:
raise TypeError
except (decimal.InvalidOperation, TypeError):
return {'add_error': 'Invalid transaction amount'}
else:
models.Transaction(parent=ledger,
from_profile=creditor_profile,
to_profile=debtor_profile,
amount_cents=int(amount * 100),
notes=self.request.get('notes')).put()
def show_withdraw_money():
accntid = request.form['accntid']
accountone = models.Account.query.filter_by(accntid=accntid).first()
account = models.Account.query.filter_by(accntid=accntid).all()
withdrawamt = int(request.form['withdrawamt'])
if withdrawamt > accountone.ammount:
flash("Insufficient Balance Ammount for withdraw.", "danger")
return render_template("Cashier/show_acc_info.html", data=account)
else:
transaction = models.Transaction.query.filter_by(
transaction_date=datetime.now())
temp = accountone.ammount - withdrawamt
accountone.ammount = temp
db.session.commit()
transaction = models.Transaction(accnt_id=accntid,
customer_cid=accountone.customer_cid,
ammount=withdrawamt,
transaction_date=datetime.now(),
mode="withdraw",
source_acc_type=accountone.accnt_type,
target_acc_type=accountone.accnt_type)
if (transaction is not None):
db.session.add(transaction)
db.session.commit()
flash("Transaction Created successfully!", "success")
else:
flash("Transaction creation failed.", "danger")
flash("Ammount Withdrawed Successfully", "sucess")
return render_template("Cashier/show_acc_info.html", data=account)
def get_txn_obj(txn):
"""
get transaction object from dict
"""
kargs = dict((i, txn[i]) for i in txn.keys())
del kargs['ac_id']
return models.Transaction(**kargs)
def ParseLine(self, line_parts):
if not line_parts:
return None
date_str = line_parts[0]
date = datetime.datetime.strptime(date_str, '%m/%d/%Y').date()
description = line_parts[2]
amount = float(line_parts[3])
type = line_parts[4]
return models.Transaction(date, amount, description, type)
def ParseLine(self, line_dict):
date = datetime.datetime.strptime(line_dict['交易日期'], '%Y-%m-%d').date()
amount_str_out = self._Strip(line_dict['支出'])
amount_str_in = self._Strip(line_dict['存入'])
description = line_dict['交易类型'] + ' ' + line_dict['交易备注']
if amount_str_out:
amount = -float(amount_str_out)
else:
amount = float(amount_str_in)
return models.Transaction(date, amount, description, None)
def deser_tx(f):
if type(f) is not io.BytesIO:
f = io.BytesIO(f)
tx = models.Transaction()
tx.version = deser_uint32(f.read(4))
tx.inputs = deser_vector(f, models.TxIn)
tx.outputs = deser_vector(f, models.TxOut)
tx.locktime = deser_uint32(f)
return tx
def transactions_bank_statement_review(request):
""" Allow the user to change the data in the transactions before importing """
def class_gen_with_kwarg(cls, **additionalkwargs):
"""
class generator for subclasses with additional 'stored' parameters (in a closure)
This is required to use a modelformset_factory with a form that needs additional
initialization parameters (see http://stackoverflow.com/questions/622982/django-passing-custom-form-parameters-to-formset)
"""
class ClassWithKwargs(cls):
def __init__(self, *args, **kwargs):
kwargs.update(additionalkwargs)
super(ClassWithKwargs, self).__init__(*args, **kwargs)
return ClassWithKwargs
# create the formset
pending_imports = models.TransactionImportPending.objects.filter(
owner=request.user)
TransactionImportPendingFormset = modelformset_factory(models.TransactionImportPending, \
form=class_gen_with_kwarg(forms.TransactionImportPendingForm, request=request), \
fields=['date', 'amount', 'description', 'tenancy', 'building', 'person', 'category'],\
extra=0)
if request.method == 'POST':
# save the user's changes
formset = TransactionImportPendingFormset(request.POST)
if formset.is_valid():
formset.save()
# convert transaction import pending to transactions
if request.POST.get('import', False) != False:
for record_data in formset.cleaned_data:
record_id = record_data.pop('id').id
record_data['owner'] = request.user
transaction = models.Transaction(**record_data)
transaction.save()
models.TransactionImportPending.objects.filter(
owner=request.user, id=record_id).delete()
# redirect to transactions
return HttpResponseRedirect(reverse('transactions'))
return render(request,
'website/transactions_bank_statement_review.html',
{'formset': formset})
else:
# redirect to upload if no pending imports
if not pending_imports:
return HttpResponseRedirect(
reverse('transactions_bank_statement_upload'))
# show the unbound formset with all their pending imports
formset = TransactionImportPendingFormset(queryset=pending_imports)
return render(request,
'website/transactions_bank_statement_review.html',
{'formset': formset})
def _pay_any(debtors, creditors, d):
'''Make payments to as many creditors as necessary to fully pay off the debtor's debt'''
transactions = []
for c in creditors:
if creditors[c] > 0:
if -debtors[d] < creditors[c]:
transactions.append(
models.Transaction(from_profile=d,
to_profile=c,
amount_cents=-debtors[d]))
debtors[d] = creditors[c] = 0
return transactions
transactions.append(
models.Transaction(from_profile=d,
to_profile=c,
amount_cents=creditors[c]))
debtors[d] += creditors[c]
creditors[c] = 0
if debtors[d] == 0:
return transactions
return transactions
def create_transaction(money, project_id, reasons=(), user_variables=()):
m = Multipay(money, project_id, reasons, user_variables)
response = m.execute()
transaction = models.Transaction(transaction=response.transaction,
payment_url=response.payment_url)
transaction.save()
for warning in response.warnings:
w = models.Warning(code=warning.code, message=warning.code)
w.save()
transaction.warnings.add(w)
transaction.save()
return transaction
def __parse_tx(tx, block_id):
out = {}
out['gas_wanted'] = int(tx['gasWanted'])
out['gas_used'] = int(tx['gasUsed'])
out['log'] = tx['log']
events = tx['events']
if events:
out['success'] = True
out['events'] = parse_events(events, block_id)
else:
out['success'] = False
return models.Transaction(**out)
def _pay_matching(debtors, creditors, d):
'''Try to pay off two balances at the same time.'''
transactions = []
for c in creditors:
if debtors[d] + creditors[c] == 0:
transactions.append(
models.Transaction(from_profile=d,
to_profile=c,
amount_cents=-debtors[d]))
debtors[d] = creditors[c] = 0
return transactions
return transactions
def testEntityCD(self):
logging.debug('Testing entity create & delete...')
sponsor = models.Sponsor()
sponsor.name = 'Test Sponsor'
sponsor.url = 'http://www.redcross.com'
sponsor.address = '123 blaj blah, blah WA,USA'
sponsor.phone = '(555)555-555'
sponsor.put()
assert sponsor.key()
test_client = models.Client()
test_client.set_defaults()
test_client.displayName = "Bob"
test_client.fullName = "Bob the builder"
test_client.story = lorem_ipsum
test_client.sponsor = sponsor
test_client.imageURL = "http://www.test.org/img.png"
test_client.put()
assert test_client.key()
test_donor = models.Donor()
test_donor.address = "123 123 123"
test_donor.name = "Donor"
test_donor.phone = "(206)555-5555"
test_donor.put()
assert test_donor.key()
test_user = models.User()
test_user.user = users.get_current_user()
test_user.isAdmin = True
test_user.sponsor = sponsor
test_user.put()
assert test_user.key()
tx = models.Transaction()
fromAccount = 'stripe'
toAccount = '%s/%s' % (sponsor.key(), test_client.key())
amount = 1.00
type = 'CREDIT'
note = 'A donation from Bob'
confirm = False
tx.put()
# clean up
tx.delete()
test_user.delete()
test_client.delete()
sponsor.delete()
test_donor.delete()
self.response.out.write("<html><body><p>Test Passed!</p></body></html>")
def post(self):
parameters = None
if self.request.POST:
parameters = self.request.POST.copy()
if self.request.GET:
parameters = self.request.GET.copy()
if parameters:
# Send the notification back to Paypal for verification
parameters['cmd'] = '_notify-validate'
params = urllib.urlencode(parameters)
status = urlfetch.fetch(
url=PP_URL,
method=urlfetch.POST,
payload=params,
).content
payment = models.Transaction(
receiver_email=parameters['receiver_email'],
transaction_id=parameters['txn_id'],
transaction_type=parameters['txn_type'],
payment_type=parameters['payment_type'],
payment_status=parameters['payment_status'],
amount=parameters['mc_gross'],
currency=parameters['mc_currency'],
payer_email=parameters['payer_email'],
first_name=parameters['first_name'],
last_name=parameters['last_name'],
verified=False)
# Insert new transactions in the database.
if models.Transaction.transaction_exists(payment.transaction_id,
payment.payment_status):
# This transaction has already been verified and processed.
logging.debug('Transaction already exists')
# Verify that the payment is confirmed by PayPal and that it is going to the correct account
elif status == "VERIFIED" and payment.receiver_email == ACCOUNT_EMAIL:
if payment.payment_status == "Completed":
payment.verified = True
# Insert actions to take if a completed transaction is received here:
else:
payment.verified = False
# Insert actions to take if a transaction with unverified payment is received here:
# Insert new (verified) transactions in the database. You may wish to store/log unverified transactions as well as these may be malicious.
payment.put()
logging.debug('New transaction added to database')
def _pay_forward(debtors, creditors, d):
'''Try to pay off one balance now, and set up the creditor to be paid off fully in the next transaction.'''
transactions = []
for other_debtor in debtors:
if d is not other_debtor:
for c in creditors:
if debtors[d] + debtors[other_debtor] + creditors[c] == 0:
transactions.append(
models.Transaction(from_profile=d,
to_profile=c,
amount_cents=-debtors[d]))
creditors[c] += debtors[d]
debtors[d] = 0
return transactions
return transactions
def create_transaction_record(
db: Session,
to_customer_wallet: models.CustomersWallet,
to_amount: Decimal,
from_amount: Decimal,
from_currency: models.Currency,
from_customer_wallet: models.CustomersWallet = None,
):
db_transaction = models.Transaction(
from_customer_wallet=from_customer_wallet,
to_customer_wallet=to_customer_wallet,
from_amount=from_amount,
to_amount=to_amount,
from_currency=from_currency,
)
db.add(db_transaction)
def show_transfer_money():
accntid = request.form['accntid']
cusid = request.form['cus_id']
curracc = request.form['accnt_type']
targetacc = request.form['targetaccnt_type']
transferammount = int(request.form['transferamt'])
accountcurr = models.Account.query.filter_by(customer_cid=cusid,
accnt_type=curracc).first()
print(accountcurr)
accounttarget = models.Account.query.filter_by(
customer_cid=cusid, accnt_type=targetacc).first()
print(accounttarget)
account = models.Account.query.filter_by(customer_cid=cusid).all()
if (accountcurr is None):
flash('"first create"+{{curracc}}+" than transfer"')
return render_template("Cashier/show_acc_info.html", data=account)
elif (accounttarget is None):
flash('"first create"+{{targetacc}}+"than transfer"')
return render_template("Cashier/show_acc_info.html", data=account)
elif (transferammount > accountcurr.ammount):
flash("Insufficient Balance Ammount for withdraw.", "danger")
return render_template("Cashier/show_acc_info.html", data=account)
elif (accountcurr and accounttarget):
# transaction=models.Transaction.query.filter_by(transaction_date=datetime.now())
# if(transaction is None):
transaction = models.Transaction(accnt_id=accntid,
customer_cid=cusid,
ammount=transferammount,
transaction_date=datetime.now(),
mode="Transfer",
source_acc_type=curracc,
target_acc_type=targetacc)
if (transaction is not None):
db.session.add(transaction)
db.session.commit()
flash("Transaction Created successfully!", "success")
else:
flash("Transaction creation failed.", "danger")
withdraw = accountcurr.ammount - transferammount
accountcurr.ammount = withdraw
deposite = accounttarget.ammount + transferammount
accounttarget.ammount = deposite
db.session.commit()
flash("Ammount transfered Successfully", "sucess")
return render_template("Cashier/show_acc_info.html", data=account)
def post(self):
action = self.request.get('action')
if action == 'add':
transaction = models.Transaction()
transaction.doc_id = users.get_current_user().user_id()
transaction.product = 'Product XXXXXXX'
transaction.rentee_id = 'John Carter'
transaction.email = '*****@*****.**'
transaction.phone_number = '514-123-4567'
transaction.meet_point = '1111 Barclay # 1'
transaction.pick_up_date = '20/4/2016'
transaction.return_date = '20/4/2016'
transaction.amount_paid = '90$'
transaction.put()
self.buildViewTransactionsPage(notification='Transaction Add')
elif action == 'delete':
models.Transaction.deleteTransactions()
self.buildViewTransactionsPage(notification='Transaction Deleted')
def action(self, profile, ledger):
participant_profiles = ledger.participant_profiles()
from_profile = models.Profile.get_by_key_name(self.request.get('from'))
if not from_profile:
return {'bill_error': 'Invalid profile'}
if not any(from_profile.key() == p.key()
for p in participant_profiles):
return {'bill_error': 'Profile is not a member of this ledger'}
try:
amount = decimal.Decimal(self.request.get('amount'))
if amount <= 0:
raise TypeError
except (decimal.InvalidOperation, TypeError):
return {'bill_error': 'Invalid transaction amount'}
else:
amount_cents = int(amount * 100 / len(participant_profiles))
for to_profile in participant_profiles:
if from_profile.key() != to_profile.key():
models.Transaction(parent=ledger,
from_profile=from_profile,
to_profile=to_profile,
amount_cents=amount_cents,
notes=self.request.get('notes')).put()
def get(self):
"""Do a document search for the given product id,
and display the retrieved document fields."""
params = self.parseParams()
pid = params['pid']
if not pid:
# we should not reach this
msg = 'Error: do not have product id.'
url = '/'
linktext = 'Go to product search page.'
self.render_template(
'notification.html',
{'title': 'Error', 'msg': msg,
'goto_url': url, 'linktext': linktext})
return
doc = docs.Product.getDocFromPid(pid)
logging.info(doc)
if not doc:
error_message = ('Document not found for pid %s.' % pid)
return self.abort(404, error_message)
logging.error(error_message)
date_format = "%Y-%m-%d"
pickupD = (datetime.strptime(self.request.get('pickupD'), date_format))
returnD = (datetime.strptime(self.request.get('returnD'), date_format))
logging.info("pickup: %s", pickupD)
logging.info("return: %s", returnD)
c = returnD - pickupD
logging.info("c: %s", c)
c = int(c.days)
logging.info("days: %d", c)
pdoc = docs.Product(doc)
pname = pdoc.getName()
price = pdoc.getPrice()
ppacc = pdoc.getMerchant()
amount_paid = float(price) * int(c)
app_url = wsgiref.util.application_uri(self.request.environ)
template_values = {
'app_url': app_url,
'pid': pid,
'pname': pname,
'price': price,
'ppacc': ppacc,
'pickupD': pickupD.date(),
'returnD': returnD.date(),
'amount_paid': amount_paid,
'image_url': pdoc.getImageUrl(),
'prod_doc': doc,
# for this demo, 'admin' status simply equates to being logged in
'user_is_admin': users.get_current_user()}
logging.info("name: %s", pname)
logging.info("name: %s", pickupD.date())
logging.info("name: %s", returnD.date())
logging.info("name: %s", amount_paid)
user = users.get_current_user()
userinfo = ndb.Key(models.UserInfo, pdoc.getUserId()).get()
transaction = models.Transaction(
t_id = uuid.uuid4().hex, # auto-generate default UID
rentee_id = user.user_id(), # give id automatically to product
renter_id = pdoc.getUserId(),
amount_paid = amount_paid,
pickupD = pickupD.date(),
returnD = returnD.date(),
meet_point = userinfo.meetPoint,
doc_id = user.user_id(),
product = pname,
email = userinfo.email,
#dateSent = '',
#payment_status = ndb.StringProperty(),
verified = False
)
transaction.put()
logging.info('transaction saved')
logging.info('template_values :')
logging.info(template_values)
self.render_template('order.html', template_values)
def _instantiate_transactions(sections):
transactions = list()
for _, section in sections.items():
transactions.append(models.Transaction(section))
return transactions
def purchase():
# Create the form
purchase_form = forms.PurchaseForm()
# If a POST request
if flask.request.method == 'POST' and purchase_form.validate_on_submit():
pending_transaction = models.PendingTransaction.query.filter(
models.PendingTransaction.barcode ==
purchase_form.barcode.data)
# If not found, we have an error - we would also confirm payment here
if pending_transaction.count() < 1:
data = {
'barcode': pending_transaction.barcode,
'status': 'fail'
}
else:
pending_transaction = pending_transaction.first()
# Update the status of the transaction
pending_transaction.status = 2;
# Create a transaction
new_transaction = models.Transaction(
user_id=login.current_user.id,
company=pending_transaction.company,
amount=pending_transaction.amount
)
db.session.add(new_transaction)
db.session.commit()
data = {
'barcode': pending_transaction.barcode,
'status': 'success'
}
# Let the Vendor agent know that the item has been paid for
vendor = models.Vendor.query.filter(models.Vendor.id ==
pending_transaction.company).first()
data['secret'] = vendor.secret
url = vendor.agent_url + '/dispense'
headers = {'Content-type': 'application/json', 'Accept': 'text/plain'}
r = requests.post(url, data=json.dumps(data), headers=headers)
# Redirect to dashboard
return flask.redirect(flask.url_for('dashboard'))
# If not a post request
# Create barcode and update form
i2of5_code = ''.join(random.choice(string.digits) for x in range(10))
purchase_form = forms.PurchaseForm(barcode=i2of5_code)
# Add to list of pending transactions
new_pending_transaction = models.PendingTransaction(
user_id=login.current_user.id,
barcode=i2of5_code
)
db.session.add(new_pending_transaction)
db.session.commit()
# Get image URL
url = 'http://www.barcodes4.me/barcode/i2of5/' + \
i2of5_code + '.jpg'
return flask.render_template('purchase.epy', user=login.current_user,
purchase_form=purchase_form, barcode=i2of5_code, img_url=url)
