def new_mission():
form = NewMissionForm()
if form.validate_on_submit():
the_other_user = UserBasic.query.filter_by(username=form.participant.data).first()
if(form.mission_type.data == 'pk'):
mission = Mission(mission_type=form.mission_type.data, level=form.level.data, start_date=form.start_date.data, prize=form.prize.data, end_date=form.end_date.data, users=[current_user, the_other_user])
elif(form.mission_type.data == 'gift'):
mission = Mission(mission_type=form.mission_type.data, level=form.level.data, start_date=form.start_date.data, prize=form.prize.data, end_date=form.end_date.data, users=[the_other_user])
if form.mission_type.data == 'pk':
t = Transaction(transaction_type='new_mission', value=-form.prize.data, user=current_user, transaction_comment='PK with '+the_other_user.username)
db.session.add(t)
db.session.commit()
flash('New transaction updated!')
t = Transaction(transaction_type='new_mission', value=-form.prize.data, user=the_other_user, transaction_comment='PK with '+current_user.username)
db.session.add(t)
db.session.commit()
flash('New transaction updated!')
elif form.mission_type.data == 'gift':
t = Transaction(transaction_type='gift', value=-form.prize.data, user=current_user, transaction_comment='Gift to '+the_other_user.username)
db.session.add(t)
db.session.commit()
flash('New transaction updated!')
db.session.add(mission)
db.session.commit()
flash('New mission added!')
return redirect(url_for('mission.my_mission'))
return render_template("mission/new_mission.html", form=form)
def api_view(request, user):
try:
data = json.loads(request.data.decode('utf-8'))
except json.JSONDecodeError:
return bad_json()
# validate fields
if 'model' not in data:
return bad_request("No `model` prodivded in request")
model = data['model']
if 'n' in data:
try:
n = int(data['n'])
except ValueError:
return bad_request("Value given for `n` is not valid: " +
str(data['n']))
if n < 1:
return bad_request("Value given for `n` is less than 1")
else:
n = 1
if 'refresh' in data:
refresh = data['refresh']
if type(refresh) is not bool:
return bad_request("Value given for `refresh` is not valid: " +
str(refresh))
else:
refresh = True
# do transaction
record = json.dumps({'model': model, 'n': n})
last_trans = Transaction.query.filter_by(request=record, user=user).first()
if refresh or last_trans is None:
# TODO deal with bad model
data_out, cost = jg.generate(model, n)
response = json.dumps(data_out)
transaction = Transaction(user=user,
cost=cost,
request=record,
response=response,
time=datetime.now())
else:
response = last_trans.response
transaction = Transaction(user=user,
cost=last_trans.cost,
request=record,
response=last_trans.response,
time=datetime.now())
db.session.add(transaction)
db.session.commit()
return response
def test_seed():
user_list = [User(email='*****@*****.**'), User(email='*****@*****.**')]
transaction_list = [
Transaction(date=date(2019, 1, 12),
buy_currency='BTC',
buy_amount=1.1,
sell_currency='USD',
sell_amount=1000,
user_id=1),
Transaction(date=date(2019, 3, 12),
buy_currency='USD',
buy_amount=600.0,
sell_currency='BTC',
sell_amount=0.7,
user_id=1),
Transaction(date=date(2019, 5, 20),
buy_currency='ETH',
buy_amount=5.0,
sell_currency='USD',
sell_amount=1200.0,
user_id=1),
Transaction(date=date(2019, 5, 20),
buy_currency='ETH',
buy_amount=5.0,
sell_currency='USD',
sell_amount=1200.0,
user_id=2)
]
currency_list = [
Currency(cd='USD', name='United States Dollar', asset_type='fiat'),
Currency(cd='GBP', name='British Pound', asset_type='fiat'),
Currency(cd='BTC', name='Bitcoin', asset_type='crypto'),
Currency(cd='LTC', name='Litecoin', asset_type='crypto'),
Currency(cd='ETH', name='Ethereum', asset_type='crypto')
]
curr_dt = datetime.today()
last_month = curr_dt + timedelta(days=-30)
price_list = [
Price(ts=last_month,
buy_currency='BTC',
sell_currency='USD',
rate=10000),
Price(ts=curr_dt, buy_currency='BTC', sell_currency='USD', rate=15000),
Price(ts=last_month, buy_currency='ETH', sell_currency='USD',
rate=100),
Price(ts=curr_dt, buy_currency='ETH', sell_currency='USD', rate=200),
Price(ts=last_month, buy_currency='USD', sell_currency='USD', rate=1),
Price(ts=curr_dt, buy_currency='USD', sell_currency='USD', rate=1)
]
drop_create_tables(3, 5)
add_records(user_list, transaction_list, currency_list, price_list)
def seed_transactions():
x1 = Transaction(
group_id=1,
payer_id=1,
paid_amount=111,
description="Butterbeer round one!",
expense_date="2020-09-05 09:45:28",
completed=False,
updated_at="2020-09-05 09:45:28",
)
db.session.add(x1)
x2 = Transaction(
group_id=2,
payer_id=2,
paid_amount=222,
description="Butterbeer round 2!",
expense_date="2020-09-05 09:45:28",
completed=False,
updated_at="2020-09-05 09:45:28",
)
db.session.add(x2)
x3 = Transaction(
group_id=1,
payer_id=3,
paid_amount=333,
description="New Owl",
expense_date="2020-09-05 09:45:28",
completed=False,
updated_at="2020-09-05 09:45:28",
)
db.session.add(x3)
x4 = Transaction(
group_id=2,
payer_id=1,
paid_amount=444,
description="Broomstick",
expense_date="2020-09-05 09:45:28",
completed=False,
updated_at="2020-09-05 09:45:28",
)
db.session.add(x4)
db.session.commit()
def purchase(username):
user = UserProfile.query.filter_by(username=username)
if user is not None:
user = user.first()
coin_name = request.form['coin_name'] or None
coin_conversion_rate = float(request.form['coin_conversion_rate'])
purchase_amount = float(request.form['purchase_amount'])
if purchase_amount <= user.balance:
number_of_coins = purchase_amount / coin_conversion_rate
coin_investment_instance = None
for coin in user.coin_investments:
if coin.coin_name == coin_name:
coin_investment_instance = coin
break
if coin_investment_instance is None:
coin_investment_instance = Investment(user_id=user.id, coin_name=coin_name,
number_of_coins=number_of_coins, total_price=purchase_amount)
else:
coin_investment_instance.number_of_coins += number_of_coins
coin_investment_instance.total_price += purchase_amount
db.session.add(coin_investment_instance)
db.session.commit()
transaction = Transaction(investment_id=coin_investment_instance.id, coin_name=coin_name,
number_of_coins=number_of_coins, total_price=purchase_amount)
db.session.add(transaction)
db.session.commit()
user.balance -= purchase_amount
db.session.add(user)
db.session.commit()
return redirect(url_for('investments.dashboard', username=user.username))
else:
flash("Insufficient balance.")
return redirect(url_for('investments.checkprice', username=user.username))
else:
return render_template('404_error')
def add_transaction(account_id):
account = Account.query.get(account_id)
form = AddTransactionForm()
form.category.choices = build_user_category_array(current_user)
if form.validate_on_submit():
if form.transaction_type.data=='Expense':
amount = decimal.Decimal(0.00) - form.amount.data
elif form.transaction_type.data=='Income':
amount = form.amount.data
tr = Transaction(transaction_name=form.transaction_name.data, \
user_id=current_user.user_id, account_id=account_id, \
amount=amount, note=form.note.data, category_id=int(form.category.data))
if form.recurring.data=='True':
tr.recurring = True
tr.recurring_delay = Transaction.set_recurring_delay(form.how_often.data)
tr.recurring_enddate = Transaction.set_recurring_enddate(form.enddate.data)
account.account_networth += amount
db.session.add(tr)
db.session.commit()
flash("{} succesfully added".format(tr))
return redirect(url_for('main.account', account_id=account_id))
return render_template('main/add_transaction.html', form=form, user_id=current_user.user_id)
def transactions(account_id):
account = Account.query.filter_by(id=account_id).first_or_404()
form = AddTransactionForm()
print("account_id from URL:" + account_id)
if form.validate_on_submit():
print("account_id" + account_id)
print("amount" + str(form.amount.data))
print("description" + form.description.data)
print("credit" + str(form.credit.data))
print("debit" + str(form.debit.data))
transaction = Transaction(account=account,
description=form.description.data,
amount=form.amount.data)
if form.credit.data:
transaction.type = TransactionType.CREDIT.value
account.balance = account.balance + decimal.Decimal(
form.amount.data)
else:
transaction.type = TransactionType.DEBIT.value
account.balance = account.balance - decimal.Decimal(
form.amount.data)
db.session.add(transaction)
db.session.commit()
return render_template('transactions.html', account=account, form=form)
def monitor():
form = NewPhysioLogForm()
form_bank = NewTransactionForm()
if form.validate_on_submit():
user_to_add = UserBasic.query.filter_by(
username=form.username.data).first()
log = PhysioLog(physio_type=form.physio_type.data,
value=form.value.data,
user=user_to_add,
physio_verify='physician')
if (current_user.mission is not None):
log.mission = current_user.mission
db.session.add(log)
db.session.commit()
flash('New physiological log added!')
return redirect(url_for('monitor.monitor'))
if form.validate_on_submit():
user_to_add = UserBasic.query.filter_by(
username=form.username.data).first()
t = Transaction(transaction_type=form.transaction_type.data,
value=form.value.data,
user=current_user)
db.session.add(t)
db.session.commit()
flash('New transaction updated!')
return redirect(url_for('monitor.monitor'))
user_monitor = UserBasic.query.filter(UserBasic.mission != None).all()
return render_template('monitor/monitor.html',
form=form,
form_bank=form_bank,
user_monitor=user_monitor)
def addTransaction(self, trade, tradeCount, assetSymbol):
asset = Asset.objects.get(symbol=assetSymbol)
portfolioAssetMapping = PortfolioAssetMapping.objects.get(asset=asset)
timestamp = "2016-01-06"
initialCount = portfolioAssetMapping.currentCount
finalCount = initialCount
if trade == "buy":
finalCount = initialCount + tradeCount
if trade == "sell":
finalCount = initialCount - tradeCount
portfolioAssetMapping.currentCount = finalCount
assetInfo = Share(assetSymbol)
price = finalCount * float(assetInfo.get_price())
transaction = Transaction(mapping=portfolioAssetMapping,
trade=trade,
timestamp=timestamp,
initialCount=initialCount,
finalCount=finalCount,
tradeCount=tradeCount,
price=price)
transaction.save()
portfolioAssetMapping.save()
def transactions():
body = request.get_json()
user_id = body.get('user_id')
fiat_id = body.get('fiat_id')
coin_id = body.get('coin_id')
coinamt = body.get('coinamt')
fiatprice = body.get('fiatprice')
purchase = body.get('purchase')
coinamt = round(coinamt, 8)
date = datetime.datetime.now()
vault = Vault.query.filter_by(user_id=user_id).first()
vault = vault.to_dict()
coin = VaultCoin.query.filter_by(vault_id=vault['id']).filter_by(
coin_id=coin_id).first()
if purchase == True:
coin.amount = coin.amount + coinamt
db.session.commit()
else:
if (coin.amount < coinamt):
return {'errors': ['Insufficient tokens']}
coin.amount = coin.amount - coinamt
db.session.commit()
new_transfer = Transaction(user_id=user_id,
fiat_id=fiat_id,
coin_id=coin_id,
coinamt=coinamt,
fiatprice=fiatprice,
purchase=purchase,
date=date)
db.session.add(new_transfer)
db.session.commit()
new_transfer = new_transfer.to_dict()
return new_transfer
def upload():
form = UploadForm()
if form.validate_on_submit():
f = form.csv_file.data
account_holder = f.readline().decode()
df = pd.read_csv(f, skiprows=0, index_col=False).fillna(0.0)
account_holder = account_holder.split(':')[1][:14].strip()
df['Transaction Date'] = pd.to_datetime(df['Transaction Date'])
df['Posting Date'] = pd.to_datetime(df['Posting Date'])
df.columns = [x.lower().replace(' ', '_') for x in df.columns]
df['account_holder'] = account_holder
for idx, row in df.iterrows():
t = Transaction(**row.to_dict())
t_duplicate = Transaction.query.filter_by(
transaction_date=t.transaction_date,
posting_date=t.posting_date,
description=t.description,
debits=t.debits,
credits=t.credits,
balance=t.balance,
account_holder=t.account_holder).first()
if t_duplicate == None:
db.session.add(t)
db.session.commit()
return redirect(url_for('index'))
return render_template('upload.html', form=form)
def create_transaction():
data = request.get_json() or {}
if 'sender' not in data or not isinstance(data['sender'], int):
return bad_request('Sender must not be empty or incorrect value')
sender = User.query.get_or_404(data['sender'])
if token_auth.current_user().id != sender.id:
abort(403)
if 'recipient' not in data or data['recipient'] == sender.email or \
not User.query.filter_by(email=data['recipient']).first():
return bad_request('You can not transfer yourself or empty value')
if 'transfer_amount' not in data or not isinstance(data['transfer_amount'], (float, int)) or \
data['transfer_amount'] <= 0.:
return bad_request('Incorrect value of transfer amount')
recipient = User.query.filter_by(email=data['recipient']).first()
sender.bill = sender.bill - float(data['transfer_amount'])
transfer_amount_base = float(
data['transfer_amount']) / sender.currency_user.rate
recipient_bill = recipient.bill / recipient.currency_user.rate
transaction = Transaction(sender=sender.id,
recipient=recipient.email,
transfer_amount_base=transfer_amount_base,
sender_rate=sender.currency_user.rate)
recipient.bill = (recipient_bill +
transfer_amount_base) * recipient.currency_user.rate
db.session.add(transaction)
db.session.commit()
return jsonify(transaction.to_dict())
def expense():
if request.method == "POST":
try:
transactionId = int(request.form.get('transactionId'))
description = str(request.form.get('description'))
amount = float(request.form.get('amount'))
except:
return "الرجاء التأكد من تعبئة النموذج صحيحاَ"
if None or False in (transactionId, description, amount):
return "الرجاء التأكد من تعبئة النموذج صحيحاَ"
currentTime = datetime.now()
newTransaction = Transaction(transaction_Id=transactionId,
client_Id=CASH_CLIENT_ID,
description=description,
total=amount,
paid=amount,
type_Id="E",
type_name="مصروفات",
date=currentTime)
db.session.add(newTransaction)
# db.execute("INSERT INTO cash (transactionId, clientId, amount, typeId, type_name, date)"
# + "VALUES ((?), 1, (?), (?), (?), (?))", [transactionId, -amount, "E", "مصروفات", currTime])
cashClient = Client.query.get(CASH_CLIENT_ID)
cashClient.client_balance -= amount
db.session.commit()
return "/expense"
else:
return render_template('expense.html',
transactionId=getNextTransactionId())
def transfer_balance(transfer_details, user):
user.balance = user.balance - transfer_details["amount"]
transaction = Transaction(user_id=user.id,
timestamp=datetime.now(pytz.utc),
amount=(transfer_details["amount"] * -1))
db.session.add(transaction)
db.session.commit()
def process_transactions(data_db,
block_height,
pubkeyhash_version,
checksum_value,
client=None):
if client == None:
client = get_active_rpc_client()
try:
block = client.getblock('{}'.format(block_height), 4)
except Exception as e:
log.debug(e)
return
for pos_in_block, tx in enumerate(block['tx']):
try:
tx_relevant = process_inputs_and_outputs(data_db, tx,
pubkeyhash_version,
checksum_value)
except Exception as e:
log.debug(e)
return
# add only relevant TXs to the database.
if tx_relevant:
Transaction.create_if_not_exists(
data_db,
Transaction(txid=tx['txid'],
pos_in_block=pos_in_block,
block=unhexlify(block['hash'])))
def add_balance(user, amount):
user.balance = user.balance + amount
transaction = Transaction(user_id=user.id,
timestamp=datetime.now(pytz.utc),
amount=amount)
db.session.add(transaction)
db.session.commit()
def top_up():
"""Top up the user's balance and redirect to the last page."""
if not (current_user.is_admin or current_user.is_bartender):
flash("You don't have the rights to access this page.", 'danger')
return redirect(url_for('main.dashboard'))
username = request.args.get('username', 'none', type=str)
user = User.query.filter_by(username=username).first_or_404()
amount = request.form.get('amount', 0, type=float)
if amount <= 0:
flash('Please enter a strictly positive value.', 'warning')
return redirect(request.referrer)
user = User.query.filter_by(username=username).first_or_404()
user.balance += amount
transaction = Transaction(client_id=user.id,
barman=current_user.username,
date=datetime.datetime.utcnow(),
type='Top up',
balance_change=amount)
db.session.add(transaction)
db.session.commit()
flash(
'You added ' + str(amount) + '€ to ' + user.first_name + ' ' +
user.last_name + "'s account. " +
render_template('_revert_button.html.j2', transaction=transaction),
'primary')
return redirect(request.referrer)
def generate_fake_users(self, count):
for _ in range(count):
fake_user = forgery_py.internet.user_name(True)
User(email=forgery_py.internet.email_address(),
username=fake_user,
password='******').save()
fake_account = Account(name=forgery_py.name.company_name(),
number=1234,
currency=forgery_py.currency.code(),
balance=2000,
holder=fake_user).save()
fake_date = datetime(2018, 1, 1).date()
fake_amount = -100
ttype_name = TransactionType.query.filter_by(id=1).first().ttype
for _ in range(24):
fake_date = fake_date + timedelta(days=15)
fake_amount = fake_amount - 10
Transaction(date=fake_date,
amount=fake_amount,
type=ttype_name,
description='fake groceries',
category='Household',
subcategory='Groceries',
tag='Routine',
status=True,
accountid=fake_account.id,
payee='').save()
def sell():
"""Sell shares of stock"""
symbol = request.form.get('symbol')
price = request.form.get('price')
shares = int(request.form.get('shares'))
# get the number of shares associated with this symbol
stock = db.session.query(Transaction.symbol_id, func.sum(
Transaction.shares).label("sum")).join(Symbol, Symbol.id == Transaction.symbol_id).filter(Transaction.user_id == session.get('user_id'), Symbol.symbol == symbol).first()
# return an error if the user doesn't have enough shares or the input is not a positive integer
if stock.sum < shares or shares < 0:
return apology('NOT ENOUGH SHARES', 403)
# update the number of shares in the transactions table
else:
transaction = Transaction(user_id=session.get('user_id'), symbol_id=stock.symbol_id, shares=-shares, price=price)
db.session.add(transaction)
# update user's cash
transaction_value = float(price) * float(shares)
user = User.query.filter_by(id=session.get('user_id')).first()
user.cash += transaction_value
db.session.commit()
flash('You successfully sold {} shares of {}'.format(
shares, symbol))
return redirect('/')
def create_test_transaction(
user_id,
title='Test Transaction',
date=datetime.now(),
amount=100.00,
description='Test Description',
income=False,
is_recurring=False,
freq=None,
interval=None,
count=None,
until=None,
):
t = Transaction(
user_id=user_id,
title=title,
date=date,
income=income,
is_recurring=is_recurring,
freq=freq,
interval=interval,
count=count,
until=until,
)
t.set_amount(amount)
if is_recurring:
t.set_recurring(None)
db.session.add(t)
db.session.commit()
return Transaction.query.filter_by(id=t.id).first()
def seed_transactions():
demo = Transaction(type=-500, coin_id=3, price=50, quantity=10, wallet_id=2)
db.session.add(demo)
db.session.commit()
def __create_transactions(full_phone_number, request_data):
'''
Creates a transaction when passing through transaction information, including a date
When the transaction is created, it is stored with a specific date. However, when it is
retrieved, it is retrieved with all other transactions with the same month and year
'''
try:
# Loads the request body
# and checks whether all information is present
if ('transactions' not in request_data):
current_app.logger.error(
'request body not formatted correctly, body is missing required parameters: {0}'
.format(request_data))
return error_response(400)
# Gets the identity of the JWT
# and gets the user from the DB
author = User.query.filter(
User.full_phone_number == full_phone_number).first()
# Gets the list of transactions
# And creates transactions for that User
transactions_list = request_data['transactions']
for item in transactions_list:
# Makes sure that the data is formatted correctly
if ('name' not in item or 'category' not in item
or 'price' not in item or 'createdAt' not in item):
current_app.logger.error(
'transaction not formatted correctly, missing required parameters: {0}'
.format(item))
return error_response(400)
# Creates the new Transaction
# and attaches the author to it
transaction = Transaction()
transaction.from_dict(item, author=author)
# Logs that the user is being added to the database and then adds to the database
# We will commit later once everything has been processed correctly
db.session.add(transaction)
current_app.logger.info(
'added transaction {0} {1} to the database session'.format(
transaction.category, transaction.name))
# Commits the user to the database and logs that is has been commited
db.session.commit()
current_app.logger.info(
'commited transactions to the database session')
# Returns the response with status code 201 to indicate the user has been created
return error_response(201)
except Exception as e:
# Logs the exception that has been raised and rolls back all the changes made
current_app.logger.fatal(str(e))
db.session.rollback()
# Returns a 500 response (Internal Server Error)
return error_response(500)
def get_employer_by_filter(req):
try:
trans = Transaction()
employer = trans.query(Employer).all()
return ('ok', '', [e.to_dict() for e in employer])
except Exception as e:
return ('err', e.__class__.__name__, [])
def confirm_sell(username):
user = UserProfile.query.filter_by(username=username)
if user is not None:
user = user.first()
with open('app/investments/coins.json') as f:
supported_currencies = json.load(f)
coin_conversion_rate = float(request.form['coin_conversion_rate'])
sell_amount = float(request.form['sell_amount'])
print(coin_conversion_rate)
print(sell_amount)
coin_name = None
coins_list = []
for curr in supported_currencies:
coins_list.append(curr['id'])
prices = cg.get_price(ids=coins_list, vs_currencies='usd')
for curr in supported_currencies:
curr['price'] = prices[curr['id']]['usd']
print(prices)
for coin in supported_currencies:
if coin['price'] == coin_conversion_rate:
coin_name = coin['id']
break
if coin_name is None or coin_conversion_rate is None or sell_amount is None:
return redirect(url_for('investments.sell', username=user.username))
number_of_coins = sell_amount / coin_conversion_rate
coin_investment_instance = None
for coin in user.coin_investments:
if coin.coin_name == coin_name:
coin_investment_instance = coin
break
success = False
if coin_investment_instance is None:
flash("You don't have any holdings of this coin.")
else:
if coin_investment_instance.number_of_coins * prices[coin_investment_instance.coin_name][
'usd'] >= sell_amount:
coin_investment_instance.number_of_coins -= number_of_coins
coin_investment_instance.total_price -= sell_amount
db.session.add(coin_investment_instance)
db.session.commit()
transaction = Transaction(investment_id=coin_investment_instance.id, coin_name=coin_name,
number_of_coins=number_of_coins, total_price=sell_amount)
db.session.add(transaction)
if coin_investment_instance.number_of_coins <= 0:
db.session.delete(coin_investment_instance)
db.session.commit()
user.balance += sell_amount
db.session.add(user)
db.session.commit()
success = True
return render_template('confirm_sell.html', success=success)
else:
return render_template('404_error')
def delete_employer_by_id(id_):
try:
trans = Transaction()
n = trans.query(Employer).filter(Employer.id == id_).delete()
trans.commit()
return ('ok', '', n)
except Exception as e:
return ('err', e.__class__.__name__, 0)
def get_employer_by_id(id_):
try:
trans = Transaction()
employer = trans.query(Employer).get(id_)
return ('ok', '', [employer.to_dict()])
except AttributeError as e:
return ('ok', e.__class__.__name__, [])
except Exception as e:
return ('err', e.__class__.__name__, [])
def form_valid(self, form):
ret = super(TopUpFormView, self).form_valid(form)
t = Transaction(user=form.cleaned_data['user'],
amount=form.cleaned_data['amount'])
t.save()
messages.success(
self.request,
"{}€ have been added to your balance. You now have {}€ available".
format(form.cleaned_data['amount'],
form.cleaned_data['user'].profile.balance))
return ret
def post(self, request):
user_profile = UserProfile.objects.get(badge=request.POST.get('badge'))
user = user_profile.user
item = Item.objects.get(code=request.POST.get('code'))
sale = Sale(user=user)
sale.save()
sl = SaleLine(quantity=1, item=item, sale=sale)
sl.save()
t = Transaction(user=user, amount=-sale.total)
t.save()
return HttpResponse()
def test_adding_transactions(self):
t1 = Transaction(book_id=1,
borrower_id=1,
date_created=datetime.datetime(2019, 5, 26),
startdate=datetime.datetime(2019, 4, 16),
enddate=datetime.datetime(2019, 3, 30),
status="open")
db.session.add(t1)
db.session.commit()
numtrans = Transaction.query.all()
self.assertEqual(len(numtrans), 1)
def update_employer(id_, req):
try:
trans = Transaction()
n = trans.query(Employer).filter(Employer.id == id_).update(req)
trans.commit()
return ('ok', '', n)
except IntegrityError as e:
return ('err', e.__class__.__name__, 0)
except Exception as e:
return ('err', e.__class__.__name__, 0)
