class Base(db.Model):
__abstract__ = True
id = db.Column(db.Integer, primary_key=True)
date_created = db.Column(db.DateTime, default=datetime.now)
date_updated = db.Column(db.DateTime, onupdate=datetime.now)
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 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 Category(db.Model):
"""
Category model to store different categories
"""
__tablename__ = "category"
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(100), unique=True, nullable=False)
items = db.relationship('Item', backref="category", uselist=True)
class Categories(db.Model):
"""
Registered categories information is stored in db
"""
__tablename__ = 'categories'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(40), index=True)
items = db.relationship('Items', backref="category", uselist=True)
class User(db.Model, UserMixin):
"""
User model to store app users
"""
__tablename__ = 'users'
id = db.Column(db.Integer, primary_key=True)
email = db.Column(db.String(200), unique=True, nullable=False)
name = db.Column(db.String(100))
token = db.Column(db.Text)
items = db.relationship('Item', backref="user", uselist=True)
class User(db.Model):
"""User class represents a Catalog App user.
Attributes:
id: An integer of user's id.
name: A string of user's name.
email: A string of user's email address.
picture: A string of URI to user's picture.
catagory_items: A one-to-many relationship between User and
CatagoryItems; contains a list of catagory_items created by user.
"""
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(1000), nullable=False)
email = db.Column(db.String(1000), nullable=False, unique=True)
picture = db.Column(db.String(1000))
catagory_items = db.relationship('CatagoryItem',
backref='user',
lazy='dynamic')
def __init__(self, name, email, picture=None):
"""Initialize User.
Args:
name: user's name.
email: user's email address.
picture: URI to user's picture.
"""
self.name = name
self.email = email
self.picture = picture
def __repr__(self):
"""Represents User.
Returns:
A string that respresents the User object.
"""
return '<User {0}>'.format(self.email)
@property
def serialize(self):
"""Serialize User object into a dictionary.
Makes it easier to convert User class into json or xml form.
Returns:
A dictionary that holds key/value pairs that represent the User
class.
"""
return {
'id': self.id,
'name': self.name,
'address': self.email,
'picture': self.picture
}
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 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 User(db.Model, UserMixin):
"""
Registered user information is stored in db
"""
__tablename__ = 'user'
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(50), index=True)
picture = db.Column(db.String)
email = db.Column(db.String)
token = db.column(db.text)
items = db.relationship('Items', backref="user", uselist=True)
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 User(UserMixin, db.Model):
"""
Registered user information is stored in db
"""
id = db.Column(db.Integer, primary_key=True)
email = db.Column(db.String(256), unique=True, nullable=False)
name = db.Column(db.String(256))
avatar = db.Column(db.String(256))
categories = db.relationship("Category", back_populates="user")
items = db.relationship("Item", back_populates="user")
def __repr__(self):
return "{}:{}".format(self.id, self.name)
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 Catagory(db.Model):
"""Catagory class represents a Catalog App catagory.
Attributes:
id: An integer of catagory's id.
name: A string of catgory's name.
catagory_items: A one-to-many relationship between a Catagory and
CatagoryItem; contains a list of items grouped by the catagory.
"""
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(1000))
catagory_items = db.relationship('CatagoryItem',
backref='catagory',
lazy='dynamic',
cascade='delete, delete-orphan')
def __init__(self, name):
"""Initialize Catagory.
Args:
name: catagory's name.
"""
self.name = name
def __repr__(self):
"""Represents Catagory.
Returns:
A string that respresents the Catagory object.
"""
return '<Catagory {0}>'.format(self.name)
@property
def serialize(self):
"""Serialize Catagory object into a dictionary.
Makes it easier to convert Catagory class into json or xml form.
Returns:
A dictionary that holds key/value pairs that represent the Catagory
class.
"""
return {
'id': self.id,
'name': self.name,
'items': [ci.serialize for ci in self.catagory_items]
}
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 User(Base):
__tablename__ = 'users'
google_uid = db.Column(db.String, index=True)
name = db.Column(db.String, nullable=False)
email = db.Column(db.String, index=True, unique=True, nullable=False)
photo = db.Column(db.String)
def __init__(self, name, email, photo=None, google_uid=None):
self.name = name
self.email = email
self.photo = photo
self.google_uid = google_uid
def __repr__(self):
return '<User(email={})>'.format(self.email)
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 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 User(db.Model, UserMixin):
__tablename__ = 'user'
name = db.Column(db.String(80), nullable=False)
id = db.Column(db.Integer, primary_key=True)
email = db.Column(db.String(80), nullable=False)
picture = db.Column(db.String(500))
items = db.relationship('Item')
@property
def serialize(self):
# Serializable format
return {
'name': self.name,
'id': self.id,
'email': self.email,
'picture': self.picture
}
class Category(db.Model):
""""Category model class.
This class represents one category. Each category has a name,
a description and one image. All fields are required.
"""
__tablename__ = 'category'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(20), nullable=False)
description = db.Column(db.String(500), nullable=False)
def __init__(self, name, description):
self.name = name
self.description = description
def to_dict(self):
"""Converts recipe to dictionary."""
return dict(
id=self.id,
name=self.name,
description=self.description,
image=urljoin(request.url_root, self.image_src),
recipes=[recipe.to_dict() for recipe in self.recipes]
)
@cached_property
def count(self):
return self.recipes.count()
@property
def slug(self):
return slugify(self.name)
@property
def image_src(self):
return '/%s/categories/%s.png?%s' % (
URL_UPLOAD_FOLDER, self.id, int(time.time())
)
def __repr__(self):
return '<Category %r>' % (self.name)
class Category(Base):
__tablename__ = 'categories'
name = db.Column(db.String, nullable=False)
slug = db.Column(db.String, index=True, unique=True, nullable=False)
def __init__(self, name):
self.name = name.strip().title()
self.slug = Slug(self.name.lower())
def __repr__(self):
return '<Category(name={})>'.format(self.name)
@property
def serialize(self):
return dict(id=self.id,
title=self.name,
items=[i.serialize for i in self.items])
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 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 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 User(db.Model):
__tablename__ = 'user'
id = db.Column(db.Integer, primary_key=True)
email = db.Column(db.String, nullable=False, index=True, unique=True)
username = db.Column(db.String, nullable=True)
password = db.Column(db.String(64), nullable=False)
registered_on = db.Column(db.DateTime, nullable=False)
admin = db.Column(db.Boolean, nullable=False, default=False)
categories = db.relationship("Category", lazy=True, back_populates='user')
def __init__(self, email, password, admin, username=""):
self.email = email
self.password = bcrypt.generate_password_hash(password).decode('utf-8')
self.registered_on = datetime.datetime.now()
self.admin = admin
self.username = username
def is_authenticated(self):
return True
def is_active(self):
return True
def is_anonymous(self):
return False
def get_id(self):
return self.id
def __repr__(self):
return '<email {}'.format(self.email)
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 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 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 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 User(db.Model):
"""
Model:User
"""
__tablename__ = 'ctlg_user'
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(120), nullable=False)
email = db.Column(db.String(120), unique=True)
gplus_id = db.Column(db.String(40), unique=True)
created = db.Column(db.DateTime, default=datetime.utcnow)
modified = db.Column(db.DateTime, default=datetime.utcnow)
categories = db.relationship('Category',
backref='ctlg_user',
lazy='dynamic')
items = db.relationship('Item', backref='ctlg_user', lazy='dynamic')
