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')