class User(db.Model): __tablename__ = 'users' id = db.Column(db.Integer, primary_key=True) first_name = db.Column(db.String(), nullable=False) last_name = db.Column(db.String(), nullable=False) username = db.Column(db.String(), nullable=False, unique=True) password = db.Column(db.String(255), nullable=False) created_at = db.Column(db.DateTime, nullable=False, default=dt.utcnow) def __init__(self, first_name, last_name, username, password): self.first_name = first_name self.last_name = last_name self.username = username self.password = bcrypt.generate_password_hash(password) def __repr__(self): return '<User {}>'.format(self.id) def issue_token(self): payload = { 'expires_at': str(datetime.datetime.utcnow() + datetime.timedelta(days=1)), 'issued_at': str(datetime.datetime.utcnow()), 'subject': self.id } auth_token = jwt.encode(payload, app.config.get('SECRET_KEY'), algorithm='HS256') return auth_token @staticmethod def decode(auth_token): payload = jwt.decode(auth_token, app.config.get('SECRET_KEY')) return payload['subject'] @staticmethod def register(first_name, last_name, username, password): user = User(first_name, last_name, username, password) db.session.add(user) db.session.commit() auth_token = user.issue_token() return auth_token @staticmethod def authenticate(username, password): user = User.query.filter_by(username=username).first() if user and bcrypt.check_password_hash: auth_token = user.issue_token() return auth_token else: raise Exception('Unauthorized') @staticmethod def is_authorized(auth_token): return True if User.decode(auth_token) else False
class User(db.Model, Base): __tablename__ = 'user' id = db.Column(db.Integer, primary_key=True, nullable=False) username = db.Column(db.String(50), unique=True, nullable=False) password = db.Column(db.String(50), nullable=False) phone = db.Column(db.String(20), unique=True, nullable=False) avatar = db.Column(db.String(255), nullable=True) grade = db.Column(db.Integer, default=1, nullable=False) @classmethod def get_user(cls, user_id): user = cls.query.filter_by(id=user_id).first() return user @classmethod def save_data(cls, data): user = cls.query.filter_by(username=data['username'], phone=data['phone']).first() if user: return None else: user = cls(username=data['username'], password=data['password'], phone=data['phone']) db.session.add(user) db.session.commit() return user @classmethod def verify_data(cls, data): user = cls.query.filter_by(username=data['username'], password=data['password']).first() return user
class User(db.Model, UserMixin): id = db.Column(db.Integer, primary_key=True) username = db.Column(db.String(20), nullable=False, unique=True) email = db.Column(db.String(100), nullable=False, unique=True) password = db.Column(db.String(60), nullable=False) image = db.Column(db.String(20), nullable=False, default='default.png') posts = db.relationship('Post', backref='author', lazy=True) comments = db.relationship('Comment', backref='author', lazy=True) def get_reset_token(self, expire_seconds=1800): s = Serializer(app.config['SECRET_KEY'], expire_seconds) 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 Exception: return None return User.query.get(user_id) def __repr__(self): return f"User('{self.username}','{self.email}','{self.image}')"
class User(db.Model): id = db.Column(db.Integer, primary_key=True) username = db.Column(db.String(32), index=True) password_hash = db.Column(db.String(128)) def hash_password(self, password): self.password_hash = pwd_context.encrypt(password) def verify_password(self, password): return pwd_context.verify(password, self.password_hash) def generate_auth_token(self, expiration=600): s = Serializer(app.config['SECRET_KEY'], expires_in=expiration) return s.dumps({'id': self.id}) @staticmethod def verify_auth_token(token): s = Serializer(app.config['SECRET_KEY']) try: data = s.loads(token) except SignatureExpired: return None # valid token, but expired except BadSignature: return None # invalid token user = User.query.get(data['id']) return user
class RegistrationDetail(db.Model, BaseMixin, ReprMixin): name = db.Column(db.String(55), nullable=False) value = db.Column(db.String(20), nullable=False) retail_shop_id = db.Column(db.Integer(), db.ForeignKey('retail_shop.id', ondelete='CASCADE')) retail_shop = db.relationship('RetailShop', foreign_keys=[retail_shop_id], back_populates='registration_details')
class User(db.Model): id = db.Column(UUIDType(binary=False), primary_key=True, default=generate_uuid) username = db.Column(db.String(50), nullable=False, unique=True) pwdhash = db.Column(db.String(80), nullable=False) carts = db.relationship('Cart', backref='customer', lazy=True, cascade="all, delete-orphan, delete") def __repr__(self): return f"User('{self.username}')" def __init__(self, username, password): self.username = username self.set_password(password) def set_password(self, password): self.pwdhash = bcrypt.generate_password_hash(password).decode('utf-8') def check_password(self, password): return bcrypt.check_password_hash(self.pwdhash, password) def serialize(self): return { "id": self.id, "username": self.username, "carts": [{ "cart_id": cart.id, "is_ordered": True if cart.order else False } for cart in self.carts] }
class Tweet(SearchableMixin, db.Model): __searchable__ = ['textbody'] id = db.Column(db.Integer, primary_key=True) identifier = db.Column(db.String(32), nullable=False) textbody_source = db.Column(db.String(500), nullable=False) textbody_markdown = db.Column(db.Text(), nullable=False) userid = db.Column(db.Integer, db.ForeignKey('user.id'), nullable=False) comments = db.relationship('Comment', backref='tweet', lazy="dynamic") created_utc = db.Column(db.DateTime, nullable=False, default=datetime.utcnow) edited_utc = db.Column(db.DateTime, nullable=False, default=datetime.utcnow) stickied = db.Column(db.Boolean, default=False) is_banned = db.Column(db.Boolean, default=False) is_nsfw = db.Column(db.Boolean, default=False) is_edited = db.Column(db.Boolean, default=False) comment_path_counter = db.Column(db.Integer, default=1, autoincrement=True) likes = db.relationship('Like', backref='tweet', lazy='dynamic') @classmethod def get_identifier(cls): while True: ident = secrets.token_hex(nbytes=16) if not cls.query.filter_by(identifier=ident).first(): return ident def __repr__(self): return '<Tweet {}>'.format(self.id)
class Role(BaseMixin, db.Model, RoleMixin, ReprMixin): name = db.Column(db.String(80), unique=True) description = db.Column(db.String(255)) users = db.relationship('User', back_populates='roles', secondary='user_role')
class User(BaseMixin, db.Model, UserMixin, ReprMixin): email = db.Column(db.String(127), unique=True, nullable=False) password = db.Column(db.String(255), default='', nullable=False) username = db.Column(db.String(127), nullable=True) active = db.Column(db.Boolean()) confirmed_at = db.Column(db.DateTime()) last_login_at = db.Column(db.DateTime()) current_login_at = db.Column(db.DateTime()) last_login_ip = db.Column(db.String(45)) current_login_ip = db.Column(db.String(45)) login_count = db.Column(db.Integer) roles = db.relationship('Role', back_populates='users', secondary='user_role') permissions = db.relationship('Permission', back_populates='users', secondary='user_permission') user_profile = db.relationship("UserProfile", uselist=False, back_populates="user", cascade='all, delete-orphan', lazy='subquery') def has_permission(self, permission): if isinstance(permission, str): return permission in (permission.name for permission in self.permissions) else: return permission in self.permissions
class User(db.Model, UserMixin): __tablename__ = 'users' 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) def get_reset_token(self, expires_sec=1800): s = Serializer(current_app.config['SECRET_KEY'], expires_sec) return s.dumps({'user_id': self.id}).decode('utf-8') @staticmethod def verify_reset_token(token): s = Serializer(current_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 (self.username, self.email, self.image_file)
class Country(db.Model): __tablename__ = "countries" id = db.Column(db.Integer, primary_key=True, auto_increment=True) name = db.Column(db.String(50), unique=True) code = db.Column(db.String(50), unique=True) provinces = db.relationship('Province', backref='Country', lazy=True)
class Contact(db.Model): __tablename__ = 'contact' __table_args__ = ( db.ForeignKeyConstraint( ["person_id", ], ["person.id",] ), ) id = db.Column(db.Integer, autoincrement=True, primary_key=True) person_id = db.Column(db.Integer, primary_key=True) person = db.relationship("Person") email = db.Column(db.String(65)) cell_phone = db.Column(db.String(11)) phone = db.Column(db.String(11)) creation_date = db.Column(db.DateTime(), nullable=False, default=datetime.datetime.utcnow()) modification_date = db.Column(db.DateTime(), nullable=False, default=datetime.datetime.utcnow()) def __init__(self, person_id, email, cell_phone, phone): self.person_id = person_id self.email = email self.cell_phone = cell_phone self.phone = phone def __repr__(self): contact = 'id: {id}' if email: contact+= f', email:{email}' if cell_phone: contact+= f', cellphone:{cell_phone}' return f'<Contact: {contact}'
class Hint(db.Model): id = db.Column(db.Integer, primary_key=True) text = db.Column(db.String(255), unique=False, nullable=False) h_type = db.Column(db.String(100), unique=False, nullable=False) question_id = db.Column(db.Integer, db.ForeignKey('question.id'), nullable=False)
class User(db.Model): __tablename__ = "account" id = db.Column(db.Integer, primary_key=True) date_created = db.Column(db.DateTime, default=db.func.current_timestamp()) date_modified = db.Column(db.DateTime, default=db.func.current_timestamp(), onupdate=db.func.current_timestamp()) name = db.Column(db.String(144), nullable=False) username = db.Column(db.String(144), nullable=False) password = db.Column(db.String(144), nullable=False) equipment = db.relationship("Equipment") def __init__(self, name, username, password): self.name = name self.username = username self.password = password def get_id(self): return self.id def is_active(self): return True def is_anonymous(self): return False def is_authenticated(self): return True def get_equipment(self): return self.equipment
class LogBindBankCard(db.Model, LogBaseMixin, LogUserMixin): """绑卡表""" __tablename__ = 'tb_bind_bankcard' location = db.Column(db.String(200), comment="绑卡地点") bind_time = db.Column(db.BigInteger, comment="绑卡时间", index=True) result = db.Column(db.String(10), comment="绑卡结果", index=True)
class User(db.Model, UserMixin): __tablename__ = 'user' id = db.Column(db.Integer, primary_key=True) user_email = db.Column(db.String(64), unique=True, index=True) user_username = db.Column(db.String(64), unique=True, index=True) user_posts = db.relationship('Topic', cascade="all, delete-orphan", backref='author', lazy='dynamic') user_role = db.Column(db.String(10), index=True, default='User') user_first_name = db.Column(db.String(64), index=True, nullable=True) user_last_name = db.Column(db.String(64), index=True, nullable=True) user_birthday = db.Column(db.DateTime(), index=True, nullable=True) user_date = db.Column(db.DateTime(), index=True, nullable=True) user_location = db.Column(db.String(64), index=True, nullable=True) user_about = db.Column(db.String(140), index=True, nullable=True) user_occupation = db.Column(db.String(100), index=True, nullable=True) user_interests = db.Column(db.String(100), index=True, nullable=True) password_hash = db.Column(db.String(128)) user_reply = db.relationship('Reply', cascade="all, delete-orphan", backref='reply_from', lazy='dynamic') def __init__(self, user_email, user_username, user_password, user_role, user_date): self.user_email = user_email self.user_username = user_username self.user_role = user_role self.password_hash = generate_password_hash(user_password) self.user_date = user_date def check_password(self, password): return check_password_hash(self.password_hash, password)
class School(db.Model): id = db.Column(db.Integer, primary_key=True) name = db.Column(db.String(120), unique=True) slug = db.Column(db.String(120), index=True) domains = db.Column(JSON, default=[]) is_demo = db.Column(db.Boolean(), default=False) redeem_prize_email = db.Column(db.String(120)) launchable = db.Column(db.Boolean(), default=True) is_destroyed = db.Column(db.Boolean(), default=False) created_at = db.Column(db.DateTime, default=datetime.datetime.utcnow) def __init__(self, name, domains=[], is_demo=False, redeem_prize_email=None, launchable=True): self.name = name self.slug = slugify(name, separator='-', to_lower=True) self.domains = domains self.is_demo = is_demo self.redeem_prize_email = redeem_prize_email self.launchable = launchable def __repr__(self): return '<School id={}, name={}, slug={}, domains={}, is_demo={}, redeem_prize_email={}, launchable={}, is_destroyed={}, created_at={}>'.format( self.id, self.name, self.slug, self.domains, self.is_demo, self.redeem_prize_email, self.launchable, self.is_destroyed, self.created_at) def active_users(self): return [u for u in self.users if not u.is_destroyed] def active_challenges(self): return [c for c in self.challenges if not c.is_destroyed]
class User(db.Model): __tablename__ = 'users' id = db.Column(db.Integer, primary_key=True) username = db.Column(db.String(50), unique=True, nullable=False) email = db.Column(db.String(50), unique=True, nullable=False) password = db.Column(db.String(256), nullable=False) is_admin = db.Column(db.Boolean, default=False) uuid = db.Column(db.String(36), unique=True) def __init__(self, username, email, password, is_admin=False): self.username = username self.email = email self.password = generate_password_hash(password) self.is_admin = is_admin self.uuid = str(uuid.uuid4()) def __repr__(self): return f'User: {self.username}, {self.email}, {self.is_admin}, {self.uuid}' @classmethod def find_user_by_username(cls, username): return cls.query.filter_by(username=username).first() @classmethod def find_user_by_uuid(cls, uuid): return cls.query.filter_by(uuid=uuid).first()
class ScheduleModel(ModelBase): __tablename__ = 'schedules' uuid = db.Column(db.String(80), primary_key=True, nullable=False) name = db.Column(db.String(80), nullable=False, unique=True) @validates('name') def validate_name(self, _, value): if not re.match("^([A-Za-z0-9_-])+$", value): raise ValueError( "name should be alphanumeric and can contain '_', '-'") return value def __repr__(self): return f"Schedule(uuid = {self.uuid})" @classmethod def find_by_name(cls, name): return cls.query.filter_by(name=name).first() def update(self, **kwargs): if super().update(**kwargs): from src.services.schedules_registry import SchedulesRegistry SchedulesRegistry().update_schedule(self) return self def delete_from_db(self): super().delete_from_db() from src.services.schedules_registry import SchedulesRegistry SchedulesRegistry().delete_schedule(self) def save_to_db(self): super().save_to_db() from src.services.schedules_registry import SchedulesRegistry SchedulesRegistry().add_schedule(self)
class LogLoading(db.Model, LogBaseMixin): """加载表""" __tablename__ = "tb_loading" location = db.Column(db.String(200), comment="加载地") load_time = db.Column(db.BigInteger, comment='加载时间', index=True) result = db.Column(db.String(100), comment="加载结果", index=True)
class User(db.Model, UserMixin): """User table model""" id = db.Column(db.Integer, primary_key=True) username = db.Column(db.String(25), unique=True, nullable=False) email = db.Column(db.String(100), unique=True, nullable=False) password = db.Column(db.String(30), nullable=False) lessons = db.relationship('Lesson', backref='author', lazy=True)
class LogRegister(db.Model, LogBaseMixin, LogUserMixin): """注册表""" __tablename__ = 'tb_register' location = db.Column(db.String(200), comment="认证地") reg_time = db.Column(db.BigInteger, comment="注册时间", index=True) result = db.Column(db.String(100), comment="注册结果", index=True)
class Role(db.Model): """Hold Role Details.""" __tablename__ = 'sec_roles' role_id = db.Column(db.Integer, primary_key=True) role_name = db.Column(db.String(50), nullable=False, unique=True) role_description = db.Column(db.String(255), nullable=False) users = db.relationship('User', secondary='sec_users_roles', backref=db.backref('users', lazy='dynamic')) menus = db.relationship('navigation.models.Menu', secondary='nav_roles_menus', backref=db.backref('roles', lazy='dynamic')) is_active = db.Column(db.Boolean(), nullable=False, server_default='1') created_by = db.Column(db.Integer) created_datetime = db.Column(db.DateTime, default=datetime.now()) modified_by = db.Column(db.Integer) last_modified_datetime = db.Column(db.DateTime, nullable=True) is_default = db.Column(db.Boolean(), default=False) def __init__(self, role_name, role_description, created_by): """Create a new role.""" self.role_name = role_name self.role_description = role_description self.created_by = created_by self.created_datetime = datetime.now() def __repr__(self): """Represent an instance of the class.""" return self.role_name
class LogLogin(db.Model, LogBaseMixin, LogUserMixin): """登陆表""" __tablename__ = "tb_login" location = db.Column(db.String(200), comment="登陆地") login_time = db.Column(db.BigInteger, comment="登陆时间", index=True) result = db.Column(db.String(10), comment="登陆结果", index=True)
class User(UserMixin, db.Model): __tablename__="users" id = db.Column(db.Integer, primary_key=True) username = db.Column(db.String (200), nullable=False) mobile = db.Column(db.String, nullable=False, unique=True) email = db.Column(db.String (200), index = True, unique=True) password_hash = db.Column(db.String(1200)) tokens = db.relationship("Token", backref="user", lazy=True) order = db.relationship("Order", backref="user", lazy=True) location = db.relationship("Location", backref="user", lazy=True) def set_password(self, password): self.password_hash = generate_password_hash(password) def check_password(self, password): return check_password_hash(self.password_hash, password) def check_user(self): return User.query.filter_by(email=self.email).first() def add(self): db.session.add(self) db.session.commit() def get_json(self): return { "id": self.id, "username": self.username, "mobile": self.mobile, "email": self.email }
class LogRealnameAuth(db.Model, LogBaseMixin, LogUserMixin): """实名认证表""" __tablename__ = "tb_realnameauth" location = db.Column(db.String(200), comment="认证地") auth_time = db.Column(db.BigInteger, comment="认证时间", index=True) result = db.Column(db.String(10), comment="认证结果", index=True)
class Film(db.Model): id = db.Column(db.Integer, primary_key=True) title = db.Column(db.String, nullable=False) release_date = db.Column(db.Date, index=True, nullable=False) uuid = db.Column(db.String(36), unique=True) description = db.Column(db.Text) distributed_by = db.Column(db.String(128), nullable=False) length = db.Column(db.Float) rating = db.Column(db.Float) def __init__(self, title, release_date, description, distributed_by, length, rating): self.title = title self.release_date = release_date self.uuid = str(uuid.uuid4()) self.description = description self.distributed_by = distributed_by self.length = length self.rating = rating def __repr__(self): return f'Film({self.title}, {self.release_date}, {self.uuid}, {self.distributed_by})' def to_dict(self): return { 'title': self.title, 'uuid': self.uuid, 'release_date': self.release_date.strftime('%Y-%m-%d'), 'distributed_by': self.distributed_by, 'description': self.description, 'length': self.length, 'rating': self.rating, }
class LogFaceSign(db.Model, LogBaseMixin, LogUserMixin): """面签表""" __tablename__ = 'tb_face_sign' location = db.Column(db.String(200), comment="面签地") face_sign_time = db.Column(db.BigInteger, comment="面签时间", index=True) result = db.Column(db.String(10), comment="面签结果", index=True)
class User(db.Model): """User Model for storing user related details.""" __tablename__ = "users" id = db.Column(db.Integer, primary_key=True, autoincrement=True) username = db.Column(db.String(255), unique=True, nullable=False) password = db.Column(db.String(255), nullable=False) registered_on = db.Column(db.DateTime, nullable=False) account_type = db.Column(db.Integer, nullable=True) def __init__(self, username, password, account_type): self.username = username self.password = bcrypt.generate_password_hash( password, app.config.get("BCRYPT_LOG_ROUNDS")).decode() self.registered_on = datetime.datetime.now() self.account_type = (account_type if account_type == 1 or account_type == 2 else None) def encode_auth_token(self, user_id): """ Generates the Auth Token :return: string """ try: payload = { "exp": datetime.datetime.utcnow() + datetime.timedelta(days=1, seconds=0), "iat": datetime.datetime.utcnow(), "sub": user_id, } return jwt.encode(payload, app.config.get("SECRET_KEY"), algorithm="HS256") except Exception as e: return e @staticmethod def decode_auth_token(auth_token): """ Validates the auth token :param auth_token: :return: integer|string """ try: payload = jwt.decode(auth_token, app.config.get("SECRET_KEY"), algorithms=["HS256"]) is_blacklisted_token = BlacklistToken.check_blacklist(auth_token) if is_blacklisted_token: return "Token blacklisted. Please log in again." else: return payload["sub"] except jwt.ExpiredSignatureError: return "Signature expired. Please log in again." except jwt.InvalidTokenError: return "Invalid token. Please log in again."
class Url(db.Model): __tablename__ = "url" id = db.Column(db.Integer, primary_key=True, autoincrement=True) url = db.Column(db.String(256), nullable=False) code = db.Column(db.String(6), nullable=False) created_at = db.Column(db.DateTime, default=datetime.datetime.utcnow(), nullable=False) last_usage = db.Column(db.DateTime, nullable=True) usage_count = db.Column(db.Integer, default=0, nullable=False) def to_json(self): return {'url': self.url, 'code': self.code} def stats_to_json(self): result = { 'created_at': self.created_at.isoformat(), 'usage_count': self.usage_count } if self.last_usage is not None: result['last_usage'] = self.last_usage.isoformat() return result def save(self): db.session.add(self) db.session.commit()