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 post(self):
json_trns = request.get_json()
print(json_trns.keys())
debited_account = db.session.query(Account).filter_by(
id=json_trns['debited_account_id']).one()
credited_account = db.session.query(Account).filter_by(
id=json_trns['credited_account_id']).one()
trn = Transaction(
debited_account_id=json_trns['debited_account_id'],
credited_account_id=json_trns['credited_account_id'],
amount=json_trns['amount'],
)
if "timestamp" in json_trns.keys():
trn.timestamp = json_trns['timestamp']
debited_account.balance += json_trns['amount']
credited_account.balance -= json_trns['amount']
db.session.add(debited_account)
db.session.add(credited_account)
db.session.add(trn)
db.session.commit()
return jsonify({})
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 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 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(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 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 upload_file():
if request.method == 'POST':
file = request.files['file']
if file and allowed_file(file.filename):
filename = secure_filename(file.filename)
file.save(os.path.join(app.config['UPLOAD_FOLDER'], filename))
Transaction.from_csv_tinkoff(
os.path.join(app.config['UPLOAD_FOLDER'], filename))
return redirect(url_for('transactions'))
return render_template('upload.html', files=os.listdir('uploads'))
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 create(self, source, target, date, amount, description=''):
if source is None:
raise TypeError('source Account is None.')
if target is None:
raise TypeError('target is None')
if source.key() == target.key():
raise ValueError('source and target Accounts are the same.')
# TODO: calculate exchange rate between account's currencies
exchange_rate = 1.0
app.logger.debug(source)
app.logger.debug(target)
app.logger.debug(date)
app.logger.debug(amount)
app.logger.debug(description)
app.logger.debug(exchange_rate)
transaction = Transaction(source=source, target=target, date=date, amount=amount,
exchange_rate=exchange_rate, description=description)
transaction.put()
# XXX: precision problems?
reverse_amount = exchange_rate * amount
reverse_rate = 1 / exchange_rate
reverse = Transaction(source=target, target=source, date=date, amount=reverse_amount,
exchange_rate=reverse_rate, description=description, reverse=transaction)
reverse.put()
transaction.reverse = reverse
transaction.put()
return transaction
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 get_about(self, username):
# facebook_scraper = pickle.load(open( "facebook_scraper.pickle", "rb" ))
try:
result = facebook_scraper.get_about(username)
user = FacebookUser.query.filter_by(username=username).first()
if not user:
user = FacebookUser()
convert_result(user, result)
user.created_at = datetime.now()
db.session.add(user)
transact_type = 'create'
else:
convert_result(user, result)
transact_type = 'update'
user.updated_at = datetime.now()
except Exception as e:
transaction = Transaction(
timestamp = datetime.utcnow(),
transact_type = 'error',
func = 'get_about(%s)' % username,
ref = "%s: %s" % (
str(e.errno) if hasattr(e, 'errno') else 0,
e.strerror if hasattr(e, 'strerror') else e
)
)
if 'result' in locals():
transaction.data = str(result)
transaction.ref = "%s.%s" % (FacebookUser.__tablename__, str(result.uid))
db.session.add(transaction)
db.session.commit()
return
## Scrape Transaction
transaction = Transaction(
timestamp = datetime.utcnow(),
transact_type = transact_type,
ref = "%s.%s" % (FacebookUser.__tablename__, str(result.uid)),
func = 'get_about(%s)' % username,
data = str(result)
)
db.session.add(transaction)
db.session.commit()
return result
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 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 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 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 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 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 complete_transaction(request):
try:
# print request.body
# data = json.loads(request.body)['json']
if request.POST:
consumer = request.POST.get('user_id')
useracc = MainUser.objects.get(id=consumer)
key = request.POST.get('key')
prototype = Prototype.objects.get(key=key)
type = request.POST.get('type')
mode = request.POST.get('mode')
## type 1 is merchant and type 2 is personal and mode 2 is self
if type == 1:
products = Product.objects.filter(prototype=prototype)
merchant = prototype.merchant
total = Decimal(0)
for p in products:
total += p.quantity*p.price
merchant.balance += total
merchant.save()
ts = Transaction()
ts.prototype = prototype
ts.customer = useracc
ts.status = 1
ts.mode = mode
ts.save()
if mode == 2:
useracc.balance -= total
useracc.save()
else:
pt = PersonalTransfer.objects.filter(prototype=prototype)
receiver = prototype.merchant
sender = useracc
total = Decimal(0)
for p in pt:
total += p.amount
receiver.balance += total
receiver.save()
ts = Transaction()
ts.prototype = prototype
ts.customer = useracc
ts.status = 1
ts.mode = mode
ts.save()
if mode == 2:
useracc.balance -= total
useracc.save()
gcm_push_message("You've received funds in your paypaid account!","You have got funds!",receiver.gcm)
except Exception,e:
print e
return HttpResponse("error",status=400)
def get_fans(self, pagename):
max_retries = 3
for retries in xrange(max_retries + 1):
try:
page = FacebookPage.query.filter_by(username=pagename).first()
break
except (DatabaseError, OperationalError):
if retries + 1 > max_retries:
raise
if not page: raise Exception("put the page in the db first plz")
results = []
try:
for result in facebook_scraper.get_fans(pagename):
try:
user = FacebookUser.query.filter_by(username=result.username).first()
if not user:
user = FacebookUser()
convert_result(user, result)
user.created_at = datetime.now()
db.session.add(user)
transact_type = 'create'
else:
convert_result(user, result)
transact_type = 'update'
# logger.debug()
# self.update_state(state='PROGRESS', meta={'transact_type': transact_type, 'current_result': result.username, 'current_total': len(results)})
except Exception as e:
transaction = Transaction(
timestamp = datetime.utcnow(),
transact_type = 'error',
func = 'get_likes(%s)' % pagename,
ref = "%s: %s" % (
str(e.errno) if hasattr(e, 'errno') else 0,
e.strerror if hasattr(e, 'strerror') else e
)
)
print transaction.__dict__
if 'result' in locals():
transaction.data = str(result)
# logger.debug()
# self.update_state(state='PROGRESS', meta={'transact_type': transact_type, 'current_result': result.username, 'current_total': len(results)})
db.session.add(transaction)
db.session.commit()
continue
user.updated_at = datetime.now()
user.pages.append(page)
## Scrape Transaction
transaction = Transaction(
timestamp = datetime.utcnow(),
transact_type = transact_type,
ref = "%s.%s" % (FacebookUser.__tablename__, str(result.uid)),
func = 'get_likes(%s)' % pagename,
data = str(result)
)
db.session.add(transaction)
db.session.commit()
results.append(result)
logger.info( "%s - %i - %s" % (pagename, len(results), result.username))
except (ScrapingError, ValueError) as e:
logger.info(e)
raise
return results
def get_likes(self, username):
# TODO: move this to FacebookUser model
#
# from sqlalchemy.exc import DatabaseError, OperationalError
#
# retries method on DatabaseError or OperationalError
# def retry(fun):
# @wraps(fun)
# def _inner(*args, **kwargs):
# max_retries = kwargs.pop('max_retries', 3)
# for retries in xrange(max_retries + 1):
# try:
# return fun(*args, **kwargs)
# except (DatabaseError, OperationalError):
# if retries + 1 > max_retries:
# raise
# return _inner
#
# @retry
# def get(username_or_uid):
# if type(username_or_uid) == int:
# return FacebookUser.query.get(username_or_uid)
# elif type(username_or_uid) == str:
# return FacebookUser.query.filter_by(username=username).first()
# else:
# raise
max_retries = 3
for retries in xrange(max_retries + 1):
try:
user = FacebookUser.query.filter_by(username=username).first()
break
except (DatabaseError, OperationalError):
if retries + 1 > max_retries:
raise
if not user: raise Exception("scrape the dude's about information first plz")
user.scrape_status = 1
results = []
try:
for result in facebook_scraper.get_likes(username):
try:
page = FacebookPage.query.filter_by(username=result.username).first()
if not page:
page = FacebookPage()
convert_result(page, result)
page.created_at = datetime.now()
db.session.add(page)
transact_type = 'create'
else:
convert_result(page, result)
transact_type = 'update'
# logger.debug()
# self.update_state(state='PROGRESS', meta={'transact_type': transact_type, 'current_result': result.username, 'current_total': len(results)})
except Exception as e:
transaction = Transaction(
timestamp = datetime.utcnow(),
transact_type = 'error',
func = 'get_likes(%s)' % username,
ref = "%s: %s" % (
str(e.errno) if hasattr(e, 'errno') else 0,
e.strerror if hasattr(e, 'strerror') else e
)
)
if 'result' in locals():
transaction.data = str(result)
# logger.debug()
# self.update_state(state='PROGRESS', meta={'transact_type': transact_type, 'current_result': result.username, 'current_total': len(results)})
db.session.add(transaction)
db.session.commit()
continue
page.updated_at = datetime.now()
page.users.append(user)
## Scrape Transaction
transaction = Transaction(
timestamp = datetime.utcnow(),
transact_type = transact_type,
ref = "%s.%s" % (FacebookPage.__tablename__, str(result.page_id)),
func = 'get_likes(%s)' % username,
data = str(result)
)
db.session.add(transaction)
db.session.commit()
results.append(result)
logger.info( "%s - %i - %s" % (username, len(results), result.username))
except ScrapingError as e:
user.scrape_status = 0
if user.scrape_status == 1:
user.scrape_status = 2
db.session.commit()
return results
