class Org(DB.Model):
id = DB.Column(DB.Integer, primary_key=True, autoincrement=True)
name = DB.Column(DB.String(128))
address = DB.Column(DB.String(4096))
def __repr__(self):
return self.name
class Login(DB.Model):
id = DB.Column(DB.Integer, primary_key=True)
name = DB.Column(DB.String(80), unique=True, nullable=False)
email = DB.Column(DB.String(120), unique=True, nullable=False)
def __repr__(self):
return '<Login %r>' % self.name
def setUp(self):
test_config = TestConfig()
self.app = create_app(test_config)
self.app_context = self.app.app_context()
self.app_context.push()
self.client = self.app.test_client()
db.create_all()
def setUp(self):
""" A method that is called before each test. """
""" Pass testing configuration and initializes the app. """
self.app = create_app(config_name="testing")
self.client = self.app.test_client
with self.app.app_context():
DB.create_all()
class Tweet(Base):
__tablename__ = 'tweets'
text = db.Column(db.String(120), nullable=False)
user_id = db.Column(db.Integer, nullable=False)
liked = db.Column(db.Integer, nullable=False)
retweet = db.Column(db.Integer, nullable=False)
def __init__(self, text, user=None, username=None):
self.text = text
if username is not None:
user = User.query.filter_by(name=username).first()
self.user_id = user.id
else:
self.user_id = user.id
self.liked = random.randint(0, 10)
self.retweet = random.randint(0, 10)
def __repr__(self):
return '<Tweet %r>' % (self.text)
def get_username(self):
user = User.query.filter_by(id=self.user_id).first()
return user.name
class Bucketlist(db.Model):
"""This class represents the bucketlist table."""
__tablename__ = 'bucketlists'
id_key = db.Column(db.Integer, primary_key=True)
item = db.Column(db.String(255))
date_created = db.Column(db.DateTime, default=db.func.current_timestamp())
date_modified = db.Column(db.DateTime,
default=db.func.current_timestamp(),
onupdate=db.func.current_timestamp())
def __init__(self, name):
"""Initialize tables with name"""
self.name = name
def save(self):
db.session.add(self)
db.session.commit()
@staticmethod
def get_all():
return Bucketlist.query.all()
def delete(self):
db.session.delete(self)
db.session.commit()
def __repr__(self):
return "<Bucketlist: {}".format(self.name)
class Active(DB.Model):
'''Active User table.'''
id = DB.Column(DB.Integer, primary_key=True)
name = DB.Column(DB.String(80), unique=True, nullable=False)
def __repr__(self):
return '<Active %r>' % self.name
class JokeReaction(DB.Model):
"""jokes reactions model"""
__tablename__ = 'joke_reaction'
id = DB.Column(DB.Integer, primary_key=True)
joke_id = DB.Column(DB.Integer, DB.ForeignKey('joke.id'))
reaction_type = DB.Column(Enum(ReactionsType))
created_at = DB.Column(TIMESTAMP, default=datetime.utcnow, nullable=False)
def setUp(self):
APP.config['TESTING'] = True
APP.config['DEBUG'] = False
APP.config[
'SQLALCHEMY_DATABASE_URI'] = 'postgres://localhost/transport_test'
self.app = APP.test_client()
DB.drop_all()
DB.create_all()
self.lifegoup1 = {
'name': 'uq1',
'password': '******',
'email': '*****@*****.**'
}
self.lifegoup2 = {
'name': 'uq2',
'password': '******',
'email': '*****@*****.**'
}
self.lifegoup3 = {
'name': 'uq3',
'password': '******',
'email': '*****@*****.**'
}
DB.session.add(LifegroupModel(**self.lifegoup1))
DB.session.add(LifegroupModel(**self.lifegoup2))
DB.session.add(LifegroupModel(**self.lifegoup3))
DB.session.commit()
self.assertFalse(APP.debug)
def setUp(self):
APP.config['TESTING'] = True
APP.config['DEBUG'] = False
APP.config[
'SQLALCHEMY_DATABASE_URI'] = 'postgres://localhost/transport_test'
self.app = APP.test_client()
DB.drop_all()
DB.create_all()
self.lifegoup1 = {
'name': 'uq1',
'password': '******',
'email': '*****@*****.**'
}
self.lifegoup2 = {
'name': 'uq2',
'password': '******',
'email': '*****@*****.**'
}
self.lifegoup3 = {
'name': 'uq3',
'password': '******',
'email': '*****@*****.**'
}
DB.session.add(LifegroupModel(**self.lifegoup1))
DB.session.add(LifegroupModel(**self.lifegoup2))
DB.session.add(LifegroupModel(**self.lifegoup3))
DB.session.commit()
self.member1 = {
'id': '1',
'lifegroup': 'uq1',
'name': 'Kenneth Guo',
'suburb': 'Sunnybank QLD, 4109'
}
self.member2 = {
'id': '2',
'lifegroup': 'uq2',
'name': 'Ken Guo',
'suburb': 'Sunnybank QLD, 4109'
}
self.note1 = {
'id': '1',
'lifegroup': 'uq1',
'text': "A and B stay at the same place"
}
self.note2 = {
'id': '2',
'lifegroup': 'uq2',
'text': "C and D stay at the same place"
}
DB.session.add(MemberModel(**self.member1))
DB.session.add(MemberModel(**self.member2))
DB.session.add(NoteModel(**self.note1))
DB.session.add(NoteModel(**self.note2))
DB.session.commit()
self.assertFalse(APP.debug)
class Joined(DB.Model):
id = DB.Column(DB.Integer, primary_key=True)
username = DB.Column(DB.String(80), unique=True, nullable=False)
score = DB.Column(DB.Integer, unique=False, nullable=True)
def __repr__(self):
return '<Joined %r>' % self.username
class GoogleDate(DB.Model):
"""
ORM Model representing the date for which a complete set of Google terms for a particular model
ID was retrieved. The date here stored assumes the scores for a set of Google terms as a
transaction and should always be added to the session together with the set of GoogleScores.
"""
id = DB.Column(DB.Integer, primary_key=True)
flu_model_id = DB.Column(DB.Integer, DB.ForeignKey('model.id'))
transaction_timestamp = DB.Column(DB.DateTime, default=DB.func.current_timestamp())
score_date = DB.Column(DB.Date)
def __init__(self, model_id: int, score_date: date):
self.flu_model_id = model_id
self.score_date = score_date
def save(self):
""" Convenience method to save current instance """
DB.session.add(self)
DB.session.commit()
def __repr__(self):
return '<GoogleDate model_id=%d %s>' % (
self.flu_model_id, self.score_date.strftime('%Y-%m-%d')
)
class Gamer(DB.Model):
'''class sets table columns'''
id = DB.Column(DB.Integer, primary_key=True)
username = DB.Column(DB.String(80), unique=True, nullable=False)
gameswon = DB.Column(DB.Integer, nullable=False)
def __repr__(self):
return '<Gamer %r>' % self.username
def db():
''' creates tables and drops them for every test '''
DB.create_all()
yield
DB.session.commit()
DB.drop_all()
class Leaderboard(DB.Model):
'''Leaderboard table.'''
id = DB.Column(DB.Integer, primary_key=True)
username = DB.Column(DB.String(80), unique=True, nullable=False)
score = DB.Column(DB.Integer, nullable=False)
def __repr__(self):
return '<Leaderboard %r>' % self.username
class UserLevel(db.Model):
'''User level class definition'''
id = db.Column(db.Integer, primary_key=True)
levelname = db.Column(db.String(64), index=True, unique=True)
users = db.relationship('User', backref='level', lazy='dynamic')
def __repr__(self):
return '<User {}>'.format(self.levelname)
class User(DB.Model):
""" User class """
__tablename__ = "users"
id = DB.Column(DB.Integer, primary_key=True)
name = DB.Column(DB.String(64))
def __init__(self, name=None):
self.name = name
class Person(DB.Model):
'''
Schema for database
'''
username = DB.Column(DB.String(80), primary_key=True)
score = DB.Column(DB.Integer, nullable=False)
def __repr__(self):
return '<Person %r>' % self.username
class Person(db.Model):
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(80), unique=True, nullable=False)
email = db.Column(db.String(120), unique=True, nullable=False)
def __repr__(self):
return '<Person %r>' % self.username
def __init__(self, username, email):
self.username = username
self.email = email
class Subject(DB.Model):
"""Класс для сущности 'Предмет обучения'"""
__tablename__ = 'subject'
id = DB.Column('subject_id', DB.INTEGER, primary_key=True, autoincrement=True)
name = DB.Column('subject_name', DB.String(45), nullable=False, unique=True)
def __repr__(self):
return "Subject(id={id}, name={name})".format(id=self.id, name=self.name)
class Base(DB.Model):
__abstract__ = True
id = DB.Column(DB.Integer, primary_key=True)
date_created = DB.Column(DB.DateTime, default=DB.func.current_timestamp())
date_modified = DB.Column(DB.DateTime,
default=DB.func.current_timestamp(),
onupdate=DB.func.current_timestamp())
class Person(DB.Model):
''' manage DB'''
id = DB.Column(DB.Integer, primary_key=True)
username = DB.Column(DB.String(80), unique=True, nullable=False)
score = DB.Column(DB.Integer, unique=False, nullable=False)
date = DB.Column(DB.DateTime, unique=False, nullable=False)
def __repr__(self):
return '<Person %r>' % self.username
def app():
environ['FLASK_ENV'] = 'test'
_app = create_app()
with _app.app_context():
DB.create_all()
yield _app
DB.session.remove()
DB.drop_all()
return _app
class Category(DB.Model):
"""Joke category model """
id = DB.Column(DB.Integer, primary_key=True)
name = DB.Column(DB.String(128), index=True, unique=True)
average_rank = DB.Column(DB.Float)
jokes = DB.relationship('Joke', backref='category', lazy='dynamic')
def __repr__(self):
"""info about category"""
return '<Category %r>' % (self.name)
class Role(DB.Model):
"""Класс для сущности 'Роль пользователя в системе'"""
__tablename__ = 'role'
id = DB.Column(DB.Integer, primary_key=True)
name = DB.Column(DB.String(50), unique=True)
def __repr__(self):
return "Role(id={id}, name={name})". \
format(id=self.id, name=self.name)
class PsnBannerModel(DB.Model):
__tablename__ = 'psn_banner'
id = DB.Column(DB.Integer, primary_key=True)
banner_url = DB.Column(DB.JSON, nullable=False)
banner_background_url = DB.Column(DB.JSON)
def __init__(self, banner_url, banner_background_url):
self.banner_url = banner_url
self.banner_background_url = banner_background_url
class Like(DB.Model):
"""Table for Likes"""
like_id = DB.Column(DB.Integer, primary_key=True)
post_id = DB.Column(DB.Integer)
username = DB.Column(DB.String(225))
def __init__(self, post_id, username):
"""Constructor for adding Like to table"""
self.post_id = post_id
self.username = username
def setUp(self):
"""Define test variables and initialize app."""
self.app = create_app(config_name="TESTING")
self.client = self.app.test_client
self.bucketlist = {'name': 'Go to Borabora for vacation'}
# binds the app to the current context
with self.app.app_context():
# create all tables
DB.create_all()
class DefaultFluModel(DB.Model): # pylint: disable=too-few-public-methods
"""
ORM Model to define the default public model to be returned by the API
"""
id = DB.Column(DB.Integer, primary_key=True)
flu_model_id = DB.Column(DB.Integer, DB.ForeignKey('model.id'))
def __repr__(self):
return '<DefaultFluModel %d>' % self.flu_model_id
class Person(DB.Model):
"""
database shcema
"""
id = DB.Column(DB.Integer, primary_key=True)
username = DB.Column(DB.String(80), unique=True, nullable=False)
rank = DB.Column(DB.Integer)
def __repr__(self):
return '<Person %r>' % self.username
def del_schedule():
if current_user.admin:
form = SelectForm()
form.schedule_list.choices = DB.schedule_list()
if form.submit2.data:
DB.delete_schedule(form.schedule_list.data)
return redirect(url_for("index"))
return render_template("del_schedule.html", form=form)
else:
return redirect(url_for("index"))
#!./venv/bin/python
"""Set up DB tables and add some core data"""
from app import DB
import app.types
from re import compile, UNICODE
_strip_pattern = compile('[\W_]+', UNICODE)
DB.drop_all()
DB.create_all()
ROLE_MAP = {}
ALL_ROLES = ['admin', 'scorekeeper']
for role_name in ALL_ROLES:
role = app.types.Role(name=role_name)
DB.session.add(role)
ROLE_MAP[role_name] = role
for info in [
['avi', 'finkel.org', ALL_ROLES],
['elizabeth', 'papa.org', ALL_ROLES],
['admin', 'papa.org', ['admin']],
['scorekeeper', 'papa.org', ['scorekeeper']],
]:
user = app.types.User(
username=info[0],
email=info[0] + '@' + info[1],
from app import matrix, DB
import os,sys
# from app import initialize,
if __name__ == "__main__":
# initialize()
current_dir = os.path.dirname(os.path.abspath(__file__))
from web import views
from web import api
from web import admin
DB.create_all()
if True:
from werkzeug import SharedDataMiddleware
print current_dir
file_hosted_at = os.path.join(current_dir, 'web' , 'static')
print file_hosted_at
matrix.wsgi_app = SharedDataMiddleware(matrix.wsgi_app, {
'/static': file_hosted_at
})
matrix.run(debug=True,port=5555)
