def submit_payment():
pform = PaymentForm()
pform.uid.choices = User.get_uids()
if not pform.validate_on_submit():
flash('Payment invalid.')
return redirect(url_for('coffee.admin'))
uid = pform.uid.data
amount = float(pform.amount.data) * 100
user = User.objects.get(id=uid)
transaction = Transaction(user=user,
diff=amount,
description='{} payment from {}'.format(
euros(amount), user.name))
transaction.save()
if user.email:
msg = Message('[Kaffeeministerium] Einzahlung von {}'.format(
euros(amount)))
msg.charset = 'utf-8'
msg.add_recipient(user.email)
msg.body = render_template('mail/payment',
amount=amount,
balance=user.balance)
flash('Mail sent to user {}'.format(user.name))
if not app.config['DEBUG']:
mail.send(msg)
else:
print(u'Sending mail \n{}'.format(msg.as_string()))
return redirect(url_for('coffee.admin'))
def submit_payment():
pform = PaymentForm()
pform.uid.choices = User.get_uids()
if not pform.validate_on_submit():
flash('Payment invalid.')
return redirect(url_for('coffee.admin'))
uid = pform.uid.data
# prevent inaccurate input parsing (see
# https://docs.python.org/3.6/tutorial/floatingpoint.html)
amount = int(round(float(pform.amount.data) * 100))
user = User.objects.get(id=uid)
transaction = Transaction(user=user,
diff=amount,
description='{} payment from {}'.format(
euros(amount), user.name))
transaction.save()
if user.email:
msg = EmailMessage()
msg['Subject'] = f'[Kaffeeministerium] Einzahlung von {euros(amount)}'
msg['From'] = app.config['MAIL_DEFAULT_SENDER']
msg['To'] = user.email
msg.set_content(
render_template('mail/payment',
amount=amount,
balance=user.balance,
minister_name=app.config['MAIL_MINISTER_NAME']))
flash('Mail sent to user {}'.format(user.name))
if not app.config['DEBUG']:
s = getMailServer()
s.send_message(msg)
else:
print(u'Sending mail \n{}'.format(msg.as_string()))
return redirect(url_for('coffee.admin'))
def test_transaction_create_ok(session, data_transaction):
count1 = session.query(Transaction).count()
users = User.get_users(db_session=session)
data = TransactionPost(
reference=data_transaction['reference'],
account=data_transaction['account'],
date=data_transaction['date'],
amount=data_transaction['amount'],
type=data_transaction['type'],
category=data_transaction['category'],
)
Transaction.create(db_session=session, user_id=users[0].id, data=data)
count2 = session.query(Transaction).count()
assert count1 + 1 == count2
def global_api(function):
if function == 'personal_data':
user = User.objects.get(username=current_user.username)
return jsonify(data=user.consumption_list())
if function == 'global_data':
# some renaming
actual_curve = [
dict(date=t['_id'], amount=t['total'])
for t in Transaction.dailyTransactions()
]
consumption_curve = Consumption.dailyConsumptions()
expense_curve = Transaction.dailyExpenses()
# get all unique dates
unique_dates = set([t['_id'] for t in expense_curve
]).union(set([t['_id']
for t in consumption_curve]))
target_curve = []
for date in unique_dates:
amount = (next(
(x['total']
for x in expense_curve if x['_id'] == date), 0) + next(
(x['total']
for x in consumption_curve if x['_id'] == date), 0))
target_curve.append(dict(date=date, amount=amount))
target_curve = sorted(target_curve, key=lambda x: x['date'])
return jsonify(actual_curve=actual_curve, target_curve=target_curve)
if function == 'consumption_times':
""" return a list of consumtion daytimes, in seconds """
def getSecondsOfDay(dates):
for d in dates:
yield d.subtract(years=d.year - 1970,
months=d.month - 1,
days=d.day - 1).timestamp()
consumptions = Consumption.objects(date__gte=pendulum.now().subtract(
days=28))
consumptions4Weeks = [pendulum.instance(c.date) for c in consumptions]
consumptions1Week = [
c for c in consumptions4Weeks
if pendulum.now().subtract(days=7) < c
]
return jsonify(last_four_weeks=list(
getSecondsOfDay(consumptions4Weeks)),
last_week=list(getSecondsOfDay(consumptions1Week)))
return abort(404)
def new_transaction_db(self,
time_stamp,
product_serial_number,
product_name,
product_price,
tran_type,
manufacturer_seller_id,
manufacturer_seller_name,
manufacturer_seller_address,
manufacturer_seller_licence_number,
Status="Pending"):
session = self.session_factory()
tran = Transaction(
time_stamp=time_stamp,
product_serial_number=product_serial_number,
product_name=product_name,
product_price=product_price,
type=tran_type,
manufacturer_seller_id=manufacturer_seller_id,
manufacturer_seller_name=manufacturer_seller_name,
manufacturer_seller_address=manufacturer_seller_address,
manufacturer_seller_licence_number=
manufacturer_seller_licence_number,
Status=Status)
session.add(tran)
session.commit()
latest_tran_id = session.query(Transaction).order_by(
Transaction.transaction_id.desc()).first()
'''
tran_alert = Transaction_Alert(transaction_id = latest_tran_id.transaction_id, status = "Active")
session.add(tran_alert)
session.commit()
'''
session.close()
return latest_tran_id
def handle_all_callback(self, bot, update):
print("1. Received: " + str(datetime.datetime.now().time()))
counter.Counter.add_count()
try:
cbq = update.callback_query
data = cbq.data
if data is None:
return cbq.answer()
conn = self.db.get_connection()
with Transaction(conn) as trans:
user = update.callback_query.from_user
trans.add_user(user.id, user.first_name, user.last_name,
user.username)
payload = json.loads(data)
action_type = payload.get(const.JSON_ACTION_TYPE)
action_id = payload.get(const.JSON_ACTION_ID)
if action_type is None:
return cbq.answer('nothing')
print("1.1. Find handler: " +
str(datetime.datetime.now().time()))
handler = self.get_action_handler(action_type)
print("2. Dispatched: " + str(datetime.datetime.now().time()))
return handler.execute(bot, update, trans, action_id, 0,
payload)
except Exception as e:
logging.exception('handle_all_callback')
def administrate_expenses():
eform = ExpenseForm()
if not eform.validate_on_submit():
for field, errors in eform.errors.items():
for error in errors:
flash(u'Error in the %s field - %s' %
(getattr(eform, field).label.text, error))
return redirect(url_for('coffee.admin'))
description = eform.description.data
amount = eform.amount.data
date = (eform.date.data if eform.date.data != '' else datetime.utcnow())
t = Transaction(diff=100 * amount, date=date, description=description)
t.save()
flash('Transaction stored.')
return redirect(url_for('coffee.admin'))
def backlogs_put(**kwargs):
"""
actually insert transaction
"""
obj = json.loads(request.data.decode('utf-8', 'strict'))
origin_time = datetime.datetime.strptime(
obj['origin_time'], '%Y-%m-%d').date()
operation_time = datetime.datetime.strptime(obj['time'], '%Y-%m-%d').date()
transaction = Transaction(
time=operation_time,
account_id=int(obj['account.id']),
sum=strip_numbers(obj['sum']),
income_id=obj['income.id'],
comment=obj['comment'])
DB.add(transaction)
DB.flush()
if origin_time != operation_time:
# payment before
DB.add(
Payforward(
income_id=int(obj['income.id']),
income_date=origin_time,
payment_date=operation_time,
transaction_id=transaction.record_id
)
)
DB.commit()
return transaction
def test_got_question_twice(self):
transaction = Transaction(bid_id_old=42,
bid_created_at=self.user.created_at,
buyer_user_id=self.user.id,
seller_user_id=self.another_user.id,
value_satoshi=100,
coinbase_order="unknown",
status="wait_for_question")
email = Email(to_user_id=self.user.id, purpose="ask")
transaction.active_emails.append(email)
db.session.add(transaction)
db.session.commit()
from_email = self.user.address_hash + "@example.com"
self.responder.process_email(from_email,
"Hash: %s ..." % (email.email_hash),
"Some question?\n%s" % (from_email))
db.session.refresh(transaction)
db.session.refresh(self.user)
self.assertEqual(len(self.user.active_emails),
1) # We still have verification left
self.trader.question_asked.assert_called_with(self.user, transaction,
"Some question?")
def post_transactions(*,
db_session: Session = Depends(get_db),
payload: TransactionPostList) -> List[TransactionGet]:
user = User.get_user_by_name(db_session=db_session, name=payload.name)
if user is None:
raise HTTPException(status_code=HTTP_404_NOT_FOUND,
detail=messages.USER_NOT_FOUND)
data = []
references_db = Transaction.get_referencez(db_session=db_session)
for transaction in payload.transactions:
if transaction.reference not in references_db:
transaction.user_id = user.id
references_db.append(transaction.reference)
data.append(dict(transaction))
return Transaction.create_bulk(db_session=db_session, data=data)
def test_transaction_get_transaction_by_user_id_date_range(
session, new_user, scenario, start_date, end_date, expected):
assert len(
Transaction.get_transaction_by_user_id_date_range(
db_session=session,
user_id=new_user.id,
start_date=start_date,
end_date=end_date,
)) == expected
def administrate_expenses():
eform = ExpenseForm()
if not eform.validate_on_submit():
for field, errors in eform.errors.items():
for error in errors:
flash(u'Error in the %s field - %s' %
(getattr(eform, field).label.text, error))
return redirect(url_for('coffee.admin'))
description = eform.description.data
# prevent inaccurate input parsing (see
# https://docs.python.org/3.6/tutorial/floatingpoint.html)
amount = int(round(float(eform.amount.data * 100)))
date = (eform.date.data if eform.date.data != '' else datetime.utcnow())
t = Transaction(diff=amount, date=date, description=description)
t.save()
flash('Transaction stored.')
return redirect(url_for('coffee.admin'))
def setUp(self):
testuser = User(username='******', email='*****@*****.**')
testuser.save()
self.testuser = testuser
User(username='******', email='*****@*****.**', admin=True).save()
testpayment = Transaction(diff=1000, user=testuser)
testpayment.save()
testexpense = Transaction(diff=-500)
testexpense.save()
testcons = Consumption(units=1, price_per_unit=50, user=testuser)
testcons.save()
self.app = coffee.app.test_client()
def lunchmoney_id_import(token, year, month):
start_of_day = ("%s-%s-01" % (year, month))
last_day_month = calendar.monthrange(int(year), int(month))[1]
end_of_day = ("%s-%s-%s" % (year, month, last_day_month))
query_result = json.loads(
Lunchmoney(token=str(token)).getAllTransactions({
'start_date': start_of_day,
'end_date': end_of_day
}))
for row in query_result['transactions']:
(Transaction.update(lunchmoney_id=row['id']).where(
Transaction.id == row['external_id'])).execute()
def store_plaid_transactions(transactionsResponse):
for transactionResponse in transactionsResponse:
transactionEntity = Transaction(
id=transactionResponse['transaction_id'],
account_id=transactionResponse['account_id'],
account_owner='Caleb Kumar',
name=str(transactionResponse['name']),
amount=transactionResponse['amount'],
date=datetime.strptime(transactionResponse['date'], '%Y-%m-%d'),
default_transaction_type=transactionResponse['transaction_type'],
# TODO: Iterate over list of categories
default_category1=str(transactionResponse['category']))
def new_bill(self, bot, update):
# only allow private message
try:
conn = self.db.get_connection()
handler = self.get_action_handler(const.TYPE_CREATE_BILL)
with Transaction(conn) as trans:
handler.execute(bot,
update,
trans,
action_id=create_bill_handler.ACTION_NEW_BILL)
except Exception as e:
logging.exception('new_bill')
def data_export(token):
query_result = Transaction.select(
Transaction.id, Transaction.data,
Transaction.asset_id).where(Transaction.lunchmoney_id.is_null(True))
result = []
for row in query_result:
data = dict(row.data)
data.update({'asset_id': row.asset_id})
data.update({'external_id': row.id})
result.append(data)
response = Lunchmoney(token=str(token)).insertTransactions(result)
print(response)
def transactions_post(**kwargs):
obj = json.loads(request.data.decode('utf-8', 'strict'))
# try:
i = Transaction(
time=datetime.datetime.strptime(obj['time'], '%Y-%m-%d').date(),
account_id=int(obj['account.id']),
sum=decimal.Decimal(strip_numbers(obj['sum'])),
transfer=int(obj['transfer']) if int(obj['transfer']) > 0 else None,
income_id=int(obj['income.id']) if int(obj['income.id']) > 0 else None,
comment=obj['comment']
)
DB.add(i)
DB.flush()
if 'new_account.id' in obj:
transfer = Transaction(
time=datetime.datetime.strptime(obj['time'], '%Y-%m-%d').date(),
account_id=int(obj['new_account.id']),
sum=decimal.Decimal(strip_numbers(obj['new_sum'])),
transfer=int(obj['transfer']) if int(obj['transfer']) > 0 else None,
comment=obj['comment'],
income_id=int(obj['income.id']) if int(obj['income.id']) > 0 else None
)
DB.add(transfer)
DB.flush()
i.transfer = transfer.record_id
transfer.transfer = i.record_id
DB.commit()
# except:
# abort(400)
return i
def backlogs_delete(**kwargs):
# just create transaction with sum zero
obj = json.loads(request.data.decode('utf-8', 'strict'))
t = Transaction(
time=datetime.datetime.strptime(obj['origin_time'], '%Y-%m-%d').date(),
account_id=0,
sum=0,
income_id=obj['income.id'],
comment='cancelled')
DB.add(t)
DB.flush()
DB.commit()
return t
def accounts_put(**kwargs):
a = DB.query(Account).get(kwargs['id'])
obj = json.loads(request.data.decode('utf-8', 'strict'))
a.title = obj['title']
a.show = obj['show']
a.currency_id = obj['currency.id']
delta_sum = decimal.Decimal(strip_numbers(obj['sum'])) - a.sum()
if delta_sum != 0:
t = Transaction(time=datetime.date.today(), sum=delta_sum,
account_id=kwargs['id'], comment='fix account summ')
DB.add(t)
DB.commit()
return {'updated': DB.query(Account).get(kwargs['id']), "previous": a}
def scenario(session, new_user):
data_1 = dict(user_id=new_user.id,
reference='000051',
account='C00099',
date='2020-01-03',
amount=-51.13,
type='outflow',
category='groceries')
data_2 = dict(user_id=new_user.id,
reference='000052',
account='C00099',
date='2020-01-10',
amount=2500.72,
type='inflow',
category='salary')
data_3 = dict(user_id=new_user.id,
reference='000053',
account='C00099',
date='2020-01-10',
amount=-150.72,
type='outflow',
category='transfer')
data_4 = dict(user_id=new_user.id,
reference='000054',
account='C00099',
date='2020-01-13',
amount=-560.00,
type='outflow',
category='rent')
data_5 = dict(user_id=new_user.id,
reference='000689',
account='S00012',
date='2020-01-10',
amount=150.72,
type='inflow',
category='savings')
Transaction.create_bulk(db_session=session,
data=[data_1, data_2, data_3, data_4, data_5])
def handle_inline(self, bot, update):
try:
conn = self.db.get_connection()
handler = self.get_action_handler(const.TYPE_SHARE_BILL)
with Transaction(conn) as trans:
user = update.inline_query.from_user
trans.add_user(user.id, user.first_name, user.last_name,
user.username)
handler.execute(bot,
update,
trans,
action_id=share_bill_handler.ACTION_FIND_BILLS)
except Exception as e:
logging.exception('handle_inline')
def new_transaction(session, new_user, data_transaction):
data = TransactionPost(
reference=data_transaction['reference'],
account=data_transaction['account'],
date=data_transaction['date'],
amount=data_transaction['amount'],
type=data_transaction['type'],
category=data_transaction['category'],
)
return Transaction.create(
db_session=session,
user_id=new_user.id,
data=data,
)
def start(self, bot, update, args):
# TODO: make command list screen
if args is not None and len(args) == 1:
handler = manage_bill_handler.BillManagementHandler()
conn = self.db.get_connection()
data = {const.JSON_BILL_ID: args[0]}
with Transaction(conn) as trans:
handler.execute(bot,
update,
trans,
action_id=manage_bill_handler.ACTION_SEND_BILL,
data=data)
return
bot.sendMessage(chat_id=update.message.chat_id, text="Start screen")
def test_transaction_get_summary_by_category_ok(session, new_user, scenario):
expected = {
"inflow": {
"salary": 2500.72,
"savings": 150.72
},
"outflow": {
"groceries": -51.13,
"rent": -560.00,
"transfer": -150.72
}
}
assert Transaction.get_summary_by_category(db_session=session,
user_id=new_user.id) == expected
def test_transaction_create_bulk_ok(session, new_user):
count1 = session.query(Transaction).count()
data_1 = dict(
user_id=new_user.id,
reference='reference1',
account='account',
date='2020-02-02',
amount=1.00,
type='inflow',
category='category',
)
data_2 = dict(
user_id=new_user.id,
reference='reference2',
account='account',
date='2020-02-02',
amount=1.00,
type='inflow',
category='category',
)
Transaction.create_bulk(db_session=session, data=[data_1, data_2])
count2 = session.query(Transaction).count()
assert count1 + 2 == count2
def get_summary_by_category(
*,
db_session: Session = Depends(get_db),
name: str,
start_date: date = None,
end_date: date = None,
) -> TransactionSummaryByCategory:
user = User.get_user_by_name(db_session=db_session, name=name)
if user is None:
raise HTTPException(status_code=HTTP_404_NOT_FOUND,
detail=messages.USER_NOT_FOUND)
return Transaction.get_summary_by_category(db_session=db_session,
user_id=user.id,
start_date=start_date,
end_date=end_date)
def start(self, bot, update, args):
# TODO: make command list screen
if args is not None and len(args) == 1:
handler = manage_bill_handler.BillManagementHandler()
conn = self.db.get_connection()
data = {const.JSON_BILL_ID: args[0]}
with Transaction(conn) as trans:
msg = update.message
trans.reset_session(msg.chat_id, msg.from_user.id)
handler.execute(bot,
update,
trans,
action_id=manage_bill_handler.ACTION_SEND_BILL,
data=data)
return
self.send_help_msg(bot, update)
def accounts_post(**kwargs):
""" add new account and set first transaction with rests of money """
obj = json.loads(request.data.decode('utf-8', 'strict'))
new_account = Account(
title=obj['title'],
currency_id=int(obj['currency.id']))
DB.add(new_account)
DB.flush()
if float(strip_numbers(obj['sum'])) > 0:
DB.add(Transaction(account_id=new_account.record_id,
show=obj['show'],
comment='initial summ',
time=datetime.date.today(),
sum=strip_numbers(obj['sum'])))
DB.commit()
return new_account
def test_transaction_get_summary_by_account_ok(session, new_user, scenario):
expected = [
{
"account": "C00099",
"balance": 1738.87,
"total_inflow": 2500.72,
"total_outflow": -761.85
},
{
"account": "S00012",
"balance": 150.72,
"total_inflow": 150.72,
"total_outflow": 0.00
},
]
assert Transaction.get_summary_by_account(db_session=session,
user_id=new_user.id) == expected
