def add_entry():
if not session.get('logged_in'):
abort(401)
url = request.form['url']
# Add product to DB
existing = Product.query.filter(Product.url == url).first()
e = None
product = None
if not existing:
#Query Amazon
try:
product = azcrawler.crawl_url(url)
if product is None:
flash("Amazon doesn't sell this product today!")
return redirect(url_for('show_entries'))
e = Product(product[0], url , product[2], float(product[1][0]))
e.prev_price = 0
db = get_db()
db.session.add(e)
db.session.commit()
except:
flash("Error fetching product...")
return redirect(url_for('show_entries'))
existing = existing or e
# Add Subscription
s = Subscription.query.filter(Subscription.user_id == session['userid'],
Subscription.prod_id == existing.id).first()
if not s:
try:
print "Adding subscription"
sub = Subscription(existing.id, session['userid'])
db = get_db()
db.session.add(sub)
updt = DinoUpdate(json.dumps(
{"title": existing.title,
"message": "Watching currently at $%s"%(existing.curr_price),
"url": existing.url,
"img": existing.img_url,
"merchant": utils.get_merchant_name(existing.url),
"mag" : 0,
"userid": session['userid']}),
session['userid'],
existing.id)
print "Adding subscription %s"% updt
db.session.add(updt)
db.session.commit()
except Exception, e:
print "DB Tx failed: %s"%str(e)
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
self.config = read_config_file()
self.db = model.get_db(self.config['db_path'])
self.books = []
for book in self.db.query(model.Book).all():
self.books.append(book)
builder = Gtk.Builder()
builder.add_from_file('./gui/minerva.glade')
self.window = builder.get_object('minerva_main')
self.vbox = builder.get_object('vbox')
self.tv_filters = builder.get_object('tv_filters')
self.statusbar = builder.get_object('statusbar')
self.btn_edit = builder.get_object('btn_edit')
self.btn_delete = builder.get_object('btn_delete')
self.books = BookList(parent=self, books=self.books)
self.filters = Gtk.ListStore(str)
self.search_entry = Gtk.SearchEntry()
setup_info_bar(self)
self.vbox.pack_end(self.info_bar, False, True, 0)
self._setup_filters(self.filters, self.tv_filters)
builder.get_object('hpaned').pack2(self.books)
builder.get_object('hbox').pack_start(self.search_entry, True, True, 0)
builder.connect_signals(self)
self.search_entry.connect('search-changed', self.on_search_changed)
self.window.connect('key-press-event', self.on_key_press_event)
def create_login(resp):
if resp.email is None or resp.email == "":
print resp
flash('Invalid login. Please try again.')
return redirect(url_for('login'))
nickname = resp.nickname
if nickname is None or nickname == "":
nickname = resp.email.split('@')[0]
db = get_db()
user = User.query.filter_by(email = resp.email).first()
if user is None:
user = User(nickname = nickname, email = resp.email)
db.session.add(user)
db.session.commit()
remember = False
session['username'] = user.nickname
session['user_id'] = user.id
session['userid'] = user.id
if 'remember' in session:
remember = session['remember']
session.pop('remember', None)
login_user(user, remember=remember)
flash('You were logged in')
return redirect(url_for('show_entries'))
def before_request():
g.user = current_user
db = get_db()
if g.user.is_authenticated():
session.logged_in = True
g.user.last_seen = datetime.utcnow()
g.user.username = session['username']
db.session.add(g.user)
db.session.commit()
def on_quit(self, action, param):
db = model.get_db(self.config['db_path'])
for e in self.books.data:
b = model.Book(isbn=e[0],
title=e[1],
author=e[2],
own=e[3],
want=e[4],
read=e[5],
location=e[6])
db.merge(b)
db.commit()
self.quit()
def fakecrawl():
pids = request.args.get("pids",'').split(",")
prices = request.args.get("prices",'').split(",")
goup = request.args.get("goup")
godown = request.args.get("godown")
gotoodown = request.args.get("gotoodown")
GOUP, GODOWN, GOTOODOWN = 1.1, 0.9, 0.6
if not pids or not pids[0]:
return json.dumps({"result": "No updates for you"})
if prices and prices[0]:
for pid, price in zip(pids, prices):
hack(int(pid), float(price))
return json.dumps(dict((pid,price) for pid, price in zip(pids, prices)))
db = get_db()
mul = 1
if godown:
mul = GODOWN
elif gotoodown:
mul = GOTOODOWN
elif goup:
mul = GOUP
if godown or goup or gotoodown:
updates = {}
for p in pids:
existing = Product.query.filter(Product.id == int(p)).first()
print "Product found ", existing
if existing:
newprice = existing.curr_price * mul
existing.prev_price = existing.curr_price
existing.curr_price = newprice
if existing.lowest_price is None or existing.lowest_price == 0.0:
existing.lowest_price = min(existing.prev_price, existing.curr_price)
if existing.lowest_price > newprice:
existing.lowest_price = newprice
print "updated price ", newprice
try:
db.session.add(existing)
except Exception, e:
print str(e)
updates[int(p)] = newprice
print "updated price fpr prod"
print "Committing changes ", updates
db.session.commit()
t.updates(updated_prods=updates)
return json.dumps(updates)
def hack(pid, newprice):
print "Updating prod id %s to price %s"%(pid, newprice)
db = get_db()
existing = Product.query.filter(Product.id == pid).first()
if existing:
existing.prev_price = existing.curr_price
existing.curr_price = newprice
if existing.lowest_price > newprice:
existing.lowest_price = newprice
db.session.add(existing)
db.session.commit()
t.updates(updated_prods={pid: datetime.now()})
return json.dumps({'result': 'success', 'prod': pid})
return json.dumps({'result': 'Nothing to update'})
def test_db_specialization(self):
"""Create few test records needed to create TeacherSubject object.
This covers tests of:
- creating TeacherSubject object
- deleting teacher/subject recursively, what leads to deleting dependent TeacherSubject object
"""
with test_database(model.get_db(), self._table_model, create_tables=True, drop_tables=True):
test_subject = model.Subject.create(name='test_subject')
test_teacher = model.Teacher.create(**self._teacher_template)
test_specialization = model.TeacherSubject.create(teacher=test_teacher, specialization=test_subject)
self.assertTrue(test_specialization)
self.assertTrue(test_teacher.delete_instance(recursive=True)) # delete teacher and its dependencies
self.assertTrue(test_subject.delete_instance())
self.assertFalse(model.TeacherSubject.select().where(
model.TeacherSubject.teacher == test_teacher,
model.TeacherSubject.specialization == test_subject))
self.assertFalse(model.Teacher.select().where(model.Teacher.username == 'test_teacher'))
self.assertFalse(model.Subject.select().where(model.Subject.name == 'test_subject'))
def test_db_grading(self):
"""Create few test records needed to test grading system.
This covers tests of:
- creating Grade object
- deleting objects which Grade object is dependent on, what results in deleting the grade as well
"""
with test_database(model.get_db(), self._table_model, create_tables=True, drop_tables=True):
test_subject_1 = model.Subject.create(name='test_subject1')
test_subject_2 = model.Subject.create(name='test_subject2')
test_teacher = model.Teacher.create(**self._teacher_template)
test_student = model.Student.create(**self._student_template)
test_grade_1 = model.Grade.create(student=test_student, subject=test_subject_1, teacher=test_teacher,
grade='1')
test_grade_2 = model.Grade.create(student=test_student, subject=test_subject_2, teacher=test_teacher,
grade='2')
self.assertTrue(test_grade_1)
self.assertTrue(test_grade_2)
self.assertTrue(test_subject_1.delete_instance(recursive=True)) # delete subject and its dependencies
self.assertFalse(model.Grade.select().where(model.Grade.grade == '1'))
self.assertTrue(test_grade_2.delete_instance())
self.assertTrue(test_subject_2.delete_instance())
self.assertTrue(test_teacher.delete_instance())
self.assertTrue(test_student.delete_instance())
def get_tree():
db = model.get_db()
cur = db.cursor()
persons = []
# get all the people
cur.execute("SELECT * FROM person")
records = cur.fetchall()
for record in records:
persons.append(Person(record[0], record[1], record[2], record[3]))
# add the spouses
for p in persons:
cur.execute(
"SELECT id, bride FROM marriage WHERE groom = ? UNION SELECT id, groom FROM marriage WHERE bride = ?",
[p.id, p.id])
records = cur.fetchall()
for record in records:
spouse_id = record[1]
spouse = [per for per in persons if per.id == spouse_id]
p.spouse.append(spouse)
# get marriages and their children
marriage = record[0]
cur.execute("SELECT id, child FROM child WHERE marriage = ?",
[marriage])
records = cur.fetchall()
for rec in recs:
child = [per for per in persons if per.id == rec[1]]
p.children[rec[0]].append(child)
if len(persons):
return draw_tree(persons)
else:
return "Drag an object onto the canvas to start"
def update_db(s):
db = get_db()
today = date.today()
# Check if this is an existing record and update instead of insert
# Need to check if name and email is matching for cases where
# the user didn't have a connectome account
# This will update the first record, TODO - handle multiple results
result = db.execute(
"SELECT id FROM restrictedaccess WHERE lastname='%s' AND email='%s'" % \
(s['lastname'], s['email'])
).fetchone()
try:
existing_id = result[0]
except:
existing_id = None
if existing_id:
q = "UPDATE restrictedaccess SET login='******',email='%s',status='%s',status_updated='%s' WHERE id=%s" % \
(s['username'], s['email'], s['status'], today, existing_id)
print q
db.execute(q)
else:
q = "INSERT INTO restrictedaccess (firstname, lastname, email, login, status, status_updated) \
VALUES ('%s', '%s', '%s', '%s', '%s', '%s')" % \
(s['firstname'], s['lastname'], s['email'], s['username'], s['status'], today)
print q
db.execute(q)
try:
db.commit()
except OperationalError:
print "OperationalError on sqlite3 database. Retrying commit ..."
db.commit()
db.close()
import random
import telegram
import secret_setting
import model
from telegram import Update
from telegram.ext import Updater, CommandHandler, CallbackQueryHandler, CallbackContext, MessageHandler, Filters
logging.basicConfig(
format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
level=logging.INFO)
logger = logging.getLogger(__name__)
WELCOME_MSG = f'Welcome. Please enter your free time.'
DB_INSTANCE = model.get_db()
# command /start
def start(update, context):
context.user_data['get_txt'] = 0
logger.info(f'start..')
chat_id = update.effective_chat.id
logger.info(f'chat_id: {chat_id}')
DB_INSTANCE.add_user(chat_id)
free_time_keyboard = model.build_keyboard_free_times(chat_id)
num_select = len(DB_INSTANCE.get_user(chat_id).selected)
update.message.reply_text(WELCOME_MSG +
f'\nYou have selected <b>{num_select}</b> days.',
reply_markup=free_time_keyboard,
parse_mode=telegram.ParseMode.HTML)
def init_db():
db = model.get_db()
with app.open_resource('schema.sql', mode='r') as f:
db.cursor().executescript(f.read())
db.commit()
from forms import StudentLoginForm, AddGradeForm, TeacherLoginForm
from forms import flash_errors
from model import Student, Teacher, Subject, Grade, TeacherSubject
from model import get_db
from peewee import DatabaseError
from bcrypt import hashpw
from flask import flash, render_template, redirect, session, url_for
from exceptions import WrongPassword
"""This module contains only methods, which are used in main file gradebook.py"""
db = get_db()
def authorize_student(student):
session['logged_in'] = True
session['user_id'] = student.id
session['username'] = student.username
session['type'] = 'S'
def authorize_teacher(teacher):
session['logged_in'] = True
session['user_id'] = teacher.id
session['username'] = teacher.username
session['type'] = 'T'
def get_current_user():
"""Returns an object of Student or Teacher class, whose credentials are currently saved in session."""
def before_request():
g.db = model.get_db()
g.config = model.Config()
g.users = model.Users()
def test_db_student(self):
with test_database(model.get_db(), [model.Student], create_tables=True, drop_tables=True):
test_student = model.Student.create(**self._student_template)
self.assertTrue(test_student)
self.assertEqual(test_student, model.Student.get(model.Student.username == 'test_student'))
self.assertTrue(test_student.delete_instance())
def test_db_teacher(self):
with test_database(model.get_db(), [model.Teacher], create_tables=True, drop_tables=True):
test_teacher = model.Teacher.create(**self._teacher_template)
self.assertTrue(test_teacher)
self.assertEqual(test_teacher, model.Teacher.get(model.Teacher.username == 'test_teacher'))
self.assertTrue(test_teacher.delete_instance())
def test_db_subject(self):
with test_database(model.get_db(), [model.Subject], create_tables=True, drop_tables=True):
test_subject = model.Subject.create(name='test_subject')
self.assertTrue(test_subject)
self.assertEqual(test_subject, model.Subject.get(model.Subject.name == 'test_subject'))
self.assertTrue(test_subject.delete_instance())
def tearDown(self):
model.get_db().drop_tables(self._table_model, safe=True)
def show_entries():
db = get_db()
entries = DinoUpdate.query.filter(DinoUpdate.user_id==session['userid']).order_by(DinoUpdate.timestamp.desc())
entries = [(json.loads(x.update), timesince(to_user_timezone(x.timestamp))) for x in entries]
return render_template('show_entries.html', entries=entries)
