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)