class Cart(db.Model):
id = db.Column(db.Integer, primary_key=True)
consumer_id = db.Column(db.Integer)
items = db.Column(MutableDict.as_mutable(JSON),
server_default='{}',
nullable=False,
default={})
def __init__(self, consumer_id):
self.consumer_id = consumer_id
def set_item_quantity(self, product_id, quantity):
self.items[product_id] = int(quantity)
def increase_item_quantity(self, product_id, inc):
if product_id in self.items.keys():
self.items[product_id] += int(inc)
else:
self.set_item_quantity(product_id, inc)
def decrease_item_quantity(self, product_id, dec):
if product_id in self.items.keys():
sub = self.items[product_id] - int(dec)
if sub <= 0:
self.items[product_id] = 0
else:
self.items[product_id] = sub
def remove_item(self, product_id):
self.items.pop(product_id, None)
def clear_cart(self):
self.items.clear()
class Consumer(User):
__mapper_args__ = {'polymorphic_identity': 'consumer'}
last_name = db.Column(db.String(128))
patronymic = db.Column(db.String(128))
first_name = db.Column(db.String(128))
def __init__(self,
email,
password,
first_name,
last_name,
phone_number,
address,
patronymic=''):
super().__init__(email, password, 'consumer', phone_number, address)
self.first_name = get_string_or_default(first_name)
self.last_name = get_string_or_default(last_name)
self.patronymic = get_string_or_default(patronymic)
def get_orders(self):
return Order.query.filter_by(consumer_id=self.id).all()
def get_full_name(self):
return "{first_name} {patronymic} {last_name}".format(
first_name=self.first_name,
patronymic=self.patronymic,
last_name=self.last_name).strip()
class Advert(db.Model):
advert_id = db.Column(db.Integer, primary_key=True)
title = db.Column(db.String(50), index=True)
href = db.Column(db.String(255), nullable=True, unique=True)
description = db.Column(db.String(255))
'''
mark = db.Column(db.String(100))
model = db.Column(db.String(100))
country = db.Column(db.String(100))
material = db.Column(db.String(100))
temple_length = db.Column(db.Integer)
lens_width = db.Column(db.Integer)
bridge = db.Column(db.Integer)
purchase_price = db.Column(db.Integer)
sale_price = db.Column(db.Integer)
status = db.Column(db.String(100))
#price = Column(Integer)
#category_id = Column(Integer, ForeignKey('categories.id'))
#user_id = Column(Integer, ForeignKey('users.user_id'))
'''
def __repr__(self):
return "\nAdvert(advert_id='{self.advert_id}',\n" \
"\t\t title='{self.title}')\n"\
"\t\t href='{self.href}')\n"\
"\t\t href='{self.mark}')\n"\
"\t\t href='{self.model}')\n"\
"\t\t href='{self.country}')\n"\
"\t\t href='{self.material}')\n"\
"\t\t href='{self.temple_length}')\n"\
"\t\t href='{self.lens_width}')\n"\
"\t\t href='{self.bridge}')\n"\
"\t\t href='{self.purchase_price}')\n"\
"\t\t href='{self.sale_price}')\n"\
"\t\t href='{self.status}')\n".format(self=self)
class Location(db.Model):
postal_code = db.Column(db.Integer, primary_key=True)
city = db.Column(db.String(30), nullable=False)
state = db.Column(db.String(30), nullable=False)
posts = db.relationship('Post', backref='location', lazy=True)
users = db.relationship('User', backref='location', lazy=True)
def __repr__(self):
return f"Location('{self.postal_code},{self.city},{self.state}')"
class Category(db.Model):
__tablename__ = 'categories'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(50), unique=True)
items = db.relationship('Item', backref='category')
def __repr__(self):
return "\nCategory(name='{self.name}',\n" \
"\t\t href='{self.href}')".format(self=self)
class Tag(db.Model):
__tablename__ = "tags"
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(50), unique=True)
def __init__(self, name):
self.name = name
@property
def serialize(self):
return {'id': self.id, 'name': self.name}
class Comment(db.Model):
id = db.Column(db.Integer, primary_key=True)
date_posted = db.Column(db.DateTime,
nullable=False,
default=datetime.utcnow)
content = db.Column(db.Text, nullable=False)
user_id = db.Column(db.Integer, db.ForeignKey('user.id'), nullable=False)
post_id = db.Column(db.Integer, db.ForeignKey('post.id'), nullable=False)
def __repr__(self):
return f"Post('{self.content}', '{self.date_posted}')"
class UserSession(Base):
__tablename__ = 'user_session'
id = db.Column(db.String(constants.CONST_STR_64),
primary_key=True,
unique=True,
nullable=False,
index=True)
username = db.Column(db.String(constants.CONST_STR_64),
nullable=False,
index=True)
secret_key = db.Column(db.String(constants.CONST_STR_64),
nullable=False,
index=True)
class Category(db.Model):
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.Text, nullable=False)
description = db.Column(db.Text, nullable=False)
posts = db.relationship("Post",
secondary=cat_association_table,
back_populates="category")
def __str__(self):
return str(self.name) + ' - ' + str(self.description)
def __repr__(self):
return f"Category('{self.name},{self.description}')"
class Category(db.Model):
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(128), unique=True)
slug = db.Column(db.String(128), unique=True)
parent_id = db.Column(db.Integer)
def __init__(self, name, slug=None, parent_id=0):
self.name = name
self.slug = slug
self.parent_id = parent_id
def get_products(self):
return Product.query.filter_by(category_id=self.id).all()
def get_subcategories(self):
return Category.query.filter_by(parent_id=self.id).all()
class Base(db.Model):
__abstract__ = True
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
date_created = db.Column(db.DateTime, default=datetime.utcnow)
date_modified = db.Column(db.DateTime,
default=datetime.utcnow,
onupdate=datetime.utcnow)
modified_by = db.Column(db.String(constants.CONST_STR_128))
created_by = db.Column(db.String(constants.CONST_STR_128))
def save(self):
db.session.add(self)
db.session.commit()
def delete(self):
db.session.delete(self)
db.session.commit()
class Item(db.Model):
__tablename__ = "items"
id = db.Column(db.Integer, primary_key=True)
user_id = db.Column(db.String(100))
item_name = db.Column(db.String(200))
item_description = db.Column(db.String(2000))
image_url = db.Column(db.String)
price = db.Column(db.Float)
date_listed = db.Column(db.DateTime)
date_sold = db.Column(db.DateTime)
status = db.Column(db.String(20))
# Reference to the tags table
tags = db.relationship('Tag',
secondary=item_tags,
backref=db.backref('items', lazy='dynamic'))
def __init__(self, user_id, item_name, item_description, item_url, price,
date_listed, date_sold, status):
self.user_id = user_id
self.item_name = item_name
self.item_description = item_description
self.image_url = item_url
self.price = price
self.date_listed = date_listed
self.date_sold = date_sold
self.status = status
def __repr__(self):
return '<Item %r>' % self.item_name
@property
def serialize(self):
""" Used for JSONify and render templates """
tag_output = []
for tag in self.tags:
tag_output.append(tag.serialize)
return {
'id': self.id,
'user_id': self.user_id,
'item_name': self.item_name,
'item_description': self.item_description,
'item_url': self.image_url,
'price': self.price,
'tags': tag_output,
'date_listed': str(self.date_listed),
'date_sold': str(self.date_sold),
'status': self.status
}
class Merchant(Base):
# __tablename__ will shown as real table-name on DBMS, not a table's column.
__tablename__ = 'merchant'
# column name will assigned as unique and non-nullable.
name = db.Column(db.String(constants.CONST_STR_128),
unique=True,
nullable=False)
# Owner of Merchant, must be a valid/registered User.
# Notes it's a Foreign Key to non-primary key, using column 'user.username' as a FK, not using
# 'user.id' as user's original PK
username = db.Column(db.String,
db.ForeignKey('user.username'),
nullable=True)
description = db.Column(db.String(constants.CONST_STR_128),
unique=False,
nullable=False)
city = db.Column(db.String(constants.CONST_STR_128),
unique=False,
nullable=False)
class User(SetPhotoUrlMixin, UserMixin, db.Model):
__tablename__ = 'user'
__mapper_args = {'polymorphic_on': 'discriminator'}
id = db.Column(db.Integer, primary_key=True)
email = db.Column(db.String(128), unique=True)
email_auth_status = db.Column(db.Boolean)
password_hash = db.Column(db.String(1024))
phone_number = db.Column(db.String(16))
address = db.Column(db.String(128))
photo_url = db.Column(db.String(256))
entity = db.Column(db.String(16))
def __init__(self,
email,
password,
entity,
phone_number='',
address='',
photo_url='static/img/userpic.svg'):
self.email = email
self.email_auth_status = False
self.phone_number = get_string_or_default(phone_number)
self.password_hash = generate_password_hash(password)
self.address = get_string_or_default(address)
self.entity = entity
self.photo_url = photo_url
def set_password(self, password):
self.password_hash = generate_password_hash(password)
def change_password(self, old_password, new_password):
if check_password_hash(self.password_hash, old_password):
self.password_hash = generate_password_hash(new_password)
return True
else:
return False
def check_password(self, password):
return check_password_hash(self.password_hash, password)
def verify_email(self):
self.email_auth_status = True
def set_address(self, address):
self.address = address
def set_phone(self, phone_number):
self.phone_number = phone_number
class User(db.Model):
__tablename__ = "users"
id = db.Column(db.Integer, primary_key=True)
user_id = db.Column(db.String(100), unique=True)
rating_value = db.Column(db.Integer)
num_ratings = db.Column(db.Integer)
def __init__(self, user_id, rating_value, num_ratings):
self.user_id = user_id
self.rating_value = rating_value
self.num_ratings = num_ratings
def __repr__(self):
return '<User %r>' % self.user_id
@property
def serialize(self):
""" Used for JSONify and render templates """
return {
'id': self.id,
'user_id': self.user_id,
'rating_value': self.rating_value,
'num_ratings': self.num_ratings
}
class Item(db.Model):
__tablename__ = 'items'
id = db.Column(db.Integer, primary_key=True)
item_id = db.Column(db.Integer, nullable=False, unique=True)
title = db.Column(db.String(50), index=True)
image_href = db.Column(db.String(255), nullable=False, unique=True)
description = db.Column(db.String(255), nullable=True)
price = db.Column(db.Integer, nullable=True)
category_id = db.Column(db.Integer, db.ForeignKey('categories.id'))
def __repr__(self):
return "\nItem(item_id='{self.item_id}',\n" \
"\t\t title='{self.title}')\n"\
"\t\t image_href='{self.image_href}')\n" \
"\t\t price='{self.price}')\n" \
"\t\t description='{self.description}')".format(self=self)
class User(db.Model, UserMixin):
user_id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(50), unique=True)
phone = db.Column(db.String(50), nullable=True)
created_on = db.Column(db.DateTime, nullable=True)
login = db.Column(db.String(100), unique=True)
email = db.Column(db.String(100), unique=True)
password = db.Column(db.String(255))
def get_id(self):
return self.user_id
def __repr__(self):
return "\nUsers(user_id='{self.user_id}',\n" \
"\t\t name='{self.name}')\n"\
"\t\t phone='{self.phone}')\n".format(self=self)
class User(db.Model, UserMixin):
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(20), unique=True, nullable=False)
email = db.Column(db.String(120), unique=True, nullable=False)
image_file = db.Column(db.String(20),
nullable=False,
default='default.jpg')
password = db.Column(db.String(60), nullable=False)
posts = db.relationship('Post', backref='author', lazy=True)
comments = db.relationship('Comment', backref='comment_author', lazy=True)
location_id = db.Column(db.Integer,
db.ForeignKey('location.postal_code'),
nullable=True)
phone = db.Column(db.String(13), nullable=True)
role_id = db.Column(db.Integer,
db.ForeignKey('role.id'),
nullable=False,
default=2)
following = db.relationship(
'User',
lambda: user_following,
primaryjoin=lambda: User.id == user_following.c.user_id,
secondaryjoin=lambda: User.id == user_following.c.following_id,
backref='followers')
def get_reset_token(self, expires_sec=1800):
s = Serializer(app.config['SECRET_KEY'], expires_sec)
return s.dumps({'user_id': self.id}).decode('utf-8')
@staticmethod
def verify_reset_token(token):
s = Serializer(app.config['SECRET_KEY'])
try:
user_id = s.loads(token)['user_id']
except:
return None
return User.query.get(user_id)
def __repr__(self):
return f"User('{self.username}', '{self.email}', '{self.image_file}')"
class Comment(db.Model):
id = db.Column(db.Integer, primary_key=True)
product_id = db.Column(db.Integer)
consumer_id = db.Column(db.Integer)
rating = db.Column(db.Integer)
consumer_name = db.Column(db.String(128))
timestamp = db.Column(db.DateTime, default=datetime.utcnow)
body = db.Column(db.String(512))
def __init__(self,
product_id,
consumer_id,
body,
rating,
consumer_name='Покупатель'):
self.product_id = product_id
self.consumer_id = consumer_id
self.body = body
self.rating = rating
self.consumer_name = consumer_name
class Producer(RatedMixin, User):
__mapper_args__ = {'polymorphic_identity': 'producer'}
name = db.Column(db.String(128), unique=True)
person_to_contact = db.Column(db.String(128))
description = db.Column(db.String(256))
rating = db.Column(db.Float, default=0)
votes = db.Column(db.Integer, default=0)
trello_token = db.Column(db.String(256), nullable=True)
trello_board_id = db.Column(db.String(256), nullable=True)
categories = db.relationship("Category",
secondary=producer_category_association_table,
lazy='subquery',
backref=db.backref('producers', lazy=True))
def __init__(self,
password,
email,
name,
phone_number,
address,
person_to_contact,
description='',
photo_url='static/img/standard-profile.jpg'):
super().__init__(email, password, 'producer', phone_number, address)
self.name = name
self.person_to_contact = person_to_contact
self.description = get_string_or_default(description)
self.photo_url = photo_url
def get_products(self):
return Product.query.filter_by(producer_id=self.id).all()
def get_orders(self):
return Product.query.filter_by(producer_id=self.id).all()
def set_description(self, description):
self.description = description
def link_trello_account(self, token, board_id):
self.trello_token = token
self.trello_board_id = board_id
class Post(db.Model):
id = db.Column(db.Integer, primary_key=True)
title = db.Column(db.String(100), nullable=False)
date_posted = db.Column(db.DateTime,
nullable=False,
default=datetime.utcnow)
content = db.Column(db.Text, nullable=False)
user_id = db.Column(db.Integer, db.ForeignKey('user.id'), nullable=False)
location_id = db.Column(db.Integer,
db.ForeignKey('location.postal_code'),
nullable=False)
comments = db.relationship('Comment', backref='post', lazy=True)
category = db.relationship("Category",
secondary=cat_association_table,
back_populates="posts")
def __repr__(self):
return f"Post('{self.title}', '{self.date_posted}')"
class User(Base):
__tablename__ = 'user'
id = db.Column(db.Integer, primary_key=True)
# column username will assigned as unique and non-nullable.
# index=True means this is an Indexable column with the predefined index to access it.
username = db.Column(db.String(constants.CONST_STR_64),
unique=True,
nullable=False,
index=True)
password = db.Column(db.String(constants.CONST_STR_128),
unique=False,
nullable=False)
fullname = db.Column(db.String(constants.CONST_STR_128),
unique=False,
nullable=True)
phone = db.Column(db.String(constants.CONST_STR_16),
unique=True,
nullable=False)
email = db.Column(db.String(constants.CONST_STR_16),
unique=True,
nullable=True)
class Product(SetPhotoUrlMixin, RatedMixin, db.Model):
query_class = ProductQuery
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(128))
description = db.Column(db.String(256))
photo_url = db.Column(db.String(256))
price = db.Column(MONEY)
quantity = db.Column(db.Integer)
times_ordered = db.Column(db.Integer)
producer_id = db.Column(db.Integer)
category_id = db.Column(db.Integer)
measurement_unit = db.Column(db.String(16))
weight = db.Column(db.Float)
rating = db.Column(db.Float, default=0)
votes = db.Column(db.Integer, default=0)
subscribers = db.relationship("Consumer",
secondary=subscribe_consumer_product,
backref=db.backref('subscribe', lazy=True))
search_vector = db.Column(
TSVectorType('name',
'description',
weights={
'name': 'A',
'description': 'B'
},
regconfig='pg_catalog.russian'))
def __init__(self,
price,
name,
quantity,
producer_id,
category_id,
measurement_unit,
weight=None,
description='',
photo_url='static/img/standard.png'):
self.price = float(price)
self.name = name
self.quantity = quantity
self.producer_id = producer_id
self.category_id = category_id
self.measurement_unit = measurement_unit
self.times_ordered = 0
self.weight = weight
self.description = get_string_or_default(description)
self.photo_url = photo_url
def set_description(self, description):
self.description = description
def get_producer(self):
return Producer.query.filter_by(id=self.producer_id).all()
def get_category(self):
return Category.query.filter_by(id=self.category_id).all()
from marketplace import db
# Association table for associating items with tags and vice-versa
item_tags = db.Table('item_tags',
db.Column('tag_id', db.Integer, db.ForeignKey('tags.id')),
db.Column('item_id', db.Integer, db.ForeignKey('items.id'))
)
from marketplace.models.user import User
from marketplace.models.tag import Tag # Must come before Item, because Item refers to Tag for the relationship
from marketplace.models.item import Item
class Transaction(Base):
__tablename__ = 'order'
invoice_no = db.Column(db.String(constants.CONST_STR_128),
unique=True,
nullable=False)
date = db.Column(db.DateTime, default=datetime.utcnow)
class Product(Base):
__tablename__ = 'product'
name = db.Column(db.String(constants.CONST_STR_128),
unique=False,
nullable=False)
price = db.Column(db.Integer, db.ForeignKey('user.id'), nullable=True)
class Order(db.Model):
id = db.Column(db.Integer, primary_key=True)
total_cost = db.Column(MONEY)
order_items_json = db.Column(db.JSON)
status = db.Column(db.String(128))
delivery_method = db.Column(db.String(128))
delivery_address = db.Column(db.String(128))
order_timestamp = db.Column(db.DateTime, default=datetime.utcnow)
shipping_timestamp = db.Column(db.DateTime)
consumer_phone = db.Column(db.String(128))
consumer_email = db.Column(db.String(128))
consumer_id = db.Column(db.Integer)
producer_id = db.Column(db.Integer)
first_name = db.Column(db.String(128))
last_name = db.Column(db.String(128))
reviewed = db.Column(db.Boolean, default=False)
unread_consumer_messages = db.Column(db.Integer, default=0)
unread_producer_messages = db.Column(db.Integer, default=0)
def __init__(self,
total_cost,
order_items_json,
delivery_method,
delivery_address,
consumer_phone,
consumer_email,
consumer_id,
producer_id,
status='Не обработан',
first_name='',
last_name=''):
self.total_cost = int(total_cost)
self.order_items_json = order_items_json
self.status = status
self.delivery_method = delivery_method
self.delivery_address = delivery_address
self.consumer_id = consumer_id
self.producer_id = producer_id
self.consumer_phone = consumer_phone
self.consumer_email = consumer_email
self.first_name = first_name
self.last_name = last_name
def get_consumer(self):
return Consumer.query.filter_by(id=self.consumer_id).first()
def get_producer(self):
return Producer.query.filter_by(id=self.producer_id).first()
def change_status(self, status):
if status == 'shipped':
self.shipping_timestamp = datetime.utcnow
self.status = status
class Role(db.Model):
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.Text, nullable=False)
description = db.Column(db.Text, nullable=False)
users = db.relationship('User', backref='role', lazy=True)
if len(user_id) < 6:
user = User.query.get(int(user_id))
else:
user = m_db.users.find_one({'_id': user_id})
if user:
user = UserDict(user)
user['is_authenticated'] = True
else:
user = {'is_authenticated': False}
user = UserDict(user)
return user
cat_association_table = db.Table(
'cat_association', db.Model.metadata,
db.Column('post_id', db.Integer, db.ForeignKey('post.id')),
db.Column('category_id', db.Integer, db.ForeignKey('category.id')))
user_following = db.Table(
'user_following', db.Model.metadata,
db.Column('user_id',
db.Integer,
db.ForeignKey("user.id"),
primary_key=True),
db.Column('following_id',
db.Integer,
db.ForeignKey("user.id"),
primary_key=True))
class User(db.Model, UserMixin):
from marketplace import db, login
except:
from content.data_app import db, login
from werkzeug.security import generate_password_hash, check_password_hash
from datetime import datetime
from sqlalchemy.dialects.postgresql import MONEY
from flask_login import UserMixin
from sqlalchemy_searchable import SearchQueryMixin, make_searchable
from sqlalchemy_utils.types.ts_vector import TSVectorType
make_searchable(db.metadata)
producer_category_association_table = db.Table(
'producers_categories',
db.Column('producer_id',
db.Integer,
db.ForeignKey('user.id'),
primary_key=True),
db.Column('category_id',
db.Integer,
db.ForeignKey('category.id'),
primary_key=True))
subscribe_consumer_product = db.Table(
'subscribe_consumer_product',
db.Column('product_id',
db.Integer,
db.ForeignKey('product.id'),
primary_key=True),
db.Column('consumer_id',
db.Integer,
db.ForeignKey('user.id'),
