def post(self, Date, ClustCoeff=None):
"""
Method for POST request
:param Date:
:param ClustCoeff:
"""
clustering_coefficient = ClusteringCoefficient(date=Date,
clust_coeff=ClustCoeff)
db_session.add(clustering_coefficient)
try:
db_session.commit()
response = {
"ResponseCode":
ResponseCodes.Success.value,
"ResponseDesc":
ResponseCodes.Success.name,
"ClusteringCoefficient":
serialize_clustering_coefficient(clustering_coefficient)
}
except SQLAlchemyError as e:
print(str(e))
db_session.rollback()
response = {
"ResponseCode": ResponseCodes.InternalError.value,
"ResponseDesc": ResponseCodes.InternalError.name,
"ErrorMessage": ResponseDescriptions.ErrorFromDataBase.value
}
return response
def post(self, Date, SCC=None):
"""
Method for POST request
:param Date:
:param SCC:
"""
strongly_connected_component = StronglyConnectedComponent(date=Date,
scc=SCC)
db_session.add(strongly_connected_component)
try:
db_session.commit()
response = {
"ResponseCode":
ResponseCodes.Success.value,
"ResponseDesc":
ResponseCodes.Success.name,
"StronglyConnectedComponent":
serialize_strongly_connected_component(
strongly_connected_component)
}
except SQLAlchemyError as e:
print(str(e))
db_session.rollback()
response = {
"ResponseCode": ResponseCodes.InternalError.value,
"ResponseDesc": ResponseCodes.InternalError.name,
"ErrorMessage": ResponseDescriptions.ErrorFromDataBase.value
}
return response
def post(self, Date, TotBTC=None, CircPercent=None, NotCircuPercent=None):
"""
Method for POST request
:param Date:
:param TotBTC:
:param CircPercent:
:param NotCircuPercent:
"""
bitcoin_circulation = BitcoinCirculation(
date=Date,
tot_btc=TotBTC,
circ_percent=CircPercent,
not_circu_percent=NotCircuPercent)
db_session.add(bitcoin_circulation)
try:
db_session.commit()
response = {
"ResponseCode":
ResponseCodes.Success.value,
"ResponseDesc":
ResponseCodes.Success.name,
"BitcoinCirculation":
serialize_bitcoin_circulation(bitcoin_circulation)
}
except SQLAlchemyError as e:
print(str(e))
db_session.rollback()
response = {
"ResponseCode": ResponseCodes.InternalError.value,
"ResponseDesc": ResponseCodes.InternalError.name,
"ErrorMessage": ResponseDescriptions.ErrorFromDataBase.value
}
return response
def post(self, Date, Addr=None, NoOfTrans=None):
"""
Method for POSt request
:param Date:
:param Addr:
:param NoOfTrans:
"""
most_active_entity = MostActiveEntity(date=Date,
addr=Addr,
no_of_trans=NoOfTrans)
db_session.add(most_active_entity)
try:
db_session.commit()
response = {
"ResponseCode":
ResponseCodes.Success.value,
"ResponseDesc":
ResponseCodes.Success.name,
"MostActiveEntity":
serialize_most_active_entity(most_active_entity)
}
except SQLAlchemyError as e:
print(str(e))
db_session.rollback()
response = {
"ResponseCode": ResponseCodes.InternalError.value,
"ResponseDesc": ResponseCodes.InternalError.name,
"ErrorMessage": ResponseDescriptions.ErrorFromDataBase.value
}
return response
def delete_items(title, id):
list = db_session.query(List).filter(List.title == title,
List.id == id).first()
if request.method == "POST":
item = request.form['item']
delete_item = db_session.query(List_Item).filter(
List_Item.content == item, List_Item.list_id == list.id).first()
if delete_item:
db_session.delete(delete_item)
try:
db_session.commit()
except Exception as e:
db_session.rollback()
db_session.flush()
print("error")
flash("an error ocured delting this item")
return redirect(
url_for('routes.delete_items',
title=list.title,
id=list.id))
else:
flash("this is not an item on this list")
return redirect(
url_for('routes.delete_items', title=list.title, id=list.id))
return redirect(url_for('routes.list', title=list.title, id=list.id))
if session.get('logged_in') == False:
return redirect(url_for('routes.login'))
if not list:
return redirect(url_for('routes.list_of_lists'))
items = db_session.query(List_Item).filter(List_Item.list_id == id).all()
list = db_session.query(List).filter(List.id == id).first()
return render_template('editlist.html', items=items, list=list)
def post(self, Date, ReceiveOnlyPer=None, SendReceivePer=None):
"""
Method for POST request
:param Date:
:param ReceiveOnlyPer:
:param SendReceivePer:
"""
address_distribution = AddressDistribution(
date=Date,
receive_only_per=ReceiveOnlyPer,
send_receive_per=SendReceivePer)
db_session.add(address_distribution)
try:
db_session.commit()
response = {
"ResponseCode":
ResponseCodes.Success.value,
"ResponseDesc":
ResponseCodes.Success.name,
"AddressDistribution":
serialize_address_distribution(address_distribution)
}
except SQLAlchemyError as e:
print(str(e))
db_session.rollback()
response = {
"ResponseCode": ResponseCodes.InternalError.value,
"ResponseDesc": ResponseCodes.InternalError.name,
"ErrorMessage": ResponseDescriptions.ErrorFromDataBase.value
}
return response
def post(self, Date, SplitChlt=None, MergeChlt=None, TransitionChlt=None):
"""
Method for POST request
:param Date:
:param SplitChlt:
:param MergeChlt:
:param TransitionChlt:
"""
chainlets_occurance = ChainletsOccurance(
date=Date,
split_chlt=SplitChlt,
merge_chlt=MergeChlt,
transition_chlt=TransitionChlt)
db_session.add(chainlets_occurance)
try:
db_session.commit()
response = {
"ResponseCode":
ResponseCodes.Success.value,
"ResponseDesc":
ResponseCodes.Success.name,
"ChainletsOccurance":
serialize_chainlets_occurance(chainlets_occurance)
}
except SQLAlchemyError as e:
print(str(e))
db_session.rollback()
response = {
"ResponseCode": ResponseCodes.InternalError.value,
"ResponseDesc": ResponseCodes.InternalError.name,
"ErrorMessage": ResponseDescriptions.ErrorFromDataBase.value
}
return response
def sign_up():
if request.method == "POST":
username = request.form["username"]
password = request.form["password"]
existing_user = db_session.query(User).filter(
User.username == username).first()
if existing_user:
flash("someone has alreay used that username try again")
return redirect(url_for('routes.sign_up'))
else:
new_user = User(username, password)
db_session.add(new_user)
try:
db_session.commit()
session['logged_in'] = True
except Exception as e:
db_session.rollback()
db_session.flush()
print("error")
return redirect(url_for('routes.home'))
msg = Message("Hello Email World",
sender="*****@*****.**",
recipients=["*****@*****.**"])
mail.send(msg)
return render_template('signup.html')
def post(self,
Date,
Address,
No_of_SCC=None,
No_of_WCC=None,
BTC_Received=None,
BTC_Sent=None,
Activity_Level=None,
Clustering_Coeff=None,
PearsonCC=None,
Maximal_Balance=None,
Current_Balance=None):
"""
Method for POST request
:param Date:
:param Address:
:param No_of_SCC:
:param No_of_WCC:
:param BTC_Received:
:param BTC_Sent:
:param Activity_Level:
:param Clustering_Coeff:
:param PearsonCC:
:param Maximal_Balance:
:param Current_Balance:
"""
address_feature = AddressFeature(date=Date,
address=Address,
no_of_scc=No_of_SCC,
no_of_wcc=No_of_WCC,
btc_received=BTC_Received,
btc_sent=BTC_Sent,
activity_level=Activity_Level,
clustering_coeff=Clustering_Coeff,
pearsoncc=PearsonCC,
maximal_balance=Maximal_Balance,
current_balance=Current_Balance)
db_session.add(address_feature)
try:
db_session.commit()
response = {
"ResponseCode": ResponseCodes.Success.value,
"ResponseDesc": ResponseCodes.Success.name,
"AddressFeature": serialize_feature_address(address_feature)
}
except SQLAlchemyError as e:
print(str(e))
db_session.rollback()
response = {
"ResponseCode": ResponseCodes.InternalError.value,
"ResponseDesc": ResponseCodes.InternalError.name,
"ErrorMessage": ResponseDescriptions.ErrorFromDataBase.value
}
return response
def post(self,
Date,
BTCrecLT1=None,
BTCrecLT10=None,
BTCrecLT100=None,
BTCrecLT1000=None,
BTCrecLT10000=None,
BTCrecLT50000=None,
BTCrecGT50000=None):
"""
Method for POST request
:param Date:
:param BTCrecLT1:
:param BTCrecLT10:
:param BTCrecLT100:
:param BTCrecLT1000:
:param BTCrecLT10000:
:param BTCrecLT50000:
:param BTCrecGT50000:
"""
total_btc_received = TotalBtcReceived(date=Date,
btcreclt1=BTCrecLT1,
btcreclt10=BTCrecLT10,
btcreclt100=BTCrecLT100,
btcreclt1000=BTCrecLT1000,
btcreclt10000=BTCrecLT10000,
btcreclt50000=BTCrecLT50000,
btcrecgt50000=BTCrecGT50000)
db_session.add(total_btc_received)
try:
db_session.commit()
response = {
"ResponseCode":
ResponseCodes.Success.value,
"ResponseDesc":
ResponseCodes.Success.name,
"TotalBtcReceived":
serialize_total_btc_received(total_btc_received)
}
except SQLAlchemyError as e:
print(str(e))
db_session.rollback()
response = {
"ResponseCode": ResponseCodes.InternalError.value,
"ResponseDesc": ResponseCodes.InternalError.name,
"ErrorMessage": ResponseDescriptions.ErrorFromDataBase.value
}
return response
def post(self,
Date,
TransSizeLT1=None,
TransSizeLT10=None,
TransSizeLT100=None,
TransSizeLT5000=None,
TransSizeLT20000=None,
TransSizeLT50000=None,
TransSizeGT50000=None):
"""
Method for POST request
:param Date:
:param TransSizeLT1:
:param TransSizeLT10:
:param TransSizeLT100:
:param TransSizeLT5000:
:param TransSizeLT20000:
:param TransSizeLT50000:
:param TransSizeGT50000:
"""
transaction_size = TransactionSize(date=Date,
trans_size_lt1=TransSizeLT1,
trans_size_lt10=TransSizeLT10,
trans_size_lt100=TransSizeLT100,
trans_size_lt5000=TransSizeLT5000,
trans_size_lt20000=TransSizeLT20000,
trans_size_lt50000=TransSizeLT50000,
trans_size_gt50000=TransSizeGT50000)
db_session.add(transaction_size)
try:
db_session.commit()
response = {
"ResponseCode": ResponseCodes.Success.value,
"ResponseDesc": ResponseCodes.Success.name,
"TransactionSize": serialize_transaction_size(transaction_size)
}
except SQLAlchemyError as e:
print(str(e))
db_session.rollback()
response = {
"ResponseCode": ResponseCodes.InternalError.value,
"ResponseDesc": ResponseCodes.InternalError.name,
"ErrorMessage": ResponseDescriptions.ErrorFromDataBase.value
}
return response
def post(self,
Date,
CurrBal1=None,
CurrBal10=None,
CurrBal100=None,
CurrBal1000=None,
CurrBal10000=None,
CurrBal50000=None,
CurrBalGT50000=None):
"""
Method for POST request
:param Date:
:param CurrBal1:
:param CurrBal10:
:param CurrBal100:
:param CurrBal1000:
:param CurrBal10000:
:param CurrBal50000:
:param CurrBalGT50000:
"""
current_balance = CurrentBalance(date=Date,
currbal1=CurrBal1,
currbal10=CurrBal10,
currbal100=CurrBal100,
currbal1000=CurrBal1000,
currbal10000=CurrBal10000,
currbal50000=CurrBal50000,
currbalgt50000=CurrBalGT50000)
db_session.add(current_balance)
try:
db_session.commit()
response = {
"ResponseCode": ResponseCodes.Success.value,
"ResponseDesc": ResponseCodes.Success.name,
"CurrentBalance": serialize_current_balance(current_balance)
}
except SQLAlchemyError as e:
print(str(e))
db_session.rollback()
response = {
"ResponseCode": ResponseCodes.InternalError.value,
"ResponseDesc": ResponseCodes.InternalError.name,
"ErrorMessage": ResponseDescriptions.ErrorFromDataBase.value
}
return response
def post(self,
Date,
LOALT2=None,
LOALT5=None,
LOALT10=None,
LOALT100=None,
LOALT1000=None,
LOALT5000=None,
LOAGT5000=None):
"""
Method for POST request
:param Date:
:param LOALT2:
:param LOALT5:
:param LOALT10:
:param LOALT100:
:param LOALT1000:
:param LOALT5000:
:param LOAGT5000:
"""
activity_level = ActivityLevel(date=Date,
loalt2=LOALT2,
loalt5=LOALT5,
loalt10=LOALT10,
loalt100=LOALT100,
loalt1000=LOALT1000,
loalt5000=LOALT5000,
loagt5000=LOAGT5000)
db_session.add(activity_level)
try:
db_session.commit()
response = {
"ResponseCode": ResponseCodes.Success.value,
"ResponseDesc": ResponseCodes.Success.name,
"ActivityLevel": serialize_activity_level(activity_level)
}
except SQLAlchemyError as e:
print(str(e))
db_session.rollback()
response = {
"ResponseCode": ResponseCodes.InternalError.value,
"ResponseDesc": ResponseCodes.InternalError.name,
"ErrorMessage": ResponseDescriptions.ErrorFromDataBase.value
}
return response
def add_list():
if request.method == "POST":
title = request.form["title"]
description = request.form["about"]
new_list = List(title, description)
list_items = request.form.getlist('items')
for item in list_items:
print(item)
new_items = List_Item(item)
db_session.add(new_items)
new_list.items.append(new_items)
print("panda")
db_session.add(new_list)
items_created = False
list_created = False
if new_list.title and new_list.description:
list_created = True
else:
flash("your list must have a title and a desciption")
if new_items.content:
list_items = True
else:
flash("your list must have some items")
if list_created and items_created:
try:
db_session.commit()
print("pandas are awsome")
except Exception as e:
print(e)
db_session.rollback()
db_session.flush()
created_list = db_session.query(List).filter(
List.title == title).first()
redirect_id = created_list.id
redirect_title = created_list.title
return redirect(
url_for('routes.list', title=redirect_title, id=redirect_id))
return render_template('add_list.html')
def idea():
title = request.form["title"]
content = request.form["content"]
new_idea = Idea(title, content)
if new_idea.title and new_idea.content:
db_session.add(new_idea)
try:
db_session.commit()
return redirect(url_for('routes.home'))
except Exception as e:
print(e)
db_session.rollback()
db_session.flush()
flash("something whent wrong")
return redirect(url_for('routes.home'))
else:
flash("are you sure you filled in all the fields")
return redirect(url_for('routes.home'))
