class ItemPhoto(Base):
__tablename__ = 'item_photos'
filename = db.Column(db.String, nullable=False)
filepath = db.Column(db.String, nullable=False)
url = db.Column(db.String, nullable=False)
item_id = db.Column(db.Integer, db.ForeignKey('items.id'))
item = db.relationship('Item',
backref=db.backref('photos',
cascade='all, delete-orphan',
lazy='dynamic'))
creator_id = db.Column(db.Integer, db.ForeignKey('users.id'))
creator = db.relationship('User',
backref=db.backref('item_photos',
cascade='all, delete-orphan',
lazy='dynamic'))
def __init__(self, filename, filepath, url, item_id, creator_id):
self.filename = filename
self.filepath = filepath
self.url = url
self.item_id = item_id
self.creator_id = creator_id
def __repr__(self):
return '<ItemPhoto(filename={})>'.format(self.filename)
@property
def serialize(self):
return dict(id=self.id,
filename=self.filename,
url=self.url,
itemID=self.item_id,
createdDate=self.date_created)
class Item(db.Model):
"""
Model:Item
"""
__tablename__ = 'ctlg_item'
id = db.Column(db.Integer, primary_key=True)
title = db.Column(db.String(100), nullable=False)
description = db.Column(db.Text, nullable=False)
created = db.Column(db.DateTime, default=datetime.utcnow)
modified = db.Column(db.DateTime, default=datetime.utcnow)
category_id = db.Column(db.Integer,
db.ForeignKey('ctlg_category.id'),
nullable=False)
user_id = db.Column(db.Integer,
db.ForeignKey('ctlg_user.id'),
nullable=False)
@property
def serialize(self):
return {
'id': self.id,
'title': self.title,
'description': self.description,
'category_id': self.category_id
}
class Item(db.Model):
"""
Registered Item information is stored in db
"""
id = db.Column(db.Integer, primary_key=True)
created_date = db.Column(db.DateTime, default=datetime.datetime.utcnow)
category_id = db.Column(db.Integer, db.ForeignKey(
'category.id'), nullable=False)
user_id = db.Column(db.Integer, db.ForeignKey('user.id'), nullable=False)
name = db.Column(db.String(20), nullable=False)
description = db.Column(db.Text, nullable=False)
category = db.relationship(
"Category", back_populates="items")
user = db.relationship("User", back_populates="items")
__table_args__ = (db.UniqueConstraint(
'category_id', 'name', name='_category_name_uc'),
)
@property
def serialize(self):
return {
'id': self.id,
'catergory_id': self.category_id,
'created_date': self.created_date,
'name': self.name,
'description': self.description
}
def __repr__(self):
return "{}:{}:{}".format(self.id, self.category_id, self.name)
class Item(db.Model):
__tablename__ = 'item'
id = db.Column(db.Integer, primary_key=True, unique=True)
name = db.Column(db.String(50), nullable=False)
picture = db.Column(db.String, nullable=True)
description = db.Column(db.String)
category_id = db.Column(db.Integer,
db.ForeignKey('category.id'),
nullable=False)
category_name = db.Column(db.String)
user_id = db.Column(db.Integer, db.ForeignKey('user.id'), nullable=False)
category = db.relationship("Category",
foreign_keys=[category_id],
back_populates="items",
cascade="all, delete")
db.relationship("User")
@property
def serialize_item(self):
return {
'id': self.id,
'name': self.name,
'picture': self.picture,
'user_id': self.user_id,
'description': self.description,
'category_id': self.category_id,
'category_name': self.category_name,
}
class CatalogsItem(db.Model):
name = db.Column(db.String(80), nullable=False)
id = db.Column(db.Integer, primary_key=True)
description = db.Column(db.String(250))
price = db.Column(db.String(8))
catalogs_id = db.Column(db.Integer, db.ForeignKey("catalog.id"))
user_id = db.Column(db.Integer, db.ForeignKey("user.id"))
catalogs = db.relationship(Catalog, backref="catalogsItem")
user = db.relationship("User")
class Items(db.Model):
"""
Registered items information is stored in db
"""
__tablename__ = 'items'
name = db.Column(db.String(80), nullable=False)
id = db.Column(db.Integer, primary_key=True)
description = db.Column(db.String(250))
categories_id = db.Column(
db.Integer, db.ForeignKey('categories.id', ondelete='CASCADE'))
user_id = db.Column(db.Integer, db.ForeignKey('user.id'))
class Item(db.Model):
"""
Item model stores individual items and links them
to category and user
"""
__tablename__ = "item"
id = db.Column(db.Integer, primary_key=True)
title = db.Column(db.String(100), unique=True, nullable=False)
description = db.Column(db.Text)
created_at = db.Column(db.DateTime, nullable=True, default=datetime.now())
category_id = db.Column(db.Integer, db.ForeignKey(
'category.id', ondelete='CASCADE'))
user_id = db.Column(db.Integer, db.ForeignKey('users.id'))
class OAuth(OAuthConsumerMixin, db.Model):
"""
Registered OAuthConsumerMixin information is stored in db
"""
provider_user_id = db.Column(db.String(256), unique=True)
user_id = db.Column(db.Integer, db.ForeignKey(User.id))
user = db.relationship(User)
class Item(db.Model):
id = db.Column(db.Integer, primary_key=True)
title = db.Column(db.String(80))
admin = db.Column(db.Integer, db.ForeignKey('author.id'))
def __init__(self, title, admin):
self.title = title
self.admin = admin
def __repr__(self):
return '<Blog %r>' % self.name
class Item(db.Model):
__tablename__ = 'item'
name = db.Column(db.String(80), nullable=False)
id = db.Column(db.Integer, primary_key=True)
description = db.Column(db.String(500))
category_id = db.Column(db.Integer, db.ForeignKey('category.id'))
category = db.relationship('Category')
# add the relationship with the User class
user = relationship('User')
# Authorization: add a user_id field to map an item to a user
user_id = db.Column(db.Integer, db.ForeignKey('user.id'))
@property
def serialize(self):
# Returns object data in JSON
return {
'name': self.name,
'description': self.description,
'id': self.id
}
class Category(db.Model):
"""
Model:Category
"""
__tablename__ = 'ctlg_category'
id = db.Column(db.Integer, primary_key=True)
title = db.Column(db.String(100), nullable=False)
created = db.Column(db.DateTime, default=datetime.utcnow)
modified = db.Column(db.DateTime, default=datetime.utcnow)
user_id = db.Column(db.Integer,
db.ForeignKey('ctlg_user.id'),
nullable=False)
items = db.relationship('Item', backref='ctlg_category', lazy='dynamic')
class Item(Base):
__tablename__ = 'items'
name = db.Column(db.String, nullable=False)
slug = db.Column(db.String, index=True, unique=True, nullable=False)
description = db.Column(db.Text)
category_id = db.Column(db.Integer, db.ForeignKey('categories.id'))
category = db.relationship('Category',
backref=db.backref('items',
cascade='all, delete-orphan',
lazy='dynamic'))
creator_id = db.Column(db.Integer, db.ForeignKey('users.id'))
creator = db.relationship('User',
backref=db.backref('items',
cascade='all, delete-orphan',
lazy='dynamic'))
def __init__(self, name, category_id, creator_id, description=None):
self.name = name.strip().title()
self.slug = Slug(self.name.lower())
self.category_id = category_id
self.creator_id = creator_id
self.description = description
def __repr__(self):
return '<Item(name={})>'.format(self.name)
@property
def serialize(self):
return dict(id=self.id,
title=self.name,
description=self.description,
categoryID=self.category_id,
createdDate=self.date_created,
updatedDate=self.date_updated,
photos=[p.serialize for p in self.photos])
class Category(db.Model):
__tablename__ = 'category'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(50), nullable=False)
user_id = db.Column(db.Integer, db.ForeignKey('user.id'), nullable=False)
user = db.relationship("User",
back_populates='categories',
cascade="save-update")
items = db.relationship('Item',
back_populates='category',
cascade="all, delete")
@property
def serialize_category(self):
return {'id': self.id, 'name': self.name, 'user_id': self.user_id}
class Category(db.Model):
__tablename__ = 'category'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(250), nullable=False)
# add the relationship with the User class
user = db.relationship('User')
# Authorization: add a user_id field to map an item to a user
user_id = db.Column(db.Integer, db.ForeignKey('user.id'))
@property
def serialize(self):
# Returns object data in JSON
return {
'id': self.id,
'name': self.name,
}
class RecipeImage(db.Model):
""""Recipe images model class.
This class create the 'recipe_image' table. Each row will have an id,
a recipe_id, a filename and a hidden column.
All fields are required.
A many to one relationship is established between this table and
Recipe table.
"""
__tablename__ = 'recipe_image'
id = db.Column(db.Integer, primary_key=True)
recipe_id = db.Column(db.Integer, db.ForeignKey('recipe.id'))
filename = db.Column(db.String(250), nullable=False)
hidden = db.Column(db.Boolean, nullable=False)
recipe = db.relationship('Recipe',
backref=db.backref(
'images',
cascade='delete, delete-orphan',
lazy='dynamic'))
def __init__(self, recipe, filename, hidden=False):
self.recipe = recipe
self.filename = filename
self.hidden = hidden
def to_dict(self):
return dict(src=urljoin(request.url_root, self.src))
@property
def src(self):
return '/%s/recipes/%s' % (URL_UPLOAD_FOLDER, self.filename)
@staticmethod
def cb_delete_filename(mapper, connection, target):
delete_recipe_image(target.filename)
def __repr__(self):
return '<Image %r %r>' % (self.id, self.recipe_id)
class Category(db.Model):
"""
Registered Category information is stored in db
"""
id = db.Column(db.Integer, primary_key=True)
user_id = db.Column(db.Integer, db.ForeignKey('user.id'), nullable=False)
name = db.Column(db.String(20), nullable=False)
items = db.relationship(
"Item", back_populates="category", cascade="all, delete-orphan")
user = db.relationship("User", back_populates="categories")
__table_args__ = (db.UniqueConstraint(
'user_id', 'name', name='_user_name_uc'),
)
@property
def serialize(self):
return {
'id': self.id,
'name': self.name,
}
def __repr__(self):
return "{}:{}".format(self.id, self.name)
class Catalog(db.Model):
cname = db.Column(db.String(250), nullable=False)
id = db.Column(db.Integer, primary_key=True)
user = db.relationship(User)
user_id = db.Column(db.Integer, db.ForeignKey("user.id"))
class Recipe(db.Model):
"""Recipe model class.
This class represents one recipe. Each recipe has an user id, category id,
title, description, ingredients,
preparation time, cook time, servings and a publish date.
All fields are required.
Two many to one relations are established between Recipe and Category
and between Recipe and User tables.
"""
__tablename__ = 'recipe'
id = db.Column(db.Integer, primary_key=True)
user_id = db.Column(db.Integer, db.ForeignKey('user.id'))
category_id = db.Column(db.Integer, db.ForeignKey('category.id'))
title = db.Column(db.String(200), nullable=False)
description = db.Column(db.String(500), nullable=False)
ingredients = db.Column(db.String(), nullable=False)
directions = db.Column(db.String(), nullable=False)
prep_time = db.Column(db.Integer, nullable=False)
cook_time = db.Column(db.Integer, nullable=False)
servings = db.Column(db.Integer, nullable=False)
pub_date = db.Column(db.DateTime)
user = db.relationship('User',
backref=db.backref('recipes',
cascade='delete, delete-orphan',
lazy='dynamic'))
category = db.relationship('Category',
backref=db.backref(
'recipes',
cascade='delete, delete-orphan',
lazy='dynamic'))
def __init__(self,
user,
category,
title,
description,
ingredients,
directions,
prep_time,
cook_time,
servings,
pub_date=None):
self.user = user
self.category = category
self.title = title
self.description = description
self.ingredients = ingredients
self.directions = directions
self.prep_time = prep_time
self.cook_time = cook_time
self.servings = servings
if pub_date is None:
pub_date = datetime.utcnow()
self.pub_date = pub_date
def to_dict(self):
"""Converts recipe to dictionary."""
return dict(id=self.id,
category=dict(id=self.category_id,
name=self.category.name),
title=self.title,
ingredients=self.ingredients,
directions=self.directions,
prep_time=self.prep_time,
cook_time=self.cook_time,
servings=self.servings,
images=[image.to_dict() for image in self.images])
@property
def formated_prep_time(self):
return formated_time(self.prep_time)
@property
def formated_cook_time(self):
return formated_time(self.cook_time)
@property
def url(self):
return url_for('recipes.show', id=self.id)
@property
def slug(self):
return slugify(self.title)
@property
def image_src(self):
"""Returns main recipe image."""
if self.images.count() > 0 and self.images[0].filename:
return '/%s/recipes/%s' % (URL_UPLOAD_FOLDER,
self.images[0].filename)
return '/static/images/no-image.png'
def __repr__(self):
return '<Recipe %r>' % (self.title)
class CatagoryItem(db.Model):
"""CatagoryItem class represents a Catalog App item.
Attributes:
id: An integer of item's id.
name: A string of item's name.
author: A string of item's author (for books).
description: A string of item's description.
picture: A string of URI to item's picture.
user_id: An integer of the user's id who created the item.
catagory_id: An integer of the catagory that item belongs to.
"""
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(1000), nullable=False)
author = db.Column(db.String(1000), nullable=False)
description = db.Column(db.Text)
picture = db.Column(db.String(1000))
user_id = db.Column(db.Integer, db.ForeignKey('user.id'))
catagory_id = db.Column(db.Integer,
db.ForeignKey('catagory.id'),
nullable=False)
def __init__(self,
name,
author,
catagory_id,
description=None,
picture=None,
user_id=None):
"""Initialize CatagoryItem.
Args:
name: name of item.
author: author--for books--of item.
description: description of item.
picture: URI to picture of item.
catagory_id: id of the catagory that the item belongs in.
user_id: id of the user that created the item.
"""
self.name = name
self.author = author
self.description = description
self.picture = picture
self.catagory_id = catagory_id
self.user_id = user_id
def __repr__(self):
"""Represents CatagoryItem.
Returns:
A string that respresents the CatagoryItem object.
"""
return '<CatagoryItem {0}>'.format(self.name)
@property
def serialize(self):
"""Serialize CatagoryItem object into a dictionary.
Makes it easier to convert CatagoryItem class into json or xml form.
Returns:
A dictionary that holds key/value pairs that represent the
CatagoryItem class.
"""
return {
'id': self.id,
'name': self.name,
'author': self.author,
'description': self.description,
'picture': self.picture
}
class oAuth(OAuthConsumerMixin, db.Model):
user_id = db.Column(db.Integer, db.ForeignKey("user.id"))
user = db.relationship(User)
