class Match(db.Model):
__tablename__ = 'match'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(50))
description = db.Column(db.String(200))
userId = db.Column(db.Integer, db.ForeignKey('user.id'))
opponentId = db.Column(db.Integer, db.ForeignKey('user.id'))
userTime = db.Column(db.Float)
userDistance = db.Column(db.Float)
opponentTime = db.Column(db.Float)
opponentDistance = db.Column(db.Float)
locationName = db.Column(db.String(50))
locationLatitude = db.Column(db.Float)
locationLongitude = db.Column(db.Float)
state = db.Column(db.Integer)
def __init__(
self, name, description, userId, opponentId, userTime,
userDistance, opponentTime, opponentDistance,
locationName, locationLatitude, locationLongitude, state
):
self.name = name
self.description = description
self.userId = userId
self.opponentId = opponentId
self.userTime = userTime
self.userDistance = userDistance
self.opponentTime = opponentTime
self.opponentDistance = opponentDistance
self.locationName = locationName
self.locationLatitude = locationLatitude
self.locationLongitude = locationLongitude
self.state = state
class Service(db.Model):
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(80))
description = db.Column(db.String(256))
price = db.Column(db.Float, nullable=True)
duration = db.Column(db.Interval, nullable=True)
performers = db.relationship('Performer', secondary=performer_service,
back_populates='services', lazy='dynamic')
business_id = db.Column(db.Integer, db.ForeignKey(
'business.id',
onupdate="CASCADE",
ondelete="CASCADE"
), nullable=False)
business = db.relationship("Business", back_populates='services')
appointments = db.relationship('Appointment', back_populates='service')
def to_obj(self):
return {
'id': self.id,
'name': self.name,
'description': self.description,
'price': self.price,
'duration': str(self.duration),
'performers': list(map(lambda x: x.id, self.performers))
}
@staticmethod
def get(service_id):
return db.session.query(Service).get(service_id)
class Business(db.Model):
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(80), nullable=True, unique=True)
phone = db.Column(db.String(80), nullable=True)
address = db.Column(db.String(256), nullable=True)
user_id = db.Column(db.Integer, db.ForeignKey(
'user.id',
onupdate="CASCADE",
ondelete="CASCADE"
), nullable=False)
services = db.relationship("Service", back_populates='business')
performers = db.relationship("Performer", back_populates='business')
def to_obj(self):
return {
'id': self.id,
'name': self.name,
'address': self.address,
'phone': self.phone,
'performers': list(map(lambda x: x.to_obj(), self.performers)),
'services': list(map(lambda x: x.to_obj(), self.services))
}
@staticmethod
def get(user_id):
return db.session.query(Business).filter(Business.user_id == user_id).first()
class ConfigFile(db.Model):
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(128), index=True)
path = db.Column(db.String(256))
def __repr__(self):
return '<ConfigFile {} ({})>'.format(self.name, self.path)
class Species(db.Model):
__tablename__ = 'species'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(120), unique=True, nullable=False)
homeworld = db.Column(db.String(120), nullable=False)
quadrant = db.Column(db.String(120), nullable=False)
warp_capable = db.Column(db.Boolean, nullable=False)
sightings = db.Column(db.Integer, nullable=False)
extinct = db.Column(db.Boolean, nullable=True)
extra_galactic = db.Column(db.Boolean, nullable=True)
humanoid = db.Column(db.Boolean, nullable=True)
reptilian = db.Column(db.Boolean, nullable=True)
non_corporeal = db.Column(db.Boolean, nullable=True)
shape_shifting = db.Column(db.Boolean, nullable=True)
spaceborne = db.Column(db.Boolean, nullable=True)
telepathic = db.Column(db.Boolean, nullable=True)
trans_dimentional = db.Column(db.Boolean, nullable=True)
alternate_reality = db.Column(db.Boolean, nullable=True)
def __repr__(self):
return '<Species {}>'.format(self.name)
def _serializable_keys(self):
return [
'id', 'name', 'homeworld', 'quadrant', 'warp_capable', 'sightings',
'extinct', 'extra_galactic', 'humanoid', 'reptilian',
'non_corporeal', 'shape_shifting', 'spaceborne', 'telepathic',
'trans_dimentional', 'alternate_reality'
]
def serialize(self):
return {key: self.__dict__[key] for key in self._serializable_keys()}
class VirtualAliases(db.Model, TrackModifications):
__tablename__ = "virtual_aliases"
id = db.Column(db.Integer, primary_key=True, nullable=False)
domain_id = db.Column(
db.Integer, db.ForeignKey('virtual_domains.id', ondelete="CASCADE"))
domain = db.relationship("VirtualDomains", back_populates="aliases")
source = db.Column(db.String(128), nullable=False)
destination = db.Column(db.String(128), nullable=False)
def __repr__(self):
return f"Forwarding: {self.source} => {self.destination}"
def source_name(self):
try:
return self.source.split("@")[0]
except IndexError:
return ""
def set_source(self, source, domain):
self.source = f'{source}@{domain}'
def update_source(self, domain):
self.source = f"{self.source_name()}@{domain}"
def json(self):
return {
"id": self.id,
"source": self.source,
"destination": self.destination,
"source_name": self.source_name(),
"domain": self.domain.name,
"domain_id": self.domain_id,
"created_at": datetime_browser_format(self.created_at),
"updated_at": datetime_browser_format(self.updated_at)
}
class Tournament(db.Model):
'''Represents tournament'''
__tablename__ = 'tournament'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
user_id = db.Column(db.ForeignKey(User.id), nullable=False)
name = db.Column(db.String(64), index=True)
date = db.Column(db.Date)
uuid = db.Column(db.String(36))
active = db.Column(db.Boolean)
# Config related fields
rounds = db.Column(db.Integer)
current_round = db.Column(db.Integer)
victory_value = db.Column(db.Integer)
tie_value = db.Column(db.Integer)
def __init__(self, name, user_id):
self.name = name
self.user_id = user_id
self.date = datetime.now()
self.uuid = uuid.uuid4()
self.active = True
self.rounds = c.config['tournament']['rounds']
self.current_round = 1
self.victory_value = c.config['tournament']['vp']
self.tie_value = c.config['tournament']['tie']
class Content(db.Model):
__tablename__ = "tb_content"
id = db.Column(db.Integer, primary_key=True)
create_time = db.Column(db.DATETIME, default=datetime.now)
update_time = db.Column(db.DATETIME, default=datetime.now)
title = db.Column(db.String(255))
url = db.Column(db.String(255))
image = db.Column(db.String(255))
text = db.Column(db.String(255))
sequence = db.Column(db.Integer)
status = db.Column(db.Boolean)
category_id = db.Column(db.Integer)
def to_dict(self):
return {
"id": self.id,
"create_time": self.create_time,
"update_time": self.update_time,
"title": self.title,
"url": self.url,
"image": self.image,
"text": self.text,
"sequence": self.sequence,
"status": self.status,
"category_id": self.category_id
}
class UserModel(db.Model):
"""User database table."""
__tablename__ = "users"
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(120), unique=True, nullable=False)
password = db.Column(db.String(120), nullable=False)
@classmethod
def find_by_username(cls, username):
"""Return user by username."""
return cls.query.filter_by(username=username).first()
def save_to_db(self):
"""Use this as auto_commit is False."""
db.session.add(self)
db.session.commit()
@staticmethod
def generate_hash(password):
"""Generate password hash."""
return sha256.hash(password)
@staticmethod
def verify_hash(password, hash):
"""Verify password hash."""
return sha256.verify(password, hash)
class CourseSections(db.Model):
__tablename__ = 'course_sections'
id = db.Column(db.Integer, primary_key=True)
code = db.Column(db.String(20))
name = db.Column(db.String(50))
course_id = db.Column(db.Integer, db.ForeignKey('courses.id'))
teacher_id = db.Column(db.Integer, db.ForeignKey('users.id'))
course_section_period = db.Column(db.String(6))
section_times = db.relationship("SectionTimes",
backref='course_section',
lazy='dynamic')
__table_args__ = (db.UniqueConstraint('course_id',
'teacher_id',
'course_section_period',
'code',
name='course_section_period_uc'), )
def __str__(self):
return str('{0} - {1}').format(
str(Courses.query.get(self.course_id).code),
str(self.course_section_period))
def set_fields(self, fields):
self.code = fields['code']
self.name = fields['name']
self.course_id = fields['course_id']
self.teacher_id = fields['teacher_id']
self.course_section_period = fields['course_section_period']
class Conferences(db.Model):
id = db.Column(db.Integer, primary_key=True)
acronym = db.Column(db.String(50))
name = db.Column(db.String(50))
city = db.Column(db.String(50))
country = db.Column(db.String(50))
venue = db.Column(db.String(50))
start_date = db.Column(db.Date())
end_date = db.Column(db.Date())
def set_fields(self, fields):
self.acronym = fields.get('acronym')
self.name = fields.get('name')
self.city = fields.get('city')
self.country = fields.get('country')
self.venue = fields.get('venue')
self.start_date = datetime.datetime.strptime(
fields.get('start_date'),
"%d/%m/%Y").date() if fields.get('start_date') else None
self.end_date = datetime.datetime.strptime(
fields.get('end_date'),
"%d/%m/%Y").date() if fields.get('end_date') else None
def serialize(self):
return dict(id=self.id,
acronym=self.acronym,
name=self.name,
city=self.city,
country=self.country,
venue=self.venue,
start_date=self.start_date.strftime('%d/%m/%Y')
if self.start_date else None,
end_date=self.end_date.strftime('%d/%m/%Y')
if self.end_date else None)
class Client(db.Model):
id = db.Column(db.Integer, primary_key=True)
phone_number = db.Column(db.String(50))
name = db.Column(db.String(100))
assigned_gender = db.Column(db.String(50))
assigned_age = db.Column(db.String(50))
email = db.Column(db.String(50))
is_deleted = db.Column(db.Boolean)
establishment_id = db.Column(db.Integer)
def __init__(self,
id=None,
phone_number,
name,
assigned_gender,
assigned_age,
email,
is_deleted=None,
establishment_id):
self.id = id
self.phone_number = phone_number
self.name = name
self.assigned_gender = assigned_gender
self.assigned_age = assigned_age
self.email = email
self.is_deleted = is_deleted
self.establishment_id = establishment_id
def __repr__(self):
return "<Client %r>" % self.id % self.phone_number % self.name % self.assigned_gender % self.assigned_age % self.email % self.is_deleted % self.establishment_id
class Merchant(db.Model):
id = db.Column(db.Integer, primary_key=True)
merchant_id = db.Column(db.String(127), nullable=False)
name = db.Column(db.String(255), nullable=False)
restriction = db.Column(db.Integer,
db.ForeignKey('restriction.id'),
nullable=True)
class Player(db.Model):
id = db.Column(db.Integer, primary_key=True)
date_updated = db.Column(db.DateTime,
nullable=False,
default=datetime.utcnow)
tag = db.Column(db.String(20), nullable=False)
name = db.Column(db.String(50), nullable=False)
town_hall_level = db.Column(db.Integer, nullable=False)
town_hall_weapon_level = db.Column(db.Integer, nullable=False)
exp_level = db.Column(db.Integer, nullable=False)
trophies = db.Column(db.Integer, nullable=False)
best_trophies = db.Column(db.Integer, nullable=False)
war_stars = db.Column(db.Integer, nullable=False)
attack_wins = db.Column(db.Integer, nullable=False)
defence_wins = db.Column(db.Integer, nullable=False)
builder_hall_level = db.Column(db.Integer, nullable=False)
versus_trophies = db.Column(db.Integer, nullable=False)
best_versus_trophies = db.Column(db.Integer, nullable=False)
versus_battle_wins = db.Column(db.Integer, nullable=False)
role = db.Column(db.String(50), nullable=False)
donations = db.Column(db.Integer, nullable=False)
donations_received = db.Column(db.Integer, nullable=False)
clan_name = db.Column(db.String(50), nullable=False)
clan_tag = db.Column(db.String(50), nullable=False)
league = db.Column(db.JSON, nullable=False)
legend_statistics = db.Column(db.JSON, nullable=False)
achievements = db.Column(db.JSON, nullable=False)
labels = db.Column(db.JSON, nullable=False)
troops = db.Column(db.JSON, nullable=False)
heroes = db.Column(db.JSON, nullable=False)
spells = db.Column(db.JSON, nullable=False)
class BlogComment(db.Model):
id = db.Column(db.Integer, primary_key=True)
created = db.Column(db.DateTime,
server_default=db.func.now(),
onupdate=db.func.now())
modified = db.Column(db.DateTime, server_default=db.func.now())
# title = db.Column(db.String(128))
author = db.Column(db.String(128))
author_email = db.Column(db.String(128))
author_website = db.Column(db.String(128), nullable=True)
content = db.Column(db.Text)
by_author = db.Column(db.Boolean, default=False)
replied_to_id = db.Column(db.Integer,
db.ForeignKey('blog_comment.id'),
index=True)
replied_to = db.relationship(lambda: BlogComment,
remote_side=id,
backref=db.backref('sub_comments',
lazy='dynamic'))
post_id = db.Column(db.Integer, db.ForeignKey(BlogPost.id), index=True)
post = db.relationship(BlogPost,
backref=db.backref('comments', lazy='dynamic'))
class User(db.Model, UserMixin):
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(127), nullable=False)
email = db.Column(db.String(63), unique=True, nullable=False)
password = db.Column(db.String(63), unique=False, nullable=False)
isAdmin = db.Column(db.Boolean, nullable=False, default=False)
def get_auth_token(self, expires_seconds=86400):
s = Serializer(current_app.config['SECRET_KEY'], expires_seconds)
return s.dumps({'user_id': self.id}).decode('utf-8')
@staticmethod
def verify_auth_token(token):
s = Serializer(current_app.config['SECRET_KEY'])
try:
user_id = s.loads(token)['user_id']
except:
return None
return User.query.get(user_id)
def get_reset_token(self, expires_seconds=1800):
s = Serializer(current_app.config['SECRET_KEY'], expires_seconds)
return s.dumps({'user_id': self.id}).decode('utf-8')
@staticmethod
def verify_reset_token(token):
s = Serializer(current_app.config['SECRET_KEY'])
try:
user_id = s.loads(token)['user_id']
except:
return None
return User.query.get(user_id)
def __repr__(self):
return f"User ID {self.id}"
class Project(db.Model):
__tablename__ = "project"
id = db.Column("id", db.Integer(), primary_key=True)
name = db.Column("name", db.String(32), nullable=False, unique=True)
creator_user_id = db.Column(
"creator_user_id", db.Integer(), db.ForeignKey("user.id"), nullable=False
)
api_key = db.Column("api_key", db.String(32), nullable=False, unique=True)
created_at = db.Column(
"created_at", db.DateTime(), nullable=False, default=db.func.now()
)
last_modified = db.Column(
"last_modified",
db.DateTime(),
nullable=False,
default=db.func.now(),
onupdate=db.func.utc_timestamp(),
)
users = db.relationship(
"User", secondary=user_project_table, back_populates="projects"
)
data = db.relationship("Data", backref="Project")
labels = db.relationship("Label", backref="Project")
creator_user = db.relationship("User")
class Prize(db.Model):
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(50))
photo = db.Column(db.String(100))
amount_to_redeem = db.Column(db.Integer)
description = db.Column(db.String(100))
is_deleted = db.Column(db.Boolean)
establishment_id = db.Column(db.Integer)
def __init__(self,
id=None,
name,
photo,
amount_to_redeem,
description,
is_deleted=None,
establishment_id):
self.id = id
self.name = name
self.photo = photo
self.amount_to_redeem = amount_to_redeem
self.description = description
self.is_deleted = is_deleted
self.establishment_id = establishment_id
def __repr__(self):
return "<Prize %r>" % self.id % self.name % self.photo % self.amount_to_redeem % self.description % self.is_deleted % self.establishment_id
class User(db.Model):
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(64), index=True, unique=True)
email = db.Column(db.String(120), index=True, unique=True)
password = db.Column(db.String(128))
roles = db.Column(db.String(64))
is_active = db.Column(db.Boolean, default=True, server_default='true')
#logs = db.relationship('Log', backref='uploader', lazy='dynamic')
@property
def rolenames(self):
try:
return self.roles.split(',')
except Exception:
return []
@classmethod
def lookup(cls, username):
return cls.query.filter_by(username=username).one_or_none()
@classmethod
def identify(cls, id):
return cls.query.get(id)
@property
def identity(self):
return self.id
def is_valid(self):
return self.is_active
def __repr__(self):
return '<User {}>'.format(self.username)
class Users(db.Model):
__tablename__ = 'Users'
user_id = db.Column(db.Integer, primary_key=True, autoincrement=True)
password = db.Column(db.String(255))
email = db.Column(db.String(255))
firstName = db.Column(db.String(255))
lastName = db.Column(db.String(255))
def __init__(self, password, email, firstName, lastName):
self.password = password
self.email = email
self.firstName = firstName
self.lastName = lastName
def create_user(self):
status = Users.query.filter_by(email=self.email).first()
if status is not None:
return False
db.session.add(self)
db.session.commit()
return True
def login_user(self):
account = Users.query.filter_by(email=self.email).first()
if account is None:
return False
elif self.password != account.password:
return False
else:
self.firstName = account.firstName
self.lastName = account.lastName
self.user_id = account.user_id
return True
class User(db.Model):
"""This is the first model in the database."""
__tablename__ = 'users'
# Fields in this model
id = db.Column(db.Integer, primary_key=True)
email = db.Column(db.String(50), nullable=False, unique=True)
username = db.Column(db.String(30), nullable=False, unique=True)
password = db.Column(db.String, nullable=False)
def __init__(self, email, username, password):
"""
This function initializes this model. This function is necessary
since we are hashing the user's password before storing it into
the database.
"""
self.email = email
self.username = username
# Protecting the user's password using a hash function
self.password = bcrypt.generate_password_hash(password.encode('utf-8'))
def check_password(self, password):
"""This is a helper function for checking the user's password."""
return bcrypt.check_password_hash(self.password, password)
# More models can be added here...
class User(db.Model, UserMixin):
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(12), unique=True, nullable=False)
email = db.Column(db.String(120), unique=True, nullable=False)
image_file = db.Column(db.String(20),
nullable=False,
default="default.jpg")
password = db.Column(db.String(60), nullable=False)
posts = db.relationship("Post", backref="author", lazy=True)
# Generate a token
def get_reset_token(self, expires_sec=1800):
s = Serializer(app.config["SECRET_KEY"], expires_sec)
return s.dumps({"user_id": self.id}).decode("utf-8")
# Verify the token and accept only a token (static decorator)
@staticmethod
def verify_reset_token(token):
s = Serializer(app.config["SECRET_KEY"])
try:
user_id = s.loads(token)["user_id"]
except:
return None
return User.query.get(user_id)
def __repr__(self):
return f"User('{self.username}', '{self.email}', '{self.image_file}')"
class User(db.Model):
__tablename__ = 'user'
# id is the RC user ID
id = db.Column(db.Integer, primary_key=True, autoincrement=False)
name = db.Column(db.String(500))
avatar_url = db.Column(db.String(500), nullable=True)
faculty = db.Column(db.Boolean)
anonymous_by_default = db.Column(db.Boolean)
#read_by_default = db.Column(db.Boolean)
autosave_timeout = db.Column(db.Integer)
autosave_enabled = db.Column(db.Boolean)
random_seed = db.Column(db.LargeBinary(32))
def __init__(self, id, name, **kwargs):
self.id = id
self.name = name
self.avatar_url = kwargs.get("avatar_url", None)
self.faculty = kwargs.get("faculty", None)
self.anonymous_by_default = kwargs.get("anonymous_by_default", False)
# self.read_by_default = kwargs.get("read_by_default", False)
self.autosave_timeout = kwargs.get("autosave_timeout", 10)
self.autosave_enabled = kwargs.get("autosave_enabled", True)
self.random_seed = urandom(32)
def __repr__(self):
return '<User:{} ({})>'.format(self.id, self.name)
class Clan(db.Model):
id = db.Column(db.Integer, primary_key=True)
date_updated = db.Column(db.DateTime,
nullable=False,
default=datetime.utcnow)
tag = db.Column(db.String(20), nullable=False)
name = db.Column(db.String(50), nullable=False)
invite_type = db.Column(db.String(50), nullable=False)
description = db.Column(db.String(200), nullable=False)
location = db.Column(db.JSON, nullable=False)
badge_url = db.Column(db.JSON, nullable=False)
clan_level = db.Column(db.Integer, nullable=False)
clan_points = db.Column(db.Integer, nullable=False)
clan_versus_points = db.Column(db.Integer, nullable=False)
required_trophies = db.Column(db.Integer, nullable=True)
war_frequency = db.Column(db.Integer, nullable=False)
war_win_streak = db.Column(db.Integer, nullable=False)
war_wins = db.Column(db.Integer, nullable=False)
war_ties = db.Column(db.Integer, nullable=False)
war_losses = db.Column(db.Integer, nullable=False)
is_warlog_public = db.Column(db.Boolean, nullable=False)
war_league = db.Column(db.JSON, nullable=True)
member_count = db.Column(db.Integer, nullable=False)
labels = db.Column(db.JSON, nullable=True)
member_list = db.relationship('Clan_members_list',
backref="clan",
lazy=True)
class Member(db.Model):
id = db.Column(db.Integer, primary_key=True)
first_name = db.Column(db.String(30), nullable=False)
last_name = db.Column(db.String(30), nullable=False)
institution = db.Column(db.String(120), nullable=False)
is_executive_assistant = db.Column(db.Boolean)
is_archived = db.Column(db.Boolean)
executive_assistant_id = db.Column(db.Integer, db.ForeignKey('member.id'))
executive_assistant = db.relationship('Member',
backref='member_executive_assistant',
uselist=False,
remote_side=[id],
lazy=True)
emails = db.relationship('Email', backref='member', lazy=True)
phone_numbers = db.relationship('PhoneNumber', backref='member', lazy=True)
lists = db.relationship('List',
secondary=list_memberships,
backref=db.backref('members', lazy=True),
lazy=True)
cure_center_profile = db.relationship('CureCenterProfile',
backref='member',
uselist=False)
def __repr__(self):
return f"<Member(first='{self.first_name}', last='{self.last_name}')>"
class User(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 f'<User {self.username}>'
class User(UserMixin, db.Model):
__tablename__ = 'users'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(255), unique=True, nullable=False)
email = db.Column(db.String(255), unique=True, nullable=False)
_password = db.Column('password', db.String(255), nullable=False)
active = db.Column(db.Boolean(), default=True)
def _get_password(self):
return self._password
def _set_password(self, password):
if password:
password = password.strip()
self._password = generate_password_hash(password)
password_descriptor = property(_get_password, _set_password)
password = synonym('_password', descriptor=password_descriptor)
def check_password(self, password):
password = password.strip()
if not password:
return False
return check_password_hash(self.password, password)
@classmethod
def auth(cls, query, email, password):
user = query(cls).filter(cls.email == email).first()
if user is None:
return None, False
return user, user.check_password(password)
class User(db.Model):
__tablename__ = "users"
id = db.Column(db.Integer, primary_key=True)
mobile = db.Column(db.String(255), unique=True)
username = db.Column(db.String(255))
userpassword = db.Column(db.String(255))
create_time = db.Column(db.DATETIME, default=datetime.now)
class List(db.Model):
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(50), nullable=False)
list_type = db.Column(db.String(30), nullable=False)
description = db.Column(db.String(120), nullable=False)
def __repr__(self):
return f"<List(name='{self.name}')>"
class User(UserMixin, db.Model):
id = db.Column(db.Integer, primary_key=True)
email = db.Column(db.String(255), unique=True)
password = db.Column(db.String(255))
firstName = db.Column(db.String(255))
lastName = db.Column(db.String(255))
profilePic = db.Column(db.String(255))
admin = db.Column(db.Integer)
