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 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): __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 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 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')
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 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): __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): """ 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 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 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): """ 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 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(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 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 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 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 oAuth(OAuthConsumerMixin, db.Model): user_id = db.Column(db.Integer, db.ForeignKey("user.id")) user = db.relationship(User)