class CompanyModel(db.Model):
__tablename__ = "companies"
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
supplier_id = db.Column(db.Integer, db.ForeignKey("suppliers.id"), nullable=False)
company_name = db.Column(db.String(128), nullable=False)
company_address = db.relationship(
"AddressModel", backref="company", uselist=False, cascade="all",
)
address_id = db.Column(
db.Integer, db.ForeignKey("addresses.id"), unique=True, nullable=False
)
company_type = db.Column(
db.Enum(CompanyType), default=CompanyType.other, nullable=False
)
def __init__(
self, supplier_id, company_name, address_id, company_type=CompanyType.other
):
self.supplier_id = supplier_id
self.company_name = (company_name,)
self.company_type = company_type
self.address_id = address_id
def json(self):
return {
"id": self.id,
"supplier_id": self.supplier_id,
"company_name": self.company_name,
"company_type": self.company_type.name,
"address_id": self.address_id,
}
class User(db.Model, UserMixin):
__tablename__ = 'users'
id = db.Column(db.Integer, primary_key=True)
first_name = db.Column(db.String(80), unique=False, nullable=False)
second_name = db.Column(db.String(80), unique=False, nullable=False)
email = db.Column(db.String(100), nullable=False, unique=True)
password = db.Column(db.String(100), nullable=False)
group = db.Column(db.String(5), unique=False, nullable=True)
role = db.Column(db.Enum(UserRoleEnum),
default=UserRoleEnum.student,
nullable=False)
created_on = db.Column(db.DateTime(), default=datetime.utcnow)
updated_on = db.Column(db.DateTime(),
default=datetime.utcnow,
onupdate=datetime.utcnow)
def is_admin(self):
return self.role == User.ROLES['admin']
def allowed(self, access_level):
return self.role >= access_level
def set_password(self, password):
self.password = generate_password_hash(password)
def check_password(self, password):
return check_password_hash(self.password, password)
def __repr__(self):
return f"{self.first_name} {self.second_name}"
class StoreModel(db.Model):
__tablename__ = "stores"
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
retailer_id = db.Column(db.Integer, db.ForeignKey("retailers.id"), nullable=False)
store_name = db.Column(db.String(128), nullable=False)
store_address = db.relationship(
"AddressModel", backref="store", uselist=False, cascade="all",
)
address_id = db.Column(
db.Integer, db.ForeignKey("addresses.id"), unique=True, nullable=False
)
store_type = db.Column(db.Enum(StoreType), default=StoreType.other, nullable=False)
def __init__(self, retailer_id, store_name, address_id, store_type=StoreType.other):
self.retailer_id = retailer_id
self.store_name = (store_name,)
self.store_type = store_type
self.address_id = address_id
def json(self):
return {
"id": self.id,
"retailer_id": self.retailer_id,
"store_name": self.store_name,
"store_type": self.store_type.name,
"address_id": self.address_id,
}
class Vehicle(db.Model):
"""This class is the database model for a vehicle"""
__tablename__ = 'vehicles'
id = db.Column(db.Integer, primary_key=True, nullable=False, unique=True)
number = db.Column(db.Integer, nullable=False)
description = db.Column(db.Text(), nullable=True)
name = db.Column(db.String(128), nullable=True)
type = db.Column(db.Enum(VehicleType),
nullable=False,
default=VehicleType.BUS)
created_by = db.Column(db.Integer, nullable=False)
def __init__(self, id: int, number: int, description: str,
vehicle_type: VehicleType or int, user_id: id, name: str):
if type(vehicle_type) is int:
vehicle_type = VehicleType(vehicle_type)
self.id = id
self.number = number
self.description = description
self.type = vehicle_type
self.created_by = user_id
self.name = name
def serialize(self):
return {
'id': int(self.id),
'number': int(self.number),
'description': str(self.description),
'type': str(self.type),
'created_by': int(self.created_by),
'name': str(self.name)
}
class Stop(db.Model):
"""This class is the database model for a stop"""
__tablename__ = 'stops'
id = db.Column(db.Integer, nullable=False, primary_key=True, autoincrement=True, unique=True)
region = db.Column(db.Enum(Region), nullable=False)
name = db.Column(db.String(128), nullable=False)
stop_number = db.Column(db.Integer, nullable=False)
village = db.Column(db.String(128), nullable=True)
def __init__(self, region: Region or int, name: str, stop_number: int, village: str) -> None:
if type(region) == int:
region = Region(region)
self.region = region
self.name = name
self.stop_number = stop_number
self.village = village
def serialize(self):
return {
'id': int(self.id),
'region': str(self.region),
'name': str(self.name),
'stop_number': int(self.stop_number),
'village': str(self.village)
}
def to_sa_enum(py_enum):
"""Convert Python enumeration into SQLAlchemy enumeration."""
return db.Enum(
py_enum,
name=to_snake_case(py_enum.__name__),
values_callable=lambda x: [e.value for e in x],
)
class Round(db.Model):
id = db.Column(db.Integer, primary_key=True)
game_id = db.Column(db.Integer, db.ForeignKey('game.id'))
game = db.relationship('Game',
foreign_keys=[game_id],
back_populates="rounds")
round_type = db.Column(db.Enum(RoundType))
start_time = db.Column(db.DateTime)
end_time = db.Column(db.DateTime)
votes = db.relationship('Vote', back_populates="round")
def __repr__(self):
return '<Round {game_id}>'.format(game_id=str(self.game_id))
class User(db.Model):
__tablename__ = "user"
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(80), unique=True, nullable=False)
alive = db.Column(db.Boolean, default=True)
type_player = db.Column(db.Enum(UserType), default=UserType.villager)
game_id = db.Column(db.Integer, db.ForeignKey('game.id'))
game = db.relationship('Game',
foreign_keys=[game_id],
back_populates="players")
def __repr__(self):
return '<User {name}>'.format(name=self.username)
def number_of_votes(self, round_id):
return Vote.query.filter_by(player_to_id=self.id,
round_id=round_id).count()
class Order(db.Model):
__tablename__ = "orders"
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
status = db.Column(db.Enum(OrderStatus),
nullable=False,
default=OrderStatus.PENDING)
total = db.Column(db.Float, nullable=False)
created = db.Column(db.DateTime, server_default=db.func.now())
updated = db.Column(db.DateTime,
server_default=db.func.now(),
server_onupdate=db.func.now())
items = db.relationship('OrderItem', backref='order', lazy=True)
delivery_address_id = db.Column(db.Integer,
db.ForeignKey('delivery_addresses.id'),
nullable=False)
delivery_address = db.relationship('DeliveryAddress')
user_id = db.Column(db.Integer, db.ForeignKey('users._id'), nullable=True)
def __init__(self, delivery_address: DeliveryAddress, user_id: int = None):
self.user_id = user_id
self.delivery_address_id = delivery_address.id
class Items(db.Model):
__tablename__ = "items"
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
user_id = db.Column(db.Integer, db.ForeignKey('users.id'), unique=True)
name = db.Column(db.String(32), nullable=False)
category = db.Column(db.String(32),
db.Enum('Lost', 'Found'),
nullable=True)
location = db.Column(db.String(64), nullable=True)
description = db.Column(db.String(128), nullable=False)
create_date = db.Column(db.DateTime, nullable=False)
modified_date = db.Column(db.DateTime, nullable=False)
item_pic = db.Column(db.String(255), nullable=False)
# Class constructor
def __init__(self, name, category, location, description, item_pic):
self.name = name
self.category = category
self.location = location
self.description = description
self.create_date = datetime.datetime.utcnow()
self.modified_date = datetime.datetime.utcnow()
self.item_pic = item_pic
# Returning class attribute in a json format
def item_to_json(self):
return {
'id': self.id,
'name': self.name,
'category': self.category,
'location': self.location,
'description': self.description,
'create_data': self.create_date,
'modified_data': self.modified_date,
'item_pic': self.item_pic
}
class UserModel(db.Model):
__tablename__ = "users"
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
username = db.Column(db.String(128), unique=True, nullable=False)
email = db.Column(db.String(128), unique=True, nullable=False)
password = db.Column(db.String(128), nullable=False)
created_date = db.Column(db.DateTime, default=func.now(), nullable=False)
admin = db.Column(db.Boolean, default=False, nullable=False)
user_type = db.Column(db.Enum(UserType),
default=UserType.retail,
nullable=False)
retailer = db.relationship(
"RetailerModel",
backref="user",
uselist=False,
cascade="all, delete-orphan",
)
supplier = db.relationship(
"SupplierModel",
backref="user",
uselist=False,
cascade="all, delete-orphan",
)
confirmation = db.relationship(
"ConfirmationModel",
backref="user",
lazy="dynamic",
cascade="all, delete-orphan",
)
def __init__(
self,
username,
email,
password,
admin=False,
user_type=UserType.retail,
):
self.username = username
self.email = email
self.password = bcrypt.generate_password_hash(
password, current_app.config.get("BCRYPT_LOG_ROUNDS")).decode()
self.user_type = user_type
self.admin = admin
@classmethod
def encode_token(cls, user_id, token_type):
if token_type == "access":
seconds = current_app.config.get("ACCESS_TOKEN_EXPIRATION")
else:
seconds = current_app.config.get("REFRESH_TOKEN_EXPIRATION")
payload = {
"exp":
datetime.datetime.utcnow() + datetime.timedelta(seconds=seconds),
"iat": datetime.datetime.utcnow(),
"sub": user_id,
}
return jwt.encode(payload,
current_app.config.get("SECRET_KEY"),
algorithm="HS256")
@classmethod
def decode_token(cls, token):
"""Decodes auth token given"""
try:
payload = jwt.decode(token,
current_app.config.get("SECRET_KEY"),
algorithm="HS256")
return payload["sub"]
except jwt.ExpiredSignatureError:
return "Signature expired. Please log in again."
except jwt.InvalidTokenError:
return "Invalid token. Please log in again."
def save_to_db(self) -> None:
db.session.add(self)
db.session.commit()
def delete_from_db(self) -> None:
db.session.delete(self)
db.session.commit()
@classmethod
def find_by_id(cls, _id: int) -> "UserModel":
return cls.query.get(_id)
@classmethod
def find_by_email(cls, email: str) -> "UserModel":
return cls.query.filter_by(email=email).first()
@property
def most_recent_confirmation(self) -> "ConfirmationModel":
return self.confirmation.order_by(db.desc(
ConfirmationModel.expire_at)).first()
def send_confirmation_mail(self):
subject = "Registration Confirmation"
link = (f"{request.url_root[:-1]}"
f"/auth/confirmation/{self.most_recent_confirmation.id}")
text = f"Please click the link to confirm your registration: {link}"
html = (f"<html>Please click the link to confirm your registration:"
f"<a href={link}>link</a></html>")
# response = Mailgun.send_email([self.email], subject, text, html)
send_async_mail_task.delay(email=self.email,
subject=subject,
text=text,
html=html)
def json(self):
return {
"id": self.id,
"username": self.username,
"email": self.email,
"admin": self.admin,
"user_type": self.user_type.name,
"confirmed": self.most_recent_confirmation.confirmed,
}
class Genre(db.Model):
__tablename__ = "Genre"
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.Enum(*genres_list, name="genres"), nullable=False, unique=True)
class User(BaseModel, db.Model):
"""用户"""
__tablename__ = "info_user"
id = db.Column(db.Integer, primary_key=True) # 用户编号
nick_name = db.Column(db.String(32), unique=True, nullable=False) # 用户昵称
password_hash = db.Column(db.String(128), nullable=False) # 加密的密码
mobile = db.Column(db.String(11), unique=True, nullable=False) # 手机号
avatar_url = db.Column(db.String(256)) # 用户头像路径
last_login = db.Column(db.DateTime, default=datetime.now) # 最后一次登录时间
is_admin = db.Column(db.Boolean, default=False)
signature = db.Column(db.String(512)) # 用户签名
gender = db.Column( # 订单的状态
db.Enum(
"MAN", # 男
"WOMAN" # 女
),
default="MAN")
# 当前用户收藏的所有新闻
collection_news = db.relationship("News",
secondary=tb_user_collection,
lazy="dynamic") # 用户收藏的新闻
# 用户所有的粉丝，添加了反向引用followed，代表用户都关注了哪些人
followers = db.relationship(
'User',
secondary=tb_user_follows,
primaryjoin=id == tb_user_follows.c.followed_id,
secondaryjoin=id == tb_user_follows.c.follower_id,
backref=db.backref('followed', lazy='dynamic'),
lazy='dynamic')
# 当前用户所发布的新闻
news_list = db.relationship('News', backref='user', lazy='dynamic')
@property
def password(self):
raise AttributeError("当前属性不可读")
@password.setter
def password(self, value):
self.password_hash = generate_password_hash(value)
def check_passowrd(self, password):
return check_password_hash(self.password_hash, password)
def to_dict(self):
resp_dict = {
"id":
self.id,
"nick_name":
self.nick_name,
"avatar_url":
constants.QINIU_DOMIN_PREFIX +
self.avatar_url if self.avatar_url else "",
"mobile":
self.mobile,
"gender":
self.gender if self.gender else "MAN",
"signature":
self.signature if self.signature else "",
"followers_count":
self.followers.count(),
"news_count":
self.news_list.count()
}
return resp_dict
def to_admin_dict(self):
resp_dict = {
"id": self.id,
"nick_name": self.nick_name,
"mobile": self.mobile,
"register": self.create_time.strftime("%Y-%m-%d %H:%M:%S"),
"last_login": self.last_login.strftime("%Y-%m-%d %H:%M:%S"),
}
return resp_dict
class User(db.Model):
__tablename__ = "users"
_id = db.Column(db.Integer, primary_key=True, autoincrement=True)
_email = db.Column(db.String(64), nullable=False, unique=True)
_password = db.Column(db.String(255), nullable=False)
_active = db.Column(db.Boolean, nullable=False, default=False)
_role = db.Column(db.Enum(UserRole),
nullable=False,
default=UserRole.CUSTOMER)
_first_name = db.Column(db.String(64))
_last_name = db.Column(db.String(64))
_phone = db.Column(db.String(13))
_street = db.Column(db.String(64))
_zip_code = db.Column(db.String(5))
_city = db.Column(db.String(64))
_country = db.Column(db.Enum(Country))
_date_of_birth = db.Column(db.Date())
ratings = db.relationship('ProductRating', backref='user')
orders = db.relationship('Order', backref='user', lazy=True)
def __init__(self,
email,
password,
first_name=None,
last_name=None,
phone=None,
street=None,
zip_code=None,
city=None,
country=None,
date_of_birth=None):
self._set_email(email)
self._set_password(password)
self.active = False
self.role = UserRole.CUSTOMER
self.first_name = first_name
self.last_name = last_name
self.phone = phone
self.street = street
self.zip_code = zip_code
self.city = city
self.country = country
self.date_of_birth = date_of_birth
def _set_email(self, value):
if not isinstance(value, str):
raise TypeError('Email must be string.')
# http://emailregex.com/
m = re.match(r'(^[a-zA-Z0-9_.+-]+@[a-zA-Z0-9-]+\.[a-zA-Z0-9-.]+$)',
value)
if m is None:
raise ValueError('Invalid email format.')
self._email = value
def _set_password(self, value):
if not isinstance(value, str):
raise TypeError('Password must be string.')
m = re.match(r'^[a-zA-Z]\w{3,14}$', value)
if m is None:
raise ValueError(
'Password must have between 4 and 15 chars, '
'it must start with letter '
'and can only be used letters, numbers and underscore.')
self._password = bcrypt.generate_password_hash(
value, current_app.config.get('BCRYPT_LOG_ROUNDS')).decode()
@property
def id(self):
return self._id
@property
def email(self):
return self._email
@property
def password(self):
return self._password
@property
def active(self):
return self._active
@active.setter
def active(self, value):
if not isinstance(value, bool):
raise TypeError('Active flag must be boolean.')
self._active = value
@property
def role(self):
return self._role
@role.setter
def role(self, value):
if not isinstance(value, UserRole):
values = [
str(member.value)
for name, member in UserRole.__members__.items()
]
raise TypeError('Role must be integer value from this set: ' +
", ".join(values))
self._role = value
@property
def first_name(self):
return self._first_name
@first_name.setter
def first_name(self, value):
if value is None:
self._first_name = None
return
if not isinstance(value, str):
raise TypeError('First name must be string.')
self._first_name = value
@property
def last_name(self):
return self._last_name
@last_name.setter
def last_name(self, value):
if value is None:
self._last_name = None
return
if not isinstance(value, str):
raise TypeError('Last name must be string.')
self._last_name = value
@property
def phone(self):
return self._phone
@phone.setter
def phone(self, value):
if value is None:
self._phone = None
return
if not isinstance(value, str):
raise TypeError('Phone must be string.')
m = re.match(r'^\+(421|420)\d{9}$', value)
if m is None:
raise ValueError(
'Phone must have format \'+421ddddddddd\' or \'+420ddddddddd\', where \'d\' is number.'
)
self._phone = value
@property
def street(self):
return self._street
@street.setter
def street(self, value):
if value is None:
self._street = None
return
if not isinstance(value, str):
raise TypeError('Street must be string.')
self._street = value
@property
def zip_code(self):
return self._zip_code
@zip_code.setter
def zip_code(self, value):
if value is None:
self._zip_code = None
return
if not isinstance(value, str):
raise TypeError('ZIP code must be string.')
m = re.match(r'^\d{5}$', value)
if m is None:
raise ValueError('ZIP code must contain 5 numbers.')
self._zip_code = value
@property
def city(self):
return self._city
@city.setter
def city(self, value):
if value is None:
self._city = None
return
if not isinstance(value, str):
raise TypeError('City must be string.')
self._city = value
@property
def country(self):
return self._country
@country.setter
def country(self, value):
if value is None:
self._country = None
return
if not isinstance(value, Country):
values = [
str(member.value)
for name, member in Country.__members__.items()
]
raise TypeError('Country must be integer value from this set: ' +
", ".join(values))
self._country = value
@property
def date_of_birth(self):
return self._date_of_birth
@date_of_birth.setter
def date_of_birth(self, value):
if value is None:
self._date_of_birth = None
return
if not isinstance(value, datetime.date):
raise TypeError('Date of birth must be date.')
self._date_of_birth = value
