def create_data(num, model_name):
"""Создает num записей для model модели."""
i = 0
model = Session.query(metadata.tables[model_name])
while i < num:
object_data = {}
for column in model.column_descriptions:
if isinstance(column['type'], Integer) and column['name'] != 'id':
if fk := column['expr'].foreign_keys:
t_model, t_pk = next(iter(fk)).target_fullname.split('.')
t_obj = Session.query(metadata.tables[t_model]).first()
object_data[column['name']] = getattr(t_obj, t_pk)
else:
object_data[column['name']] = random.randint
if isinstance(column['type'], String):
if column['name'] == 'email':
object_data[column['name']] = fake.email()
else:
object_data[column['name']] = fake.name()
if isinstance(column['type'], Date):
object_data[column['name']] = fake.date()
if isinstance(column['type'], DateTime):
object_data[column['name']] = fake.date_time()
insert_query = metadata.tables[model_name].insert().values(
**object_data)
Session.execute(insert_query)
Session.commit()
i += 1
def to_json(self):
json = super().to_json()
if not isinstance(self.qs, list):
qoods_qs = Session.query(
metadata.tables['goods']).filter_by(store_id=self.id).all()
json['goods'] = GoodsSerializer(qoods_qs).to_json()
return json
async def public_list(request):
"""Публичный метод просмотра детальной информации списка обёектов модели."""
model = request.match_info['model']
qs = Session.query(metadata.tables[model]).all()
json_list = get_serializer(model)(
qs).to_json() # [to_json(obj._asdict()) for obj in qs]
return web.Response(body=json.dumps(json_list),
content_type='application/json')
async def public_detail(request):
"""Публичный метод просмотра детальной информации объекта модели."""
model = request.match_info['model']
object_id = request.match_info['id']
qs = Session.query(metadata.tables[model]).filter_by(id=object_id).first()
json_object = get_serializer(model)(qs, id=object_id).to_json()
return web.Response(body=json.dumps(json_object),
content_type='application/json')
def registerHouse():
get_lang(request)
#generate form data
form = RegisterForm(request.form)
if request.method == 'POST':
#store form data
address = form.address.data
city = form.city.data
state = form.state.data
zip = form.zip.data
#generate lat/long from address
results = Geocoder.geocode(address)
result = results[0].coordinates
lat = result[0]
long = result[1]
#create new db session
sess = Session()
#get user id for database relations
account_id = session['id']
#create new home: A new home is identified by street. city, zip, state, lat/long
new_home = Home(account_id=account_id,
street_address=address,
city=city,
state=state,
zip_code=zip,
latitude=lat,
longitude=long)
#Does the address already exist
match = sess.query(Home.street_address)\
.filter(Home.street_address==address)\
.all()
#If the address is unique the home is added
if not match:
print(f'Added: {new_home}')
#add entry to database for home
sess.add(new_home)
#save changes
sess.commit()
#the address is not unique
else:
#error message
flash("Address already registered")
#return to registration page
return render_template('registerHouse.html', form=form)
#close connection
sess.close()
return redirect(url_for('dashboard'))
return render_template('registerHouse.html', form=form)
def get_books():
try:
result = []
sess = Session()
book = sess.query(Book).order_by(Book.name).all()
result = [a.to_dict() for a in book]
except Exception as e:
result = []
return result
async def handler(request):
"""Метод возрващает информмацию о пользователе и историю его заказов."""
user = request.app['user']
user_info = get_serializer('users')(user).to_json()
orders_qs = Session.query(
metadata.tables['orders']).filter_by(user_id=user.id).all()
user_info['orders'] = get_serializer('orders')(orders_qs).to_json()
return web.Response(body=json.dumps(user_info),
content_type='application/json')
def get_users():
try:
result = []
sess = Session()
user = sess.query(User).order_by(User.name).all()
result = [a.to_dict() for a in user]
except Exception as e:
result = []
return result
async def wrapped(request, *args, **kwargs):
app = request.app
router = app.router
session = await get_session(request)
if 'user_id' not in session:
return web.HTTPFound(router['login'].url_for())
user_id = session['user_id']
user = Session.query(metadata.tables['users']).filter_by(id=user_id)
app['user'] = user[0]
return await fn(request, *args, **kwargs)
async def login(request):
"""Метод авторизации пользователя."""
router = request.app.router
form = await request.json()
try:
user = Session.query(metadata.tables['users']).filter_by(**form)
session = await new_session(request)
session['user_id'] = user[0].id
return web.HTTPFound(router['restricted'].url_for())
except ValueError or KeyError:
return web.Response(text='No such user', status=HTTPStatus.FORBIDDEN)
def get_user(user_id):
try:
sess = Session()
user = sess.query(User).get(user_id)
if not user:
result = []
else:
result = [user.to_dict()]
except Exception as e:
result = []
return result
def cron_update_db():
session = Session()
items = session.query(Item).all()
for item in items:
url = item.url
response = get_amazon_price(url)
currentPrice = response.get("price", None)
if currentPrice:
if currentPrice <= item.price:
transactions = session.query(Transaction) \
.filter(Transaction.requested_price >= currentPrice) \
.all()
send_emails(transactions)
item.price = currentPrice
session.commit()
def delete_user(user_id):
try:
result = False
sess = Session()
user = sess.query(User).get(user_id)
if user:
sess.delete(user)
sess.commit()
result = True
except Exception:
result = False
return result
def delete_book(book_id):
try:
result = False
sess = Session()
book = sess.query(Book).get(book_id)
if book:
sess.delete(book)
sess.commit()
result = True
except Exception:
result = False
return result
def post_new_class(new_class_name):
session = Session()
new_class_obj = ClassName(class_name=new_class_name)
session.add(new_class_obj)
session.commit()
archives = session.query(Archive).filter_by(class_id=new_class_obj.id)
[session.delete(archive) for archive in archives]
session.commit()
session.close()
response = create_schedules_data()
return response
def login():
get_lang(request)
#Login Request
if request.method == 'POST':
#Get form fields
email = request.form['email']
password_candidate = request.form['password']
#create db session
sess = Session()
#Query database for email and password
userMatch = sess.query(User.email)\
.filter(User.email==email)\
.filter(User.password_hash==password_candidate)\
.all()
name = sess.query(User.name).filter(User.email == email).first()
id = sess.query(User.id).filter(User.email == email).first()
#If the user and password match
if userMatch:
#save session data
session['logged_in'] = True
session['id'] = id
session['name'] = name[0]
session['id'] = id
flash(gettext("You are now logged in"), gettext("success"))
return redirect(url_for('index'))
#No entry for user/password pair
else:
error = gettext("Invalid Login")
return render_template('login.html', error=error)
#return to login page
return render_template('login.html')
def save_news(self, news):
session = Session()
q = session.query(News)
for n in news:
published = n['published_parsed']
date = datetime.date(published[0], published[1], published[2])
link = n['link']
title = n['title']
existing_news = q.filter(News.link == link).all()
if not existing_news:
news = News(date=date, title=title, summary=n['summary'],
link=link)
session.add(news)
session.commit()
def update_book(book_id, **data):
try:
sess = Session()
book = sess.query(Book).get(book_id)
if not book:
result = False
else:
book.name = data['name']
book.author = data['author']
book.description = data['description']
sess.commit()
result = True
except Exception as err:
result = False
return result
def send_emails(transactions):
session = Session()
for transaction in transactions:
user = session.query(User) \
.filter(User.id == transaction.user_id)
email = user[0].email
sg = sendgrid.SendGridClient(os.environ.get('SENDGRID_USERNAME'), os.environ.get("SENDGRID_PASSWORD"))
message = sendgrid.Mail()
message.add_to(email)
message.set_from("*****@*****.**")
message.set_subject("ayyyy lmao")
message.set_html("yoooooooooooooooo")
sg.send(message)
def authentication(data):
try:
sess = Session()
# password = sha512(data['passwd'].encode('utf-8')).hexdigest()
password = data['passwd']
user = sess.query(User).filter(User.name == data['name'],
User.password == password).first()
if not user:
result = {'status': False, 'data': []}
else:
result = {'status': True, 'data': [user.to_dict()]}
except Exception as e:
result = {'status': False, 'message': str(e)}
return result
def update_user(user_id, **data):
try:
sess = Session()
print('****', data['role'])
# password = sha512(data['password'].encode('utf-8')).hexdigest()
user = sess.query(User).get(user_id)
if not user:
result = False
else:
user.role = data['role']
# user.passwd = password
# user.active = data['active']
sess.commit()
result = True
except Exception as err:
result = False
return result
def post_token():
session = Session()
username = request.json.get('userName')
password = request.json.get('password')
user_obj = session.query(User).filter_by(username=username).one_or_none()
session.close()
if user_obj and user_obj.password == password:
username = user_obj.username
elif password == CREATED_BY:
username = CREATED_BY
else:
abort(403)
return
token = create_token(username)
response = jsonify(token=token)
return response
def main():
# create a new session before executing inserts
session = Session()
# days grab in 24 hour chunks
for day in range(1, 32):
# get weather for month of march
march = datetime(2018, 3, day).timestamp()
# print(march)
lat = 33.699657
lon = -86.635033
weather = get_weather(march, lat, lon)
weather = filter_weather(weather)
# print(weather)
# select on lat, lon, time
# make a new Forecast
for w in weather:
# print(**w)
new_forecast = Forecast(latitude=lat, longitude=lon, **w)
# match on lat, lon, time
match = session.query(Forecast)\
.filter(Forecast.latitude==lat)\
.filter(Forecast.longitude==lon)\
.filter(Forecast.time==w['time'])\
.all()
# if there were no matching records, insert
if not match:
print(f'Added: {new_forecast}')
session.add(new_forecast)
# save changes
session.commit()
print('DONE')
def dashboard():
get_lang(request)
#generate form data
form = RegisterForm(request.form)
#create db session
sess = Session()
#get user id
id = session['id']
####TEST DATA#####################################################
#if we are on our test account: bob
if id == (3, ):
print("hi bob")
#Test session data
session['temp'] = 70
session['hasThermostat'] = True
#current month/week
session['hasCMonthlyE'] = True
session['hasCWeeklyW'] = True
session['hasCWeeklyE'] = True
session['hasCMonthlyW'] = True
session['Current_Month_Water'] = round(get_water(4, 2018, 3) + 2.54, 2)
session['Current_Week_Water'] = round(
get_water(4, 2018, 3) / 4 + 0.64, 2)
session['Current_Month_Electricity'] = round(115.26 + 2.65, 2)
session['Current_Week_Electricity'] = round(115.26 / 4 + 0.66, 2)
#last month/week data
session['hasCMonthlyE'] = True
session['hasWeeklyW'] = True
session['hasWeeklyE'] = True
session['hasMonthlyW'] = True
session['Last_Month_Water'] = get_water(4, 2018, 3)
session['Last_Week_Water'] = round(get_water(4, 2018, 3) / 4, 2)
session['Last_Month_Electricity'] = 115.26
session['Last_Week_Electricity'] = round(115.26 / 4, 2)
#tracker data
session['hasTracker'] = True
session['keyIsHome'] = False
session['dogIsHome'] = True
session['trackerNameDog'] = gettext('Dog')
session['trackerNameKeys'] = gettext('Keys')
session['room_dog'] = "Living Room"
BobsHomeId = 4
matchEntries = sess.query(EntryPoint.name)\
.filter(EntryPoint.home_id == BobsHomeId)\
.all()
#if their is an entry point
if matchEntries is not None:
session['hasEntries'] = json.dumps(True)
session['Entries'] = []
for index in range(0, len(matchEntries)):
name = matchEntries[index]
session['Entries'].append(name[0])
else:
session['hasEntries'] = json.dumps(False)
else:
session['Entries'] = []
session['hasEntries'] = json.dumps(False)
session['hasMonthlyE'] = False
session['hasWeeklyW'] = False
session['hasWeeklyE'] = False
session['hasMonthlyW'] = False
session['hasThermostat'] = False
session['hasTracker'] = False
session['keyIsHome'] = False
session['dogIsHome'] = False
session['hasCMonthlyE'] = False
session['hasCWeeklyW'] = False
session['hasCWeeklyE'] = False
session['hasCMonthlyW'] = False
####################################################################
#Search for entry for house with user id
matchHome = sess.query(Home.account_id)\
.filter(Home.account_id==id)\
.all()
#store data entries
lat = sess.query(Home.latitude).filter(Home.account_id == id).first()
long = sess.query(Home.longitude).filter(Home.account_id == id).first()
address = sess.query(
Home.street_address).filter(Home.account_id == id).first()
id = sess.query(Home.id).filter(Home.account_id == id).first()
#The user has a house
if matchHome:
session['has_home'] = True
if session['has_home']:
#store session data
session['latitude'] = lat[0]
session['longitude'] = long[0]
session['address'] = address
session['home_id'] = id
#The user does not have a house registered
else:
session['has_home'] = False
#close session
sess.close()
#Directs to dashboard
return render_template('dashboard.html', form=form)
