def create_and_get_country_sector_db_record(type_, dict_):
"""
Creates a country or sector record in DB.
:param type_: 'country' or 'sector'
:param dict_: dictionary with all needed fundamentals on country and sector
:return: added DB record
"""
time_now = datetime.today()
data_json = {
'name': dict_[type_],
'date': time_now,
'pe': dict_[f'pe_{type_}'],
'div_yield': dict_[f'div_{type_}'],
'forward_pe': dict_[f'forward_pe_{type_}'],
'eps_g_past_5y': dict_[f'eps_g_past_5y_{type_}'],
'eps_g_next_5y': dict_[f'eps_g_next_5y_{type_}']
}
if type_ == "country":
record_in_db = CountryFundamentals(data_json)
else:
record_in_db = SectorFundamentals(data_json)
db_session.add(record_in_db)
try:
db_session.commit()
logger.info(f"{type_} {record_in_db.name} was added to DB.")
return record_in_db
except exc.SQLAlchemyError:
logger.error(f"Failed to add {type} fundamentals to DB.")
raise ErrorFundamentalsDB("'Create and Get country sector db record'")
def edit_profile(username):
user = User.query.filter(User.username == username).first()
posts = Post.query.filter(Post.user_id == user.id).order_by(Post.created.desc())
if request.method == 'POST':
first_name = request.form['first_name']
last_name = request.form['last_name']
day = request.form.get('day')
month = request.form.get('month')
year = request.form.get('year')
gender = request.form['gender']
relationship_status = request.form['relationship_status']
current_city = request.form['current_city']
bio = request.form['bio']
user.first_name = first_name
user.last_name = last_name
user.date_of_birth = ''
user.day = day
user.month = month
user.year = year
user.gender = gender
user.relationship_status = relationship_status
user.current_city = current_city
user.bio = bio
if 'photo' in request.files:
photo = request.files['photo']
if photo.filename != '':
user.profile_pic = photos.save(request.files['photo'])
db_session.add(user)
db_session.commit()
return redirect(url_for('blog.profile', username=user.username))
return render_template('blog/edit_profile.html', user=user)
def save_news_to_db(all_news) -> bool:
"""
Saving news to the DB.
:param all_news: all news
:return: no return
"""
for one_news in all_news:
first_news_in_db = News.query.filter(
News.title == one_news['title']).first()
if not first_news_in_db:
logger.info(
f"Trying to add news with title '{one_news['title']}' to DB.")
db_session.add(News(one_news))
send_to_bot(one_news)
elif one_news['change'] != first_news_in_db.change:
logger.info(
f"Trying to update price of {first_news_in_db.ticker} in DB.")
first_news_in_db.change = one_news['change']
try:
db_session.commit()
logger.info(f"All news in DB are added and updated.")
return True
except exc.SQLAlchemyError:
logger.error(f"Failed to add or update news to DB.")
return False
def register():
if request.method == 'POST':
username = request.form['username']
password = request.form['password']
error = None
if not username:
error = 'Username is required.'
elif not password:
error = 'Password is required.'
elif db_session.query(
User.id).filter(User.UserName == username).first() is not None:
error = f'User {username} is already registered.'
if error is None:
user = User(UserName=username,
PassWord=generate_password_hash(password))
db_session.add(user)
db_session.commit()
return redirect(url_for('auth.login'))
flash(error)
return render_template('auth/register.html')
def create_and_get_stocks_db_record(ticker):
"""
Creates a stocks record in DB.
:param ticker: stocks ticker
:return: added DB record
"""
data_json = get_all_stocks_fundamentals(ticker)
ticker_in_db = Fundamentals(data_json)
country_sector = get_finviz_fundamentals_of_sector_country(ticker)
country = get_actual_country_sector_fundamentals_from_db(
"country", country_sector)
sector = get_actual_country_sector_fundamentals_from_db(
"sector", country_sector)
ticker_in_db.country = country
ticker_in_db.sector = sector
db_session.add(ticker_in_db)
try:
db_session.commit()
logger.info(f"Stocks ticker {ticker} was added to DB.")
return ticker_in_db
except exc.SQLAlchemyError as e:
logger.error(f"Failed to add {ticker} fundamentals to DB.")
raise ErrorFundamentalsDB("'Create and Get stock db record'")
def create():
if request.method == 'POST':
body = request.form['body']
post = Post(body=body, author=g.user)
db_session.add(post)
db_session.commit()
return redirect(url_for('blog.index'))
return render_template('blog/create.html')
def create():
form = ProjectCreateForm(request.form)
if request.method == 'GET':
return render_template('projects/create_project.html', form=form)
if request.method == 'POST' and form.validate():
# print(form.name.data, form.client.data, form.technology.data, form.status.data)
project = Project(form.name.data, form.client.data,
form.technology.data, form.status.data)
db_session.add(project)
db_session.commit()
return redirect(url_for('project.list'))
def update(id):
post = get_post(id)
if request.method == 'POST':
body = request.form['body']
post.body = body
db_session.add(post)
db_session.commit()
return redirect(url_for('blog.index'))
return render_template('blog/update.html', post=post)
def create_server():
server = Server.from_json(request.json)
if not server:
return response('bad json', status=400)
target_rack = Rack.query.get(server.rack_id)
if not target_rack:
return response('target rack not exist', status=400)
if target_rack.size >= target_rack.capacity.value:
return response('rack is full', status=400)
db_session.add(server)
target_rack.increase_size()
db_session.commit()
return jsonify({'id': server.id})
def tcreate(project_id):
form = TaskCreateForm(request.form)
if request.method == 'GET':
project = Project.query.filter_by(id=project_id).first()
form.project_id.data = project_id
return render_template('tasks/create_task.html',
form=form,
project=project)
if request.method == 'POST' and form.validate():
# print("Project ID: ",form.project_id)
task = Task(title=form.title.data,
description=form.description.data,
project_id=form.project_id.data)
db_session.add(task)
db_session.commit()
return redirect(url_for('project.tlist', project_id=project_id))
def save_bot_user_to_db(user_id, username) -> None:
"""
Saving new users to the DB.
:param user_id: user id
:param username: user username
"""
new_user = BotUser(id=user_id, username=username)
db_session.add(new_user)
try:
db_session.commit()
except exc.SQLAlchemyError:
logging.info(f"Failed to add user {username} to DB.")
sys.exit(
"Encountered general SQLAlchemyError during saving user in DB in ReadingBot."
)
def register():
"""Register a new user.
Validates that the username is not already taken. Hashes the
password for security.
"""
if request.method == "POST":
username = request.form["username"]
password = request.form["password"]
error = None
if not username:
error = "Username is required."
elif not password:
error = "Password is required."
else:
if User.query.filter(User.username == username).first():
error = f"User {username} is already registered."
if error is None:
# the name is available, store it in the database and go to the login page
user = User(username, generate_password_hash(password))
try:
db_session.add(user)
db_session.commit()
return redirect(url_for("auth.login"))
except Exception as e:
logger.exception('register user[{0}] exception: [{1}].'.format(
user, e))
db_session.rollback()
error = "Register failed."
flash(error)
return render_template("auth/register.html")
def default_data(app):
from flaskr import models
from flaskr.db import db_session
models.Rack.query.delete()
models.Server.query.delete()
db_session.commit()
rack = models.Rack(capacity=models.RackCapacities.ten)
db_session.add(rack)
db_session.commit()
for i in range(5):
db_session.add(models.Server(rack_id=rack.id))
rack.size = models.Rack.size + 1
db_session.commit()
rack = models.Rack(capacity=models.RackCapacities.twenty)
db_session.add(rack)
db_session.commit()
for i in range(20):
db_session.add(models.Server(rack_id=rack.id))
rack.size = models.Rack.size + 1
db_session.commit()
