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