class Pin(TableTemplate, db.Model, CRUD):
query_class = PinQuery
id = db.Column(db.Integer, primary_key=True)
geo = db.Column(Geometry(geometry_type='POINT', srid=4326))
title = db.Column(db.String(50), nullable=False)
short_title = db.Column(db.String(20), nullable=False)
description = db.Column(db.String(256))
owner_id = db.Column(db.Integer, db.ForeignKey('user.id'))
pin_photo_id = db.Column(db.Integer, db.ForeignKey('file.id'), unique=True)
#Relationships
owner = db.relationship('User', backref=db.backref('pin'))
pin_photo = db.relationship('File')
#Seach Vector
search_vector = db.Column(
TSVectorType('title', 'description', 'short_title'))
@hybrid_property
def vote_score(self):
if (self.votes):
return sum((1 if vote.vote else -1) for vote in self.votes)
else:
return 0
def load_hybrid_properties(self):
self.vote_score
class User(UserMixin, db.Model):
""" Contains user information. """
__tablename__ = "user"
user_id = db.Column(db.Integer, autoincrement=True, primary_key=True)
username = db.Column(db.String(100), nullable=False)
first_name = db.Column(db.String(100), nullable=False)
last_name = db.Column(db.String(100), nullable=False)
email = db.Column(db.String, nullable=False)
confirmed = db.Column(db.Boolean, default=False)
location = db.Column(db.String(80), nullable=False)
member_since = db.Column(db.DateTime(), default=datetime.utcnow)
# avatar_hash = db.Column(db.String(32))
age = db.Column(db.Integer, nullable=True)
password = db.Column(db.String(128), nullable=False)
followed = db.relationship('Relations',
foreign_keys=[Relations.follower_id],
backref=db.backref('follower', lazy='joined'),
lazy='dynamic',
cascade='all, delete-orphan')
followers = db.relationship('Relations',
foreign_keys=[Relations.followed_id],
backref=db.backref('followed', lazy='joined'),
lazy='dynamic',
cascade='all, delete-orphan')
comments = db.relationship('Comment', backref='user', lazy='dynamic')
# Put name inside TSVectorType definition for it to be fulltext-indexed (searchable)
search_vector = db.Column(TSVectorType('first_name', 'last_name'))
def __repr__(self):
return "<User user_id={} email={}>".format(self.user_id, self.email)
class Restaurant(db.Model):
"""Restaurant on Breadcrumbs website."""
__tablename__ = "restaurants"
restaurant_id = db.Column(db.Integer, autoincrement=True, primary_key=True)
city_id = db.Column(db.Integer,
db.ForeignKey('cities.city_id'),
nullable=False)
name = db.Column(db.String(150), nullable=False)
address = db.Column(db.String(150), nullable=False)
phone = db.Column(db.String(20), nullable=True)
image_url = db.Column(db.String(200), nullable=True)
# Latitude and Longitude need to be Numeric, not Integer to have decimal places
latitude = db.Column(db.Numeric, nullable=False)
longitude = db.Column(db.Numeric, nullable=False)
# Put restaurant name and address inside definition of TSVectorType to be fulltext-indexed (searchable)
search_vector = db.Column(TSVectorType('name', 'address'))
city = db.relationship("City", backref=db.backref("restaurants"))
categories = db.relationship("Category",
secondary="restaurantcategories",
backref="restaurants")
users = db.relationship("User", secondary="visits", backref="restaurants")
def __repr__(self):
"""Provide helpful representation when printed."""
return "<Restaurant restaurant_id=%s name=%s>" % (self.restaurant_id,
self.name)
class Question(Post):
__tablename__ = 'questions'
title = Column(String, nullable=False)
answers = relationship('Answer', cascade='all, delete-orphan')
tags = relationship('Tag',
secondary=association_table,
backref='questions')
user_id = Column(Integer, ForeignKey('users.id'), nullable=False)
user = relationship('User', backref='questions')
# Search vector
search_vector = Column(TSVectorType('title', 'body'))
def to_dict(self):
my_dict = Post.to_dict(self)
my_dict.update({
'title': self.title,
'nb_answers': len(self.answers),
'tags': [tag.label for tag in self.tags],
'user': self.user.to_dict()
})
return my_dict
class Post(db.Model):
def __repr__(self):
return "<Post %r>" % self.title
query_class = PostQuery
id = db.Column(db.Integer, primary_key=True)
_title = db.Column('title', db.UnicodeText)
slug = db.Column(db.UnicodeText)
body = db.Column(db.UnicodeText)
timestamp = db.Column(db.DateTime)
user_id = db.Column(db.Integer, db.ForeignKey('user.id'))
is_published = db.Column(db.Boolean)
search_vector = db.Column(TSVectorType('title', 'body'))
@hybrid_property
def title(self):
return self._title
@title.setter
def title(self, title):
self._title = title
self.slug = re.sub('[^\w]+', '-', self.title.lower())
@hybrid_method
def summary(self, n_words):
# stripped = re.sub(r'[#>*-]', ' ', self.body)
# return ' '.join(stripped.split()[:n_words]) + '...'
stripped = self.body.split('.')
return '. '.join(stripped[:n_words]) + ' ...'
class ArxivModel(Base):
__tablename__ = 'arxiv'
id = Column(Integer, primary_key=True, autoincrement=True)
version = Column(Integer)
popularity = Column(Integer)
title = Column(Unicode(800, collation=''))
arxiv_url = Column(String(255), primary_key=True)
pdf_url = Column(String(255))
published_time = Column(DateTime())
authors = Column(Unicode(800, collation=''))
abstract = Column(Text(collation=''))
journal_link = Column(Text(collation=''), nullable=True)
tag = Column(String(255))
introduction = Column(Text(collation=''))
conclusion = Column(Text(collation=''))
analyzed = Column(Boolean, server_default='false', default=False)
# For full text search
search_vector = Column(
TSVectorType('title',
'abstract',
'authors',
weights={
'title': 'A',
'abstract': 'B',
'authors': 'C'
}))
def __repr__(self):
template = '<Arxiv(id="{0}", url="{1}")>'
return str_repr(template.format(self.id, self.arxiv_url))
class Page(db.Model):
query_class = PageQuery
__tablename__ = "pages"
id = db.Column(db.Integer, primary_key=True)
title = db.Column(db.String(500))
text = db.Column(db.UnicodeText())
html = db.Column(db.UnicodeText())
url = db.Column(db.String(500), unique=True, nullable=False)
search_vector = db.Column(TSVectorType('text'))
def __repr__(self):
"""
Return a string containing a printable
representation of a Page object.
":return: str"
"""
return 'Title: {}, url: {}'.format(unicode(self.title, "utf-8"),
unicode(self.url, "utf-8"))
@classmethod
def get_all_entries(cls):
"""
List all entries saved to database.
:return: Page object
"""
return Page.query.all()
class Location(db.Model):
query_class = LocationQuery
__tablename__ = 'locations'
id_num = db.Column(db.String(25), primary_key=True)
currencies = db.Column(db.Text)
latlng = db.Column(db.Text)
capital = db.Column(db.String(50))
population = db.Column(db.String(50))
topLevelDomain = db.Column(db.Text)
languages = db.Column(db.Text)
name = db.Column(db.String(50))
region = db.Column(db.String(25))
search_vector = db.Column(TSVectorType('name', 'region', 'capital'))
def to_json(self, list_view=False):
json_location = {
'id_num': self.id_num,
'currencies': self.currencies,
'latlng': self.latlng,
'capital': self.capital,
'population': self.population,
'topLevelDomain': self.topLevelDomain,
'languages': self.languages,
'name': self.name,
'region': self.region
}
return json_location
def __repr__(self):
return '<Location %s>' % self.id_num
class Article(db.Model):
query_class = ArticleQuery
__tablename__ = 'articles'
id_num = db.Column(db.String(25), primary_key=True)
title = db.Column(db.Text)
description = db.Column(db.Text)
pubDate = db.Column(db.String(25))
image_link = db.Column(db.Text)
category = db.Column(db.Text)
external_article_link = db.Column(db.Text)
external_source_link = db.Column(db.Text)
source_name = db.Column(db.Text)
region = db.Column(db.String(25))
search_vector = db.Column(TSVectorType('title', 'description'))
def to_json(self, list_view=False):
json_article = {
'id_num': self.id_num,
'title': self.title,
'description': self.description,
'pubDate': self.pubDate,
'image_link': self.image_link,
'category': self.category,
'external_article_link': self.external_article_link,
'external_source_link': self.external_source_link,
'source_name': self.source_name,
'region': self.region
}
return json_article
def __repr__(self):
return '<Article %s>' % self.id_num
class Charge(db.Model):
id = db.Column(db.Integer, primary_key=True)
date = db.Column(db.DateTime)
location = db.Column(db.String(MAX_STRING))
description = db.Column(db.Text)
classification = db.Column(db.String(MAX_STRING))
celebrity_id = db.Column(db.Integer, db.ForeignKey('celebrity.id'))
crime_id = db.Column(db.Integer, db.ForeignKey('crime.id'))
crime = db.relationship('Crime')
celebrity = db.relationship('Celebrity')
search_vector = db.Column(TSVectorType('description', 'classification'))
def __init__(self,
celebrity,
crime,
date=None,
location=None,
description=None,
classification=None):
self.celebrity = celebrity
self.crime = crime
self.date = date
self.location = location
self.celebrity = celebrity
self.crime = crime
self.description = description
self.classification = classification
def __repr__(self):
return '(Charge {num}: {celebrity}, {crime})'.format(
self.id, self.crime, self.celebrity)
class Celebrity(db.Model):
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(MAX_STRING))
description = db.Column(db.Text)
twitter_handle = db.Column(db.String(MAX_STRING))
birthday = db.Column(db.DateTime)
wiki_url = db.Column(db.String(MAX_STRING))
imdb_url = db.Column(db.String(MAX_STRING))
picture_url = db.Column(db.String(MAX_STRING))
aliases = db.relationship('CelebrityAlias')
crimes = db.relationship('Crime', secondary='charge')
charges = db.relationship('Charge')
search_vector = db.Column(TSVectorType('name', 'description', 'twitter_handle', 'wiki_url', 'imdb_url'))
def __init__(self,
name,
description=None,
twitter_handle=None,
birthday=None,
wiki_url=None,
imdb_url=None,
picture_url=None):
self.name = name
self.description = description
self.twitter_handle=twitter_handle
self.birthday = birthday
self.wiki_url = wiki_url
self.imdb_url = imdb_url
self.picture_url = picture_url
def __repr__(self):
return '(Celebrity {num}: {name})'.format(name=self.name, num=self.id)
class City(Base):
__tablename__ = 'city'
id = Column(Integer, primary_key=True)
name = Column(Unicode(255))
country = Column(String(255))
location = Column(Geometry(geometry_type='POINT', srid=4326)) # SRID=4326;POINT(0.00 0.00)
search_vector = Column(TSVectorType('name'))
class User(TableTemplate, db.Model, CRUD):
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(20), unique=True, nullable=False)
nickname = db.Column(db.String(20), unique=True)
password = db.Column(db.String(20), nullable=False)
email = db.Column(db.String(120), unique=True, nullable=False)
profile_photo_id = db.Column(db.Integer,
db.ForeignKey('file.id'),
unique=True)
#Seach Vector
search_vector = db.Column(TSVectorType('username', 'email', 'nickname'))
#Relationships
profile_photo = db.relationship('File')
def get_email(self):
return self.email
#Functions reserved for login manager
def is_active(self):
return self.is_active
def is_authenticated(self):
return True
def is_anonymous(self):
return False
def get_id(self):
return unicode(self.id)
class Pose(db.Model):
query_class = PoseQuery
__tablename__ = "poses"
pose_id = db.Column(db.Integer, primary_key=True, autoincrement=True)
name = db.Column(db.Unicode(100), nullable=False, unique=True) # required and unique, SEARCHABLE
sanskrit = db.Column(db.Unicode(100), nullable=True) # sanskrit name with accents (for displaying)
sanskrit_unaccented = db.Column(db.Unicode(100), nullable=True) # sanskrti name w/o accents, SEARCHABLE
description = db.Column(db.Unicode(2000)) # SEARCHABLE
difficulty = db.Column(db.String(20), nullable=False)
altnames = db.Column(db.Unicode(100), nullable=True) # SEARCHABLE
benefit = db.Column(db.String(1000), nullable=True)
img_url = db.Column(db.String(200), nullable=False)
is_leftright = db.Column(db.Boolean, nullable=True) # boolean to indicate whether a pose has left/right version
next_pose_str = db.Column(db.String(500), nullable=True) # next poses stored as a string for now
prev_pose_str = db.Column(db.String(500), nullable=True) # previous poses stored as a string for now
next_poses = db.Column(JSON, nullable=True) # next poses as a JSON {pose_id: weight, pose_id: weight, ....}
search_vector = db.Column(TSVectorType('name','sanskrit_unaccented','altnames','description',
catalog='pg_catalog.simple',
weights={'name': 'A', 'altnames': 'B', 'sanskrit_unaccented': 'C', 'description':'D'}))
pose_workout = db.relationship('PoseWorkout')
pose_categories = db.relationship('PoseCategory')
def getNextPose(self, next_poses=None):
"""
Returns a Pose object that would follow based on
choosing a pose from the original Pose object's next_poses attribute
OR it can take in a user specified next poses dictionary
next_poses must be a dictionary = {id: weight, id: weight ...}
e.g.
Usage: warrior2.getNextPose()
Output: <Pose name="Warrior I">
"""
if next_poses is None: # if no next poses are specified use the ones in the attribute for that pose
next_poses = self.next_poses
if next_poses: # if the next_poses exists for that pose (i.e. it's not an empty dictionary)
pose_ids = []
pose_weights = []
for pose_id, weight in next_poses.items(): # next_poses = {id: weight, id: weight ...}
pose_ids.append(int(pose_id))
pose_weights.append(weight)
else: # if no next poses exist then choose from some basic ones like Mountain, Down Dog
pose_ids =[64,130,32] # ids for Down Dog, Mountain, and Corpse
pose_weights = [2,2,1]
next_pose_id = random.choices(pose_ids, pose_weights)[0] # random.choices returns a list
return Pose.query.get(next_pose_id)
def __repr__(self):
"""Print out the Pose object nicely"""
return "<Pose pose_id={}, name={}>".format(self.pose_id, self.name)
class Group(db.Model):
query_class = GroupQuery
__tablename__ = 'groups'
id = db.Column(db.Integer,primary_key=True)
name = db.Column(db.String,unique=True,nullable=False)
members = db.relationship('User',secondary=members,backref=db.backref('group_users', lazy='dynamic'))
group_posts = db.relationship('Post',secondary=group_posts,backref=db.backref('group_posts', lazy='dynamic',order_by=Post.time_posted))
admins = db.relationship('User',secondary=admins,backref=db.backref('admin_users', lazy='dynamic'))
banned_members = db.relationship('User',secondary=banned_members,backref=db.backref('group_banned_users', lazy='dynamic'))
description = db.Column(db.String)
private = db.Column(db.Boolean)
search_vector = db.Column(TSVectorType('group_name', 'group_description'))
def __init__(self,name,description,admin,private):
self.name = name
self.description = description
self.admins.append(admin)
self.private = private
self.members.append(admin)
def __repr__(self):
return '<Group {0}>'.format(self.name)
def is_member(self,user):
if user in self.members:
return True
else:
return False
def is_admin(self,user):
if user in self.admins:
return True
else:
return False
def join(self,user):
self.members.append(user)
db.session.commit()
def leave(self,user):
user = User.query.get(user)
self.members.remove(user)
db.session.commit()
def make_admin(self,user):
self.admins.append(user)
db.session.commit()
def add_post(self,post):
self.group_posts.append(post)
db.session.commit()
def is_banned(self,user):
if user in self.banned_members:
return True
else:
return False
class User(TableBase):
# TODO: flesh this out and make it usable
__tablename__ = 'user'
id = Column(Integer, primary_key=True)
name = Column(String(length=256))
search_vector = Column(TSVectorType('name'))
applications = relationship('Application', back_populates='author')
class Company(db.Model):
"""
This model is used to represent Company entries in our database.
Attributes:
ID - ID of the company. This variable self-increments.
Name - The name of the company.
Num_developed - The number of games this company has developed.
Image_url - The company logo from the IGDB API.
Num_published - The number of games this company has published.
Avg_rating - The average rating of all the games this company is associated with.
Year_founded - The year this company was founded.
Games - The games associated with this company. This data is retrieved using
the association table.
"""
query_class = CompanyQuery
__tablename__ = 'companies'
company_id = db.Column(db.Integer, primary_key=True, autoincrement=False)
name = db.Column(db.String(50), unique=True)
num_developed = db.Column(db.Integer)
num_published = db.Column(db.Integer)
image_url = db.Column(db.String(255))
avg_rating = db.Column(db.Float)
year_founded = db.Column(db.Integer, db.ForeignKey('years.year_id'))
search_vector = db.Column(TSVectorType('name'))
associated_games = db.relationship(
"Game",
secondary=association_table_game_company,
backref=db.backref('companies'))
def __init__(self,
company_id,
name=None,
num_developed=0,
image_url="",
num_published=0,
avg_rating=0.0,
year_founded=None,
search_vector=None):
self.company_id = company_id
self.name = name
self.num_developed = num_developed
self.image_url = image_url
self.num_published = num_published
self.avg_rating = avg_rating
self.year_founded = year_founded
self.search_vector = search_vector
def __repr__(self):
return '<Company: %r>' % (self.name)
class TextItem(self.Base):
__tablename__ = 'textitem'
id = sa.Column(sa.Integer, primary_key=True, autoincrement=True)
name = sa.Column(sa.Unicode(255))
search_vector = sa.Column(TSVectorType('name', 'content'))
content = sa.Column(sa.UnicodeText)
class Agurate_Farmers_Farm(db.Model):
__tablename__ = 'agurate_farmers_farm'
id = db.Column(db.Integer, primary_key= True)
farmer_code = db.Column(db.String, db.ForeignKey('agurate_farmers.farmer_code'), nullable=False)
farm_code = db.Column(db.String, db.ForeignKey('agurate_farms.farm_code'), index=True, nullable=False)
created_at = db.Column(db.DateTime, server_default=db.func.current_timestamp())
updated_at = db.Column(db.DateTime,server_default=db.func.current_timestamp(), onupdate=db.func.current_timestamp())
document_token = db.Column(db.Text)
search_vector = db.Column(TSVectorType('document_token'))
class Application(TableBase):
# TODO: Currently ignoring but should maybe handle:
# capabilities, changelog, compatibility, images, links?,
# screenshots, companion apps
__tablename__ = 'application'
id = Column(Integer, primary_key=True)
guid = Column(GUID)
author_id = Column(Integer, ForeignKey('user.id'), nullable=False)
title = Column(String(length=256))
description = Column(String)
hearts = Column(Integer, default=0)
source = Column(String(length=256))
create_ts = Column(ArrowType, default=arrow.utcnow)
publish_ts = Column(ArrowType, default=arrow.utcnow)
search_vector = Column(TSVectorType('title', 'description'))
author = relationship('User', back_populates='applications')
collections = relationship('Collection',
secondary=ApplicationCollection,
back_populates='applications')
files = relationship('File', back_populates='application')
@validates('title', 'source')
def validate_code(self, key, value):
max_len = getattr(self.__class__, key).prop.columns[0].type.length
if value and len(value) > max_len:
return value[:max_len]
return value
def to_json(self):
return {
'id': self.id,
'title': self.title,
'description': self.description,
# TODO: flesh these out
'hearts': self.hearts,
'companions': {
'android': None,
'ios': None
},
'list_image': {
'80x80': '',
'144x144': ''
},
'screenshot_hardware': 'basalt',
'screenshot_images': [{
'0x0': ''
}],
'icon_image': {
'28x28': '',
'48x48': ''
},
'capabilities': []
}
class Review(Base):
__tablename__ = 'review'
id = Column(Integer, primary_key=True)
product_id = Column(String, ForeignKey('product.id'))
voter_helpful = Column(Integer)
voter_total = Column(Integer)
text = Column(Text)
summary = Column(String)
rating = Column(Float)
date_posted = Column(DateTime)
search_vector = Column(TSVectorType('text', 'summary'))
class Agurate_Seedling_Price(db.Model):
__tablename__ = 'agurate_seedling_price'
id = db.Column(db.Integer, primary_key=True)
farmer_code = db.Column(db.String(100), nullable=False)
crop_variety_code = db.Column(db.String(100), db.ForeignKey('agurate_crop_varieties.crop_variety_code'), nullable=False)
price = db.Column(db.Numeric, nullable=False)
created_at = db.Column(db.DateTime, server_default=db.func.current_timestamp())
updated_at = db.Column(db.DateTime, server_default=db.func.current_timestamp(), onupdate=db.func.current_timestamp())
document_token = db.Column(db.Text)
search_vector = db.Column(TSVectorType('document_token'))
class Company(db.Model):
query_class = CompanyQuery
__tablename__ = 'companies'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(255))
image = db.Column(db.String(255))
city = db.Column(db.String(255))
country = db.Column(db.String(255))
deck = db.Column(db.Text)
date_founded = db.Column(db.DateTime)
people = db.relationship('Person',
secondary=company_person,
backref='companies')
developed_games = db.relationship('Game',
secondary=developer_game,
backref='developers')
published_games = db.relationship('Game',
secondary=publisher_game,
backref='publishers')
search_vector = db.Column(TSVectorType('name'))
def to_json(self, list_view=False):
json_company = {
'id': self.id,
'name': self.name,
'deck': self.deck,
'image': self.image,
'city': self.city,
'country': self.country,
'date_founded': self.date_founded
}
if list_view:
dev_games = []
for game in self.developed_games:
details = {'id': game.id, 'name': game.name}
dev_games.append(details)
pub_games = []
for game in self.published_games:
details = {'id': game.id, 'name': game.name}
pub_games.append(details)
people = []
people_cache = [] # removes duplicates
for person in self.people:
if person.id not in people_cache:
details = {'id': person.id, 'name': person.name}
people.append(details)
people_cache.append(person.id)
json_company['developed_games'] = dev_games
json_company['published_games'] = pub_games
json_company['people'] = people
return json_company
def __repr__(self):
return '<Company %s>' % self.name
class Tag(Base):
__tablename__ = 'tags'
label = Column(String(25), primary_key=True, nullable=False)
# Search vector
search_vector = Column(TSVectorType('label'))
def to_dict(self):
return {'label': self.label}
class Agurate_Farmer_Log(db.Model):
__tablename__= 'agurate_farmer_logs'
id= db.Column(db.Integer, primary_key=True)
farmer= db.Column(db.String(100), nullable=False)
type = db.Column(db.String(50), nullable=False)
note = db.Column(db.Text)
status = db.Column(db.String(100), nullable=False)
employee = db.Column(db.String(100), nullable=False)
created_at = db.Column(db.DateTime, server_default=db.func.current_timestamp())
updated_at = db.Column(db.DateTime,server_default=db.func.current_timestamp(), onupdate=db.func.current_timestamp())
document_token = db.Column(db.Text)
search_vector = db.Column(TSVectorType('document_token'))
class Character(db.Model, Base):
"""
DC characters with attributes title, hero/villain alias, an image,
their alignment, and other information
"""
__tablename__ = 'characters'
query_class = CharacterQuery
title = db.Column(db.String(50), primary_key=True)
image = db.Column(db.String(250))
universes = db.Column(ARRAY(db.String(100)))
gender = db.Column(db.String(50))
aliases = db.Column(ARRAY(db.String(100)))
creators = db.Column(ARRAY(db.String(100)))
identity = db.Column(db.String(50))
real_name = db.Column(db.String(50))
debut = db.Column(db.String(50))
affiliation = db.Column(ARRAY(db.String(100)))
alignment = db.Column(db.String(50))
category = db.Column(db.String(50))
search_vector = db.Column(
TSVectorType('title', 'image', 'universes', 'gender', 'aliases',
'creators', 'identity', 'real_name', 'debut',
'affiliation', 'alignment', 'category'))
def __init__(self,
title="",
alias=[],
image="",
alignment="",
creators=[],
identity="",
real_name="",
universe=[],
status="",
gender="",
debut="",
aliases=[],
affiliation=[]):
"""
Initialize the character
"""
self.title = title
self.aliases = aliases
self.image = image
self.alignment = alignment
self.creators = creators
self.identity = identity
self.real_name = real_name
self.universes = universe
self.gender = gender
self.debut = debut
self.affiliation = affiliation
class City(Base):
__tablename__ = "cities"
city_id = DColumn(Integer, primary_key=True)
name = DColumn(String)
population = DColumn(Integer)
city_picture_link = DColumn(String)
state = DColumn(String, ForeignKey("regions.state"))
artists = relationship('Artist',
secondary=cities_artists,
back_populates='cities')
search_vector = Column(TSVectorType('name', 'state'))
class Agurate_Farm_Property(db.Model):
__tablename__ = 'agurate_farms_properties'
id = db.Column(db.Integer, primary_key=True)
farm_code = db.Column(db.String(256), db.ForeignKey('agurate_farms.farm_code'), nullable=False)
property_code= db.Column(db.String(100), nullable=False, index=True)
property_value = db.Column(db.String, nullable=False)
group = db.Column(db.String)
created_at = db.Column(db.DateTime, server_default=db.func.current_timestamp())
updated_at = db.Column(db.DateTime,server_default=db.func.current_timestamp(), onupdate=db.func.current_timestamp())
document_token = db.Column(db.Text)
search_vector = db.Column(TSVectorType('document_token'))
def __repr__(self):
return '' %self.farm_code % self.property_code
class Agurate_Crop_Variety_Property(db.Model):
__tablename__ = 'agurate_crop_variety_properties'
id = db.Column(db.Integer, primary_key=True)
crop_variety_code = db.Column(db.String(256), db.ForeignKey('agurate_crop_varieties.crop_variety_code'),nullable=False)
entity = db.Column(db.String(256), nullable=False)
attribute = db.Column(db.String(100))
value = db.Column(db.String(100))
note = db.Column(db.Text)
created_at = db.Column(db.DateTime, server_default=db.func.current_timestamp())
updated_at = db.Column(db.DateTime,server_default=db.func.current_timestamp(), onupdate=db.func.current_timestamp())
document_token = db.Column(db.Text)
search_vector = db.Column(TSVectorType('document_token'))
class Restaurant(db.Model):
query_class = RestaurantQuery
__tablename__ = "restaurants"
try:
if int(os.environ['TESTING']) == 1:
id = db.Column(db.Integer, primary_key=True)
except KeyError:
id = db.Column(UUIDType(binary=False), primary_key=True)
name = db.Column(db.String, nullable=False)
date = db.Column(db.Date, nullable=False)
category = db.Column(db.String, nullable=True)
images = db.Column(db.PickleType, nullable=True)
dishes = db.relationship('Dish',
cascade="all, delete, delete-orphan",
backref='restaurant')
tags = db.Column(db.String, nullable=True)
editors = db.relationship('User',
backref='restaurant',
secondary=restaurants_users)
locations = db.relationship('Location', backref='restaurant')
last_edited = db.Column(db.Integer, nullable=False)
try:
if int(os.environ['TESTING']) == 1:
last_editor = db.Column(db.Integer)
except KeyError:
last_editor = db.Column(UUIDType)
search_vector = db.Column(TSVectorType('name',
'category',
'tags',
weights={'name': 'A',
'category': 'C',
'tags': 'B'}))
def __init__(self, name, category, tags, user_id):
if app.config['TESTING'] != True:
self.id = uuid.uuid4()
self.name = name
self.date = datetime.utcnow()
self.category = category
self.images = []
self.tags = tags
if user_id is None:
self.editors = []
else:
self.editors.append(User.query.get(user_id))
self.last_edited = int(time())
def __repr__(self):
return '<Restaurant {}>'.format(self.id)
