class Users(db.Model, UserMixin):
username = db.Column(db.String, nullable=False)
password = db.Column(db.String, nullable=False)
contact = db.Column(db.Integer, primary_key=True)
usertype = db.Column(db.String, nullable=True)
card = db.Column(db.String)
isparttime = db.Column(db.Boolean)
postalcode = db.Column(db.String)
biddingccontact = db.relationship('Biddings', backref='contact')
cantakecareccontact = db.relationship('Cantakecare', backref='contact')
pet = db.relationship('Pets', backref='owner')
# Relationships
roles = db.relationship('Role', secondary='user_roles',
backref=db.backref('users', lazy='dynamic'))
def is_authenticated(self):
return True
def is_active(self):
return True
def is_anonymous(self):
return False
def get_id(self):
return self.contact
class Trip(db.Model):
id = db.Column(db.Integer, primary_key=True)
url = db.Column(db.Text, nullable=False)
date = db.Column(db.DateTime, default=datetime.utcnow)
description = db.Column(db.String(300))
destination = db.Column(db.String(300))
#need to figure out a way to store DateTime properly
outbound_date = db.Column(db.String(300))
outbound_time = db.Column(db.String(300))
inbound_date = db.Column(db.String(300))
inbound_time = db.Column(db.String(300))
user_id = db.Column(db.Integer, db.ForeignKey('user.id'), nullable=False)
_tags = db.relationship('Tag', secondary=tags, lazy='joined', backref=db.backref('trips', lazy='dynamic'))
privacy = db.Column(db.Boolean, default=False)
@staticmethod
def newest(num):
return Trip.query.filter(Trip.privacy.is_(False)).order_by(desc(Trip.date)).limit(num)
@property
def tags(self):
return ",".join([t.name for t in self._tags])
@tags.setter
def tags(self, string):
if string:
self._tags = [Tag.get_or_create(name) for name in string.split(',')]
def __repr__(self):
return "<Trip '{}': '{}'>".format(self.description, self.url)
class User(db.Model, UserMixin):
id = db.Column(db.Integer, primary_key=True)
email = db.Column(db.String(255), unique=True)
name = db.Column(db.String(255), nullable=False)
phone_number = db.Column(db.String(255))
photo = db.Column(db.String(255))
about = db.Column(db.String(1000))
why = db.Column(db.String(1000))
password = db.Column(db.String(255))
active = db.Column(db.Boolean(), default=False)
approved = db.Column(db.Boolean(), default=False)
confirmed_at = db.Column(db.DateTime())
roles = db.relationship('Role', secondary=roles_users, backref=db.backref('users', lazy='dynamic'))
registered_at = db.Column(db.DateTime, default=datetime.now)
@property
def is_logged_in(self):
return False if self.is_anonymous() else True
@property
def is_admin(self):
return self.roles and self.roles[0].name == 'admin'
def __repr__(self):
return self.name
@property
def admin_url(self):
return "%s/%s/%s" % (app.config['ADMIN_URL'], 'user', self.id)
@property
def url(self):
return "%s/%s/" % ('profiles', self.name)
class User(db.Model, UserMixin):
id = db.Column(db.Integer(), primary_key=True)
email = db.Column(db.String(255), unique=True)
password = db.Column(db.String(255))
scores = db.Column(db.Integer(), default=0)
active = db.Column(db.Boolean(), default=True)
roles = db.relationship('Role',
secondary=role_user_link,
backref=db.backref('users', lazy='dynamic'))
palindromes = db.relationship('Palindrome',
secondary=palindrome_user_link,
backref=db.backref('users', lazy='dynamic'))
def __repr__(self):
return 'ID: {}, Email: {}'.format(self.id, self.email)
class geneontology(db.Model):
'''a database of gene ontologies from msigdb that has been processed for DGCA'''
__tablename__='geneontology'
id = db.Column(db.BigInteger, primary_key=True)
system = db.Column(db.String(255))
category = db.Column(db.String(255))
population_hits = db.Column(db.Integer)
population_total = db.Column(db.Integer)
genes = db.relationship('ensembl',secondary=go_modules, lazy='subquery',backref=db.backref('geneontology', lazy=True))
class UserInfo(db.Model):
__tablename__ = 'user_info'
user_id = db.Column(db.INTEGER, primary_key=True)
first_name = db.Column(db.Unicode(50), nullable=False, server_default=u'')
email = db.Column(db.Unicode(255), nullable=False, server_default=u'', unique=True)
gender = db.Column(db.VARCHAR(10), nullable=False, server_default='0')
age = db.Column(db.INTEGER)
address = db.Column(db.VARCHAR(255))
mobile = db.Column(db.BIGINT)
# Relationships
spectacles = db.relationship('Spectacles', secondary='user_spec', backref=db.backref('user_info', lazy='dynamic'))
class Hobies(db.Model):
__tablename__ = 'hobies'
prod_id = db.Column(db.Integer, primary_key=True)
tag = db.Column(db.String(50), nullable=False)
title = db.Column(db.String(50), nullable=False)
content = db.Column(db.String(200), nullable=False)
image_file = db.Column(db.String(20),
nullable=False,
default='default.jpg')
users_prod = db.relationship('User',
secondary=subs,
backref=db.backref('products',
lazy='dynamic'))
class User(db.Model):
__tablename__ = 'users'
id = Column(
Integer,
primary_key=True,
unique=True,
)
name = Column(String)
username = Column(String, unique=True)
email = Column(String, unique=True)
password = Column(String)
created_on = Column(DateTime, default=datetime.utcnow)
updated_on = Column(DateTime, default=datetime.utcnow)
# Нужен для security
active = Column(Boolean)
# для получения доступа к связанным объектам
roles = relationship('Role',
secondary=roles_users,
backref=db.backref('users', lazy='dynamic'))
#Flask Login
@property
def is_authenticated(self):
return True
@property
def is_active(self):
return True
@property
def is_anonymous(self):
return False
#Flask has security
def has_role(self, *args):
return set(args).issubset({role.name for role in self.roles})
def get_id(self):
return self.id
#Required administrative interface
def __unicode__(self):
return self.username
def set_password(self, password):
self.password = generate_password_hash(password)
def check_password(self, password):
return check_password_hash(self.password, password)
class Conversation(db.Model):
id = db.Column(db.Integer, primary_key=True)
users = db.relationship('User', secondary=conversation_users,
backref=db.backref('conversations', lazy='dynamic'))
request_id = db.Column(db.Integer, db.ForeignKey('request.id'))
request = db.relationship('Request', backref='conversation')
title = db.Column(db.String(255))
created_at = db.Column(db.DateTime, default=datetime.now)
updated_at = db.Column(db.DateTime, default=datetime.now)
@property
def admin_url(self):
return "%s/%s/%s" % (app.config['ADMIN_URL'], 'conversation', self.id)
@property
def url(self):
return "%s/%s" % ('conversation', self.id)
class Post(db.Model):
id = db.Column(db.Integer, primary_key=True)
blog_id = db.Column(db.Integer, db.ForeignKey('blog.id'))
author_id = db.Column(db.Integer, db.ForeignKey('author.id'))
title = db.Column(db.String(80))
body = db.Column(db.Text)
image = db.Column(db.String(255))
slug = db.Column(db.String(256), unique=True)
publish_date = db.Column(db.DateTime)
live = db.Column(
db.Boolean) # to avoid deleting post. If false -> just hide it
category_id = db.Column(db.Integer, db.ForeignKey('category.id'))
category = db.relationship('Category',
backref=db.backref('posts', lazy='dynamic'))
@property
def imgsrc(self):
return uploaded_images.url(self.image)
def __init__(self,
blog,
author,
title,
body,
category,
image=None,
slug=None,
publish_date=None,
live=True):
self.blog_id = blog.id
self.author_id = author.id
self.title = title
self.body = body
self.category_id = category.id
self.image = image
self.slug = slug
if publish_date is None:
self.publish_date = datetime.utcnow()
else:
self.publish_date = publish_date
self.live = live
def __repr__(self):
return '<Post %r>' % self.title
class StuffType(db.Model):
__tablename__ = "stufftype"
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(255), unique=True)
category_list = db.relationship('Category',
secondary=categories_types,
backref=db.backref('type_list',
lazy='dynamic'))
def __repr__(self):
return self.name
@property
def admin_url(self):
return "%s/%s/%s" % (app.config['ADMIN_URL'], 'stufftype', self.id)
@property
def url(self):
return "%s/%s/" % ('stuff_type', self.name)
class Team(db.Model):
__tablename__ = 'teams'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(40), nullable=False)
abbreviation = db.Column(db.String(3))
primary_color = db.Column(db.String(30))
secondary_color = db.Column(db.String(30))
city = db.Column(db.String(30))
arena = db.Column(db.String(40))
division = db.Column(db.String(20))
conference = db.Column(db.String(20))
official_site = db.Column(db.String(50))
# self-reference for affiliated teams
team_id = db.Column(db.Integer, db.ForeignKey('teams.id'))
affiliates = db.relationship("Team", backref=db.backref('parent_team', remote_side=[id]))
league_id = db.Column(db.Integer, db.ForeignKey('leagues.id'))
league = db.relationship('League', back_populates='teams')
seasons = db.relationship('Season', secondary='team_stats')
players = db.relationship('PlayerStats', back_populates='team')
class User(db.Model):
id = db.Column(db.Integer, primary_key=True)
nickname = db.Column(db.String(64), index=True, unique=True)
email = db.Column(db.String(120), index=True, unique=True)
posts = db.relationship('Post', backref='author', lazy='dynamic')
about_me = db.Column(db.String(140))
last_seen = db.Column(db.DateTime)
followed = db.relationship('User',
secondary=followers,
primaryjoin=(followers.c.follower_id == id),
secondaryjoin=(followers.c.followed_id == id),
backref=db.backref('followers', lazy='dynamic'),
lazy='dynamic')
@staticmethod
def make_unique_nickname(nickname):
if User.query.filter_by(nickname=nickname).first() is None:
return nickname
version = 2
while True:
new_nickname = nickname + str(version)
if User.query.filter_by(nickname=new_nickname).first() is None:
break
version += 1
return new_nickname
@property
def is_authenticated(self):
return True
@property
def is_active(self):
return True
@property
def is_anonymous(self):
return False
def get_id(self):
try:
return unicode(self.id) # python 2
except NameError:
return str(self.id) # python 3
def avatar(self, size):
return 'http://www.gravatar.com/avatar/%s?d=mm&s=%d' % \
(md5(self.email.encode('utf-8')).hexdigest(), size)
def follow(self, user):
if not self.is_following(user):
self.followed.append(user)
return self
def unfollow(self, user):
if self.is_following(user):
self.followed.remove(user)
return self
def is_following(self, user):
return self.followed.filter(
followers.c.followed_id == user.id).count() > 0
def followed_posts(self):
return Post.query.join(
followers, (followers.c.followed_id == Post.user_id)).filter(
followers.c.follower_id == self.id).order_by(
Post.timestamp.desc())
def __repr__(self):
return '<User %r>' % (self.nickname)
