class Vat_return(SurrogatePK, Model, TimestampMixin): __tablename__ = 'vat_returns' organisation_id = reference_col('organisations', nullable=False) period_key = Column(db.String(4)) vat_due_sales = Column(db.String(10)) vat_due_acquisitions = Column(db.String(10)) total_vat_due = Column(db.String(10)) vat_reclaimed_curr_period = Column(db.String(10)) net_vat_due = Column(db.String(10)) total_value_sales_ex_vat = Column(db.String(10)) total_value_purchases_ex_vat = Column(db.String(10)) total_value_goods_supplied_ex_vat = Column(db.String(10)) total_acquisitions_ex_vat = Column(db.String(10)) finalised = Column(db.Boolean(), default=True) is_submitted = Column(db.Boolean(), default=False) submitted_on = Column(db.DateTime, nullable = True) submitted_by = Column(db.String(50), nullable=True) def __init__(self, organisation_id, period_key, **kwargs): db.Model.__init__(self, organisation_id=organisation_id, period_key=period_key, **kwargs) def is_submitted(self): """Active or non active user (required by flask-login)""" return self.is_submitted
class User(UserMixin, SurrogatePK, Model): __tablename__ = 'users' username = Column(db.String(80), unique=True, nullable=False) email = Column(db.String(80), unique=True, nullable=False) #: The hashed password password = Column(db.String(128), nullable=True) created_at = Column(db.DateTime, nullable=False, default=dt.datetime.utcnow) first_name = Column(db.String(30), nullable=True) last_name = Column(db.String(30), nullable=True) active = Column(db.Boolean(), default=False) is_admin = Column(db.Boolean(), default=False) def __init__(self, username, email, password=None, **kwargs): db.Model.__init__(self, username=username, email=email, **kwargs) if password: self.set_password(password) else: self.password = None def set_password(self, password): self.password = bcrypt.generate_password_hash(password) def check_password(self, value): return bcrypt.check_password_hash(self.password, value) @property def full_name(self): return "{0} {1}".format(self.first_name, self.last_name) def __repr__(self): return '<User({username!r})>'.format(username=self.username)
class User(CRUDMixin, UserMixin, db.Model): id = db.Column(db.Integer, primary_key=True) username = db.Column(db.String(20), nullable=False, unique=True) email = db.Column(db.String(128), nullable=False, unique=True) pw_hash = db.Column(db.String(60), nullable=False) created_ts = db.Column(db.DateTime(timezone=True), default=datetime.datetime.utcnow) updated_ts = db.Column(db.DateTime(timezone=True), default=datetime.datetime.utcnow) remote_addr = db.Column(db.String(20)) active = db.Column(db.Boolean()) is_admin = db.Column(db.Boolean()) def __init__(self, password, **kwargs): super(User, self).__init__(**kwargs) self.set_password(password) def __repr__(self): return '<User #%s:%r>' % (self.id, self.username) def set_password(self, password): hash_ = bcrypt.generate_password_hash(password, 10).decode('utf-8') self.pw_hash = hash_ def check_password(self, password): return bcrypt.check_password_hash(self.pw_hash, password)
class User(UserMixin, SurrogatePK, Model, EntityBase): """A user of the app.""" __tablename__ = "users" account = Column(db.String(80), unique=True, nullable=False) email = Column(db.String(80), unique=True, nullable=False) #: The hashed password password = Column(db.LargeBinary(128), nullable=True) created_at = Column(db.DateTime, nullable=False, default=dt.datetime.utcnow) first_name = Column(db.String(30), nullable=True) last_name = Column(db.String(30), nullable=True) active = Column(db.Boolean(), default=False) is_admin = Column(db.Boolean(), default=False) def __init__(self, account, email, password=None, **kwargs): """Create instance.""" db.Model.__init__(self, account=account, email=email, **kwargs) if password: self.set_password(password) else: self.password = None def get_id(self): """获取用户ID""" return self.id def set_password(self, password): """Set password.""" self.password = bcrypt.generate_password_hash(password) def check_password(self, value): """Check password.""" return bcrypt.check_password_hash(self.password, value) @property def full_name(self): """Full user name.""" return f"{self.first_name} {self.last_name}" def __repr__(self): """Represent instance as a unique string.""" return f"<User({self.account!r})>" @classmethod def verify_auth_token(cls, token): data = jwt.decode(token, current_app.config["SECRET_KEY"], algorithms=['HS256']) return cls.query.get(data["id"]) def generate_token(self): return jwt.encode({"id": self.id}, current_app.config["SECRET_KEY"], algorithm='HS256')
class User(CRUDMixin, UserMixin, db.Model): id = db.Column(db.Integer, primary_key=True) email = db.Column(db.String(128), nullable=False, unique=True) pw_hash = db.Column(db.String(60), nullable=False) created_ts = db.Column( db.DateTime(timezone=True), server_default=db.func.current_timestamp(), ) updated_ts = db.Column( db.DateTime(timezone=True), onupdate=db.func.current_timestamp(), ) remote_addr = db.Column(db.String(20)) active = db.Column(db.Boolean()) is_admin = db.Column(db.Boolean()) def __init__(self, email, password, remote_addr, active=False, is_admin=False): self.email = email self.set_password(password) self.created_ts = datetime.datetime.now() self.remote_addr = remote_addr self.active = active self.is_admin = is_admin def __repr__(self): return '<User %s>' % self.email def set_password(self, password): self.pw_hash = bcrypt.generate_password_hash(password, 10).decode("utf-8") def check_password(self, password): return bcrypt.check_password_hash(self.pw_hash, password) @classmethod def stats(cls): active_users = cache.get('active_users') if not active_users: active_users = cls.query.filter_by(active=True).count() cache.set('active_users', active_users) inactive_users = cache.get('inactive_users') if not inactive_users: inactive_users = cls.query.filter_by(active=False).count() cache.set('inactive_users', inactive_users) return { 'all': active_users + inactive_users, 'active': active_users, 'inactive': inactive_users }
class Printer(db.Model): __tablename__ = "printers" id = db.Column(db.Integer, primary_key=True) vendor = db.Column(db.String(100), nullable=True, unique=True) product = db.Column(db.String(100), unique=True) in_ep = db.Column(db.Integer, nullable=True) out_ep = db.Column(db.Integer, nullable=True) active = db.Column(db.Boolean()) langu = db.Column(db.String(100)) value = db.Column(db.Integer) def __init__(self, vendor=" ", product=" ", in_ep=0, out_ep=0, active=False, langu='en', value=1): self.vendor = vendor self.product = product self.in_ep = in_ep self.out_ep = out_ep self.active = active self.value = value
class User(db.Model, UserMixin): """ User model Arguments: id (int): Primary User Key username (str): Unique username as chosen by the user email (str): User's email address password_hash (str): Users hashed password """ __tablename__ = 'users' id = db.Column(db.Integer, primary_key=True) username = db.Column(db.String(80), unique=True) email = db.Column(db.String(120), unique=True) password = db.Column(db.String(255)) active = db.Column(db.Boolean()) confirmed_at = db.Column(db.DateTime()) roles = db.relationship('Role', secondary=roles_users, backref=db.backref('users', lazy='dynamic')) def __repr__(self): return '<User %r>' % self.username def __str(self): return self.username
class User(db.Model, UserMixin): __tablename__ = 'users' id = db.Column(db.Integer, primary_key=True) active = db.Column('is_active', db.Boolean(), nullable=False, server_default='1') # User authentication information. The collation='NOCASE' is required # to search case insensitively when USER_IFIND_MODE is 'nocase_collation'. username = db.Column(db.String(255, collation='NOCASE'), nullable=False, unique=True) password = db.Column(db.String(255), nullable=False, server_default='') # User information first_name = db.Column(db.String(100, collation='NOCASE'), nullable=False, server_default='') last_name = db.Column(db.String(100, collation='NOCASE'), nullable=False, server_default='') # Define the relationship to Role via UserRoles roles = db.relationship( 'Role', secondary='user_roles', ) def __repr__(self): return self.first_name
class VSRole(CRUDMixin, db.Model): """ 角色模型 """ __tablename__ = 'tbl_vsppm_role' id = db.Column(db.Integer, primary_key=True, autoincrement=True) # 角色名称 name = db.Column(db.String(128), nullable=False, unique=True) # 角色描述 role = db.Column(db.String(128), nullable=False) # 创建时间 created_ts = db.Column(db.DateTime(timezone=True), default=datetime.datetime.utcnow) # 更新时间 updated_ts = db.Column(db.DateTime(timezone=True), default=datetime.datetime.utcnow) # 激活状态 active = db.Column(db.Boolean(), default=True) # 让VSRole和VSAcl产生关联 # 因为VSAcl和VSRole表中间还有一个vsppm_user_role表,所以添加secondary # 正向引用是VSRole访问VSAcl,反向引用是从VSAcl访问表VSRole acls = db.relationship('VSAcl', secondary=vsppm_role_acl, backref=db.backref('roles')) def __init__(self, **kwargs): super(VSRole, self).__init__(**kwargs) def __repr__(self): return '<VSRole #%s:%r>' % (self.id, self.name)
class VSGroup(CRUDMixin, db.Model): """ 组模型 """ __tablename__ = 'tbl_vsppm_group' id = db.Column(db.Integer, primary_key=True, autoincrement=True) # 组名称 name = db.Column(db.String(128), nullable=False, unique=True) # 组负责人 admin = db.Column(db.String(60)) # 所属部门id department_id = db.Column(db.Integer, nullable=False) # 创建时间 created_ts = db.Column(db.DateTime(timezone=True), default=datetime.datetime.utcnow) # 更新时间 updated_ts = db.Column(db.DateTime(timezone=True), default=datetime.datetime.utcnow) # 激活状态 active = db.Column(db.Boolean(), default=True) def __init__(self, **kwargs): super(VSGroup, self).__init__(**kwargs) def __repr__(self): return '<VSGroup #%s:%r>' % (self.id, self.name)
class VSCompany(CRUDMixin, db.Model): """ 公司模型 """ __tablename__ = 'tbl_vsppm_company' id = db.Column(db.Integer, primary_key=True, autoincrement=True) # 公司名称 name = db.Column(db.String(128), nullable=False, unique=True) # 公司负责人 admin = db.Column(db.String(60)) # 主页 website = db.Column(db.String(128)) # 创建时间 created_ts = db.Column(db.DateTime(timezone=True), default=datetime.datetime.utcnow) # 更新时间 updated_ts = db.Column(db.DateTime(timezone=True), default=datetime.datetime.utcnow) # 激活状态 active = db.Column(db.Boolean(), default=True) def __init__(self, **kwargs): super(VSCompany, self).__init__(**kwargs) def __repr__(self): return '<VSCompany #%s:%r>' % (self.id, self.name)
class VSAcl(CRUDMixin, db.Model): """ 权限模型 """ __tablename__ = 'tbl_vsppm_acl' id = db.Column(db.Integer, primary_key=True, autoincrement=True) # 权限模块名称 module = db.Column(db.String(128), nullable=False) # 权限模块功能方法名称 method = db.Column(db.String(128), nullable=False) # 创建时间 created_ts = db.Column(db.DateTime(timezone=True), default=datetime.datetime.utcnow) # 更新时间 updated_ts = db.Column(db.DateTime(timezone=True), default=datetime.datetime.utcnow) # 激活状态 active = db.Column(db.Boolean(), default=True) def __init__(self, **kwargs): super(VSAcl, self).__init__(**kwargs) def __repr__(self): return '<VSAcl #%s:%r:%r>' % (self.id, self.module, self.method)
class VSProject(CRUDMixin, db.Model): """" 项目模型 """ __tablename__ = 'tbl_sqlalchemy_project' # 项目访问权限 open: 公开 private: 私有 access = db.Column(db.String(20), default='open') # 创建时间 created_ts = db.Column(db.DateTime(timezone=True), default=datetime.datetime.utcnow) # 更新时间 updated_ts = db.Column(db.DateTime(timezone=True), default=datetime.datetime.utcnow) # 激活状态 active = db.Column(db.Boolean(), default=True) # many to many users = db.relationship( "VSUser", # 默认userlist=false为一对多关系,userlist=true为多对多关系 uselist=True, secondary=project_user_association_table, backref="projects", # 关联的user表记录也会删除 cascade="save-update, merge, delete") def __init__(self, **kwargs): super(VSProject, self).__init__(**kwargs)
class Article(db.Model): __tablename__ = 'articles' id = db.Column(db.Integer, primary_key=True) title = db.Column(db.String(250)) link = db.Column(db.String(250)) pub_date = db.Column(db.DateTime) desc = db.Column(db.Text) was_published = db.Column(db.Boolean(), default=False) created_at = db.Column(db.DateTime, default=datetime.datetime.now)
class Media(db.Model): __tablename__ = "media" id = db.Column(db.Integer, primary_key=True) vid = db.Column(db.Boolean()) audio = db.Column(db.Boolean()) img = db.Column(db.Boolean()) used = db.Column(db.Boolean()) name = db.Column(db.String(50)) def __init__(self, vid=False, audio=False, img=False, used=False, name=" "): self.vid = vid self.audio = audio self.img = img self.used = used self.name = name
class User(UserMixin, SurrogatePK, Model): """A user of the app.""" __tablename__ = "users" username = Column(db.String(80), unique=True, nullable=False) email = Column(db.String(80), unique=True, nullable=False) #: The hashed password password = Column(db.LargeBinary(128), nullable=True) created_at = Column(db.DateTime, nullable=False, default=dt.datetime.utcnow) first_name = Column(db.String(30), nullable=True) last_name = Column(db.String(30), nullable=True) active = Column(db.Boolean(), default=False) is_admin = Column(db.Boolean(), default=False) def __init__(self, username, email, password=None, **kwargs): """Create instance.""" db.Model.__init__(self, username=username, email=email, **kwargs) if password: self.set_password(password) else: self.password = None def set_password(self, password): """Set password.""" self.password = bcrypt.generate_password_hash(password) def check_password(self, value): """Check password.""" return bcrypt.check_password_hash(self.password, value) @property def full_name(self): """Full user name.""" return f"{self.first_name} {self.last_name}" def __repr__(self): """Represent instance as a unique string.""" return f"<User({self.username!r})>"
class User(db.Model, UserMixin): id = db.Column(db.Integer(), primary_key=True) email = db.Column(db.String(100), unique=True) password = db.Column(db.String(255)) active = db.Column(db.Boolean()) roles = db.relationship('Role', secondary=roles_users, backref=db.backref('users', lazy='dynamic')) def get_id(self): return self.id def get_urole(self): return self.role
class Settings(db.Model): __table_args__ = {"schema": settings.SQLALCHEMY_DATABASE_SCHEMA} __tablename__ = "settings" id = db.Column(db.Integer(), primary_key = True) max_likes_per_day = db.Column(db.Integer(), default = 600) max_unlikes_per_day = db.Column(db.Integer(), default = 600) max_follows_per_day = db.Column(db.Integer(), default = 350) max_unfollows_per_day = db.Column(db.Integer(), default = 200) max_comments_per_day = db.Column(db.Integer(), default = 100) max_likes_to_like = db.Column(db.Integer(), default = 2000) filter_users = db.Column(db.Boolean(), default = 1) filter_business_accounts = db.Column(db.Boolean(), default = 1) filter_verified_accounts = db.Column(db.Boolean(), default = 1) filter_users_without_profile_photo = db.Column(db.Boolean(), default = 1) filter_users_with_external_url = db.Column(db.Boolean(), default = 1) max_followers_to_follow = db.Column(db.Integer(), default = 5000) min_followers_to_follow = db.Column(db.Integer(), default = 10) max_following_to_follow = db.Column(db.Integer(), default = 2000) min_following_to_follow = db.Column(db.Integer(), default = 10) max_followers_to_following_ratio = db.Column(db.Integer(), default = 10) max_following_to_followers_ratio = db.Column(db.Integer(), default = 2) min_media_count_to_follow = db.Column(db.Integer(), default = 3) max_following_to_block = db.Column(db.Integer(), default = 2000) like_delay = db.Column(db.Integer(), default = 30) unlike_delay = db.Column(db.Integer(), default = 30) follow_delay = db.Column(db.Integer(), default = 30) unfollow_delay = db.Column(db.Integer(), default = 30) comment_delay = db.Column(db.Integer(), default = 30) def __repr__(self): from app.utils.functions import config_to_dict self_dict = config_to_dict(self) msg = [k + '=' + str(v) for k, v in self_dict.items()] return ','.join(msg) pass
class VSUser(CRUDMixin, db.Model): """" 账户模型 """ __tablename__ = 'tbl_sqlalchemy_user' account = db.Column(db.String(56), nullable=False, unique=True) created_ts = db.Column(db.DateTime(timezone=True), default=datetime.datetime.utcnow) updated_ts = db.Column(db.DateTime(timezone=True), default=datetime.datetime.utcnow) active = db.Column(db.Boolean(), default=True) def __init__(self, **kwargs): super(VSUser, self).__init__(**kwargs)
class Page(db.Model): __tablename__ = 'pages' id = db.Column(db.Integer, primary_key=True) name = db.Column(db.Unicode(64)) is_active = db.Column(db.Boolean(), default=True, unique=False) slug = db.Column(db.String(220)) seo_title = db.Column(db.String(85)) seo_desc = db.Column(db.String(180)) seo_keywords = db.Column(db.String(200)) text = db.Column(db.UnicodeText) desc = db.Column(db.UnicodeText) def __repr__(self): return self.name
class User(BaseModel, UserMixin): __tablename__ = 'user' username = db.Column(db.String(255), unique=True, index=True) password = db.Column(db.String(255)) active = db.Column(db.Boolean(), index=True) 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(63)) current_login_ip = db.Column(db.String(63)) login_count = db.Column(db.Integer) groups = db.relationship('Group', secondary=groups_users, backref=db.backref('users', lazy='dynamic')) roles = db.relationship('Role', secondary=roles_users, backref=db.backref('users', lazy='dynamic')) def __repr__(self): return '<User %r>' % self.username
class User(db.Model, UserMixin): """ Модель пользователей """ __tablename__ = 'users' id = db.Column(db.BigInteger, primary_key=True, nullable=False, autoincrement=True, comment='ID пользователя') name = db.Column(db.String(255), nullable=False, comment='Имя пользователя') phone = db.Column(db.String(255), nullable=False, comment='Телефон пользователя') email = db.Column(db.String(255), nullable=False, unique=True, comment='Email пользователя') password = db.Column(db.String(255), nullable=False, comment='Пароль пользователя') created_at = db.Column(db.DateTime(), nullable=False, default=datetime.now(), comment='Дата создания') updated_at = db.Column(db.DateTime(), nullable=False, default=datetime.now(), comment='Дата обновления') confirmed = db.Column(db.Boolean(), default=False, comment='Подтвержден?') def __repr__(self): return '<User %r>' % self.name
class User(db.Model, UserMixin): id = db.Column(db.Integer, primary_key=True) email = db.Column(db.String(255), unique=True) username = db.Column(db.String(255)) password = db.Column(db.String(255)) last_login_at = db.Column(db.DateTime()) current_login_at = db.Column(db.DateTime()) last_login_ip = db.Column(db.String(100)) current_login_ip = db.Column(db.String(100)) login_count = db.Column(db.Integer) active = db.Column(db.Boolean()) confirmed_at = db.Column(db.DateTime()) roles = db.relationship('Role', secondary='roles_users', backref=db.backref('users', lazy='dynamic')) def __repr__(self): return '%r %r' % (self.username, self.email) def get_setup(self): return dict(key=self.id, username=self.username, email=self.email, admin=self.is_admin()) def change_admin(self): admin = Role.query.filter(Role.name == 'admin').first() if admin in self.roles: self.roles.remove(admin) else: self.roles.append(admin) def is_admin(self): roles = [each.name for each in self.roles] if 'admin' in roles: return True return False
class User(db.Model, UserMixin): __tablename__ = 'user' id = db.Column(db.Integer, primary_key=True) email = db.Column(db.String(255), unique=True) username = db.Column(db.String(255), unique=True, index=True) password_hash = db.Column(db.String(255)) active = db.Column(db.Boolean()) confirmed_at = db.Column(db.DateTime()) name = db.Column(db.String(64)) location = db.Column(db.String(64)) member_since = db.Column(db.DateTime(), default=datetime.utcnow) about_me = db.Column(db.String(140)) last_seen = db.Column(db.DateTime, default=datetime.utcnow) avatar_hash = db.Column(db.String(32)) roles = db.relationship('Role', secondary='roles_users', backref=db.backref('users', lazy='dynamic')) posts = db.relationship('Post', backref='author', lazy='dynamic') img = db.relationship('StorageImg', backref='author', lazy='dynamic') def __init__(self, **kwargs): super(User, self).__init__(**kwargs) if self.email is not None and self.avatar_hash is None: self.avatar_hash = self.gravatar_hash() def __repr__(self): return 'id-{}, username-{}'.format(self.id, self.username) @property def password(self): raise AttributeError('password is not a readable attribute') @password.setter def password(self, password): self.password_hash = generate_password_hash(password) def verify_password(self, password): return check_password_hash(self.password_hash, password) def generate_confirmation_token(self, expiration=3600): s = Serializer(current_app.config['SECRET_KEY'], expiration) return s.dumps({'confirm': self.id}).decode('utf-8') def confirm(self, token): s = Serializer(current_app.config['SECRET_KEY']) try: data = s.loads(token.encode('utf-8')) except: return False if data.get('confirm') != self.id: return False self.confirmed_at = datetime.utcnow() db.session.add(self) return True def generate_reset_token(self, expiration=3600): s = Serializer(current_app.config['SECRET_KEY'], expiration) return s.dumps({'reset': self.id}).decode('utf-8') @staticmethod def reset_password(token, new_password): s = Serializer(current_app.config['SECRET_KEY']) try: data = s.loads(token.encode('utf-8')) except: return False user = User.query.get(data.get('reset')) if user is None: return False user.password = new_password db.session.add(user) return True def gravatar_hash(self): return hashlib.md5(self.email.lower().encode('utf-8')).hexdigest() def gravatar(self, size=100, default='identicon', rating='g'): url = 'https://secure.gravatar.com/avatar' hash = self.avatar_hash or self.gravatar_hash() return '{url}/{hash}?s={size}&d={default}&r={rating}'.\ format(url=url, hash=hash, size=size, default=default, rating=rating) def generate_email_change_token(self, new_email, expiration=3600): s = Serializer(current_app.config['SECRET_KEY'], expiration) return s.dumps({ 'change_email': self.id, 'new_email': new_email }).decode('utf-8') def change_email(self, token): s = Serializer(current_app.config['SECRET_KEY']) try: data = s.loads(token.encode('utf-8')) except: return False if data.get('change_email') != self.id: return False new_email = data.get('new_email') if new_email is None: return False if self.query.filter_by(email=new_email).first() is not None: return False self.email = new_email self.avatar_hash = self.gravatar_hash() db.session.add(self) return True def is_administrator(self): for r in self.roles: if str(r) == 'admin': return True return False def is_writer(sefl): for r in sefl.roles: if str(r) == 'post': return True return False def __str__(sefl): return '{}'.format(sefl.username)
class User(UserMixin, SurrogatePK, Model): """A user of the app.""" __tablename__ = 'users' username = Column(db.String(80), unique=True, nullable=False) email = Column(db.String(80), unique=True, nullable=False) #: The hashed password password = Column(db.LargeBinary(128), nullable=True) first_name = Column(db.String(30), nullable=True) last_name = Column(db.String(30), nullable=True) active = Column(db.Boolean(), default=False) is_admin = Column(db.Boolean(), default=False) email_confirmed = Column(db.Boolean(), nullable=True, default=False) email_confirmed_at = Column(db.DateTime(timezone=True), nullable=True) locale = db.Column(db.String(length=2), default='en') created_at = Column(db.DateTime(timezone=True), nullable=False, default=maya.now().datetime) last_seen = db.Column(db.DateTime(timezone=True)) last_message_read_time = db.Column(db.DateTime(timezone=True)) notifications = db.relationship('Notification', backref='user', lazy='dynamic') tasks = db.relationship('Task', backref='user', lazy='dynamic') messages = db.relationship('Message', back_populates='user', lazy='dynamic') def __init__(self, username: str, email: str, password: str = None, **kwargs) -> None: """Create instance.""" db.Model.__init__(self, username=username, email=email, **kwargs) if password: self.set_password(password) else: self.password = None def set_password(self, password: str) -> None: """Set password.""" self.password = bcrypt.generate_password_hash(password) def check_password(self, value: str) -> bool: """Check password.""" is_good_password: bool = bcrypt.check_password_hash( self.password, value) return is_good_password @property def full_name(self) -> str: """Full user name.""" return '{0} {1}'.format(self.first_name, self.last_name) def __repr__(self) -> str: """Represent instance as a unique string.""" return '<User({username!r})>'.format(username=self.username) def get_reset_password_token(self, expires_in: int = 600) -> str: token: str = jwt.encode( { 'reset_password': self.id, 'exp': time() + expires_in }, current_app.config['SECRET_KEY'], algorithm='HS256') return token @staticmethod def verify_reset_password_token(token) -> Union['User', None]: try: user_id = jwt.decode(token, current_app.config['SECRET_KEY'], algorithms=['HS256'])['reset_password'] except InvalidTokenError: return None user: User = User.query.get(user_id) return user def confirm_email(self) -> None: self.email_confirmed = True self.email_confirmed_at = maya.now().datetime() def get_confirmation_token(self) -> str: token: str = jwt.encode({'confirm_email': self.id}, current_app.config['SECRET_KEY'], algorithm='HS256') return token @staticmethod def verify_confirmation_token(token: str) -> Union['User', None]: try: user_id = jwt.decode(token, current_app.config['SECRET_KEY'], algorithms=['HS256'])['confirm_email'] except PyJWTError: return None user: User = User.query.get(user_id) return user def avatar(self, size): digest = md5(self.email.lower().encode('utf-8')).hexdigest() return 'https://www.gravatar.com/avatar/{}?d=identicon&s={}'.format( digest, size) def add_notification(self, name, data): notification = self.notifications.filter_by(user=self, name=name).first() if notification: notification.update(payload=data) else: notification = Notification.create(name=name, payload=data, user=self) return notification def launch_task(self, name, description, *args, **kwargs): rq_job = current_app.task_queue.enqueue('app.task.tasks.' + name, *args, **kwargs) task = Task(id=rq_job.get_id(), name=name, description=description, user=self) db.session.add(task) return task def get_tasks_in_progress(self): return Task.query.filter_by(user=self, complete=False).all() def get_task_in_progress(self, name): return Task.query.filter_by(user=self, name=name, complete=False).first() def add_message(self, contents): message = Message.create(user=self, body=contents) return message def new_messages(self): last_read_time = self.last_message_read_time or maya.when( '1900-1-1').datetime() return Message.query.filter_by(user=self).filter( Message.timestamp > last_read_time).count()
class User(CRUDMixin, UserMixin, db.Model): id = db.Column(db.Integer, primary_key=True) username = db.Column(db.String(20), nullable=False, unique=True) email = db.Column(db.String(128), nullable=False, unique=True) pw_hash = db.Column(db.Binary(60)) created_ts = db.Column( db.DateTime(timezone=True), server_default=db.func.current_timestamp(), ) updated_ts = db.Column( db.DateTime(timezone=True), onupdate=db.func.current_timestamp(), ) remote_addr = db.Column(db.String(20)) active = db.Column(db.Boolean()) is_admin = db.Column(db.Boolean()) def __init__(self, username, email, remote_addr, password=None, active=False, is_admin=False): self.username = username self.email = email if password is not None: self.set_password(password) else: self.pw_hash = None self.created_ts = datetime.datetime.now() self.remote_addr = remote_addr self.active = active self.is_admin = is_admin def __repr__(self): return '<User %s>' % self.username def set_password(self, password): self.pw_hash = bcrypt.generate_password_hash(password, 10) def check_password(self, password): return bcrypt.check_password_hash(self.pw_hash, password) @classmethod def stats(self): active_users = cache.get('active_users') if not active_users: active_users = self.query.filter_by(active=True).count() cache.set('active_users', active_users) inactive_users = cache.get('inactive_users') if not inactive_users: inactive_users = self.query.filter_by(active=False).count() cache.set('inactive_users', inactive_users) return { 'all': active_users + inactive_users, 'active': active_users, 'inactive': inactive_users } @classmethod def getUserInfo(self, user_id): user = self.query.filter_by(id=user_id).first_or_404() return user @classmethod def getUserID(self, email): try: user = self.query.filter_by(email=email).one() return user.id except: return None
class User(Model, SurrogatePK, UserMixin, ModelCacheMixin): """user model""" __tablename__ = 'users' username = db.Column(db.String(32), unique=True, index=True, nullable=False) # username password_hash = db.Column(db.String(128)) email = db.Column(db.String(128), default="") # Email phone = db.Column(db.String(32), default="") # sex = db.Column( # db.Enum(SexEnum, # values_callable=enum_value_cb # ), default=SexEnum.empty) sex = db.Column(db.String(8), default="") active = db.Column(db.Boolean(), default=True) nickname = db.Column(db.String(32), default="") # 昵称 avatar_hash = db.Column(db.String(32)) # 头像hash值 current_login_datetime = db.Column(db.DateTime, default=None) # 本次登录时间 last_login_datetime = db.Column(db.DateTime, default=None) # 上次登录时间 last_login_ip = db.Column(db.String(32), default="") # 上次登录IP current_login_ip = db.Column(db.String(32), default="") # 当前登录IP create_datetime = db.Column(db.DateTime, nullable=False, default=dt.datetime.now) # 创建(注册)时间 api_key = db.Column(db.String(128)) roles = db.relationship('Role', secondary='user_roles', backref=db.backref('users', lazy='dynamic')) def __repr__(self): return '<%s %r>'.format(self.__class__.__name__, self.username) @property def password(self): return self.password_hash @password.setter def password(self, password): """设置密码hash 使用了 flask-user 则不能进行加密, 因为 flask-user 设置密码之前已经加密了 flask-user usage: ``` user.password = User.gen_password("password") ``` """ # for flask-user self.password_hash = password # for werkzeug # self.password_hash = generate_password_hash(password) @staticmethod def gen_password(password): """ 为非注册的用户生成密码hash """ from app import user_manager return user_manager.password_manager.hash_password(password) def verify_password(self, password): """验证密码""" # from app import user_manager return user_manager.password_manager.verify_password( password, self.password_hash) # for werkzeug # return check_password_hash(self.password_hash, password) def gravatar(self, size=100, default='identicon', rating='g'): """生成头像""" if request.is_secure: url = 'https://secure.gravatar.com/avatar' else: url = 'http://www.gravatar.com/avatar' hash = self.avatar_hash or hashlib.md5( self.username.encode('utf-8')).hexdigest() return '{url}/{hash}?s={size}&d={default}&r={rating}'.format( url=url, hash=hash, size=size, default=default, rating=rating) def login_info_update(self, commit=True): """登录信息更新""" # import datetime as dt # from flask import request self.last_login_datetime = self.current_login_datetime self.current_login_datetime = dt.datetime.now() self.last_login_ip = self.current_login_ip if request: self.current_login_ip = request.remote_addr db.session.add(self) if commit: db.session.commit() def to_dict(self, has_token=True): data = { "id": self.id, "username": self.username, "password_hash": self.password_hash, "email": self.email, "phone": self.phone, # "sex": repr(self.sex), "sex": self.sex, "active": self.active, "nickname": self.nickname, "create_datetime": self.create_datetime, "avatar": self.gravatar(), "roles": [role.name for role in self.roles], } if has_token: data.update({"token": self.generate_token()}) return data def generate_token(self, expiration=60 * 60): """生成access token""" s = Serializer(current_app.config["SECRET_KEY"], expiration) # 把 id、username、roles 放进 token token = s.dumps({ "id": self.id, "username": self.username, "roles": [role.name for role in self.roles] }).decode() return token @staticmethod def verify_token(token): """验证token """ s = Serializer(current_app.config["SECRET_KEY"]) try: data = s.loads(token) except SignatureExpired: raise TokenTimeOutException except Exception: return None return data def gen_apikey(self): self.api_key = gen_salt(128) return self.api_key
class VSProject(CRUDMixin, db.Model): """" 项目模型 """ __tablename__ = 'tbl_vsppm_project' id = db.Column(db.Integer, primary_key=True, autoincrement=True) # 名称 name = db.Column(db.String(90), nullable=False, unique=True) # 开始日期 begin = db.Column(db.Date()) # 结束日期 end = db.Column(db.Date()) # 项目类型 type = db.Column(db.String(20), default='sprint') # 历时天数 days = db.Column(db.Integer) # 状态 status = db.Column(db.String(30), default='wait') # 描述 desc = db.Column(db.String(256)) # 公司id company_id = db.Column(db.Integer, db.ForeignKey('tbl_vsppm_company.id')) # 部门id department_id = db.Column(db.Integer, db.ForeignKey('tbl_vsppm_department.id')) # 项目开启者 opened_by_id = db.Column(db.Integer, db.ForeignKey('tbl_vsppm_user.id')) # 项目开启日期 opened_datetime = db.Column(db.DateTime(timezone=True)) # 项目关闭者 closed_by_id = db.Column(db.Integer, db.ForeignKey('tbl_vsppm_user.id')) # 项目关闭日期 closed_datetime = db.Column(db.DateTime(timezone=True)) # 项目取消者 canceled_by_id = db.Column(db.Integer, db.ForeignKey('tbl_vsppm_user.id')) # 项目取消日期 canceled_datetime = db.Column(db.DateTime(timezone=True)) # 项目管理员id manager_admin_id = db.Column(db.Integer, db.ForeignKey('tbl_vsppm_user.id')) # 测试管理员id test_admin_id = db.Column(db.Integer, db.ForeignKey('tbl_vsppm_user.id')) # 发布管理员id release_admin_id = db.Column(db.Integer, db.ForeignKey('tbl_vsppm_user.id')) # 需求管理员id require_admin_id = db.Column(db.Integer, db.ForeignKey('tbl_vsppm_user.id')) access = db.Column(db.String(20), default='open') # 创建时间 created_ts = db.Column(db.DateTime(timezone=True), default=datetime.datetime.utcnow) # 更新时间 updated_ts = db.Column(db.DateTime(timezone=True), default=datetime.datetime.utcnow) # 激活状态 active = db.Column(db.Boolean(), default=True) # http://docs.sqlalchemy.org/en/rel_0_9/orm/join_conditions.html#handling-multiple-join-paths opened_by = db.relationship('VSUser', foreign_keys=[opened_by_id]) closed_by = db.relationship('VSUser', foreign_keys=[closed_by_id]) canceled_by = db.relationship('VSUser', foreign_keys=[canceled_by_id]) manager_admin = db.relationship('VSUser', foreign_keys=[manager_admin_id]) test_admin = db.relationship('VSUser', foreign_keys=[test_admin_id]) release_admin = db.relationship('VSUser', foreign_keys=[release_admin_id]) require_admin = db.relationship('VSUser', foreign_keys=[require_admin_id]) # 项目成员 members = db.relationship('VSUser', secondary=vsppm_project_member, backref=db.backref('projects')) company = db.relationship('VSCompany', backref=db.backref('projects')) department = db.relationship('VSDepartment', backref=db.backref('projects')) def __init__(self, **kwargs): super(VSProject, self).__init__(**kwargs) def __repr__(self): return '<VSProject #%s:%r>' % (self.id, self.name)
class VSUser(CRUDMixin, db.Model): """" 账户模型 """ __tablename__ = 'tbl_vsppm_user' id = db.Column(db.Integer, primary_key=True, autoincrement=True) # 账户名称 username = db.Column(db.String(20), nullable=False, unique=True) # 邮箱 email = db.Column(db.String(128), nullable=False, unique=True) # 手机号码 mobile = db.Column(db.String(11)) # 密码 password = db.Column(db.String(60), nullable=False) # 真实姓名 real_name = db.Column(db.String(100), nullable=False) # 头像 avatar = db.Column(db.String(256)) # 公司id company_id = db.Column(db.Integer, db.ForeignKey('tbl_vsppm_company.id')) # 部门id department_id = db.Column(db.Integer, db.ForeignKey('tbl_vsppm_department.id')) # 角色id role_id = db.Column(db.Integer, db.ForeignKey('tbl_vsppm_role.id')) # 创建时间 created_ts = db.Column(db.DateTime(timezone=True), default=datetime.datetime.utcnow) # 更新时间 updated_ts = db.Column(db.DateTime(timezone=True), default=datetime.datetime.utcnow) # 激活状态 active = db.Column(db.Boolean(), default=True) # 第一个参数为你要关系到哪个模型的名字,也就是类名 # db.backref('users')第一个参数users为要反向引用的名字,也可以用其他名字 # 正向引用是VSUser访问VSCompany,反向引用是从VSCompany访问表VSUser company = db.relationship('VSCompany', backref=db.backref('users')) # 第一个参数为你要关系到哪个模型的名字,也就是类名 # db.backref('users')第一个参数users为要反向引用的名字,也可以用其他名字 # 正向引用是VSUser访问VSDepartment,反向引用是从VSDepartment访问表VSUser department = db.relationship('VSDepartment', backref=db.backref('users')) # 让VSUser和VSRole产生关联 # 因为VSUser和VSRole表中间还有一个vsppm_user_role表,所以添加secondary # 正向引用是VSUser访问VSRole,反向引用是从VSRole访问表VSUser role = db.relationship('VSRole', backref=db.backref('users')) def __init__(self, password, **kwargs): super(VSUser, self).__init__(**kwargs) self.set_password(password) def __repr__(self): return '<VSUser #%s:%r>' % (self.id, self.username) def set_password(self, password): hash_ = bcrypt.generate_password_hash(password, 10).decode('utf-8') self.password = hash_ def check_password(self, password): return bcrypt.check_password_hash(self.password, password) def generate_token(self): """" :return bool: function exec result str: function exec data """ payload = { 'exp': datetime.datetime.utcnow() + datetime.timedelta(days=0, seconds=36000), 'iat': datetime.datetime.utcnow(), 'iss': 'ken', 'data': { 'username': self.username, 'password': self.password } } return JwtEncoder().encoder(payload=payload)
class User(db.Model, UserMixin): """ Define the User class for table 'auth_user' with the following columns: guid varchar(64), unique identifier for the 'auth_type' auth_type user_auth_type, authentication type of user (NYC.ID or a federated identity provider) first_name varchar(64), first name of user middle_initial varchar(1), middle initial of user (single character) last_name varchar(64), last name of user email varchar(254), email address of user phone varchar(25), phone number of variable format email_validated boolean, has user has validated its email address? terms_of_use_accepted boolean, has the user accepted the latest terms of use? agency_ein varchar(3), foreign key to 'agency' table is_poc boolean, is the user an agency point of contact? is_admin boolean, is the user an administrator (member of DORIS library staff)? is_super boolean, is the user an all-powerful super user? Most fields are provided by NYC.ID Authentication Web Service SAML Assertion. The combination of "guid" and "auth_type" must be unique and therefore is used as a primary composite key. """ __tablename__ = "auth_user" # columns guid = db.Column(db.String(64), primary_key=True) auth_type = db.Column( enum_user_auth_type, primary_key=True ) # FIXME: not needed since only agency users can login first_name = db.Column(db.String(64), nullable=False) middle_initial = db.Column(db.String(1)) last_name = db.Column(db.String(64), nullable=False) email = db.Column(db.String(254), nullable=False, unique=True) phone = db.Column(db.String(25)) email_validated = db.Column(db.Boolean(), nullable=False, default=False) terms_of_use_accepted = db.Column(db.Boolean(), nullable=False, default=False) is_poc = db.Column(db.Boolean(), nullable=False, default=False) is_admin = db.Column(db.Boolean(), nullable=False, default=False) is_super = db.Column(db.Boolean(), nullable=False, default=False) # relationships registrations = db.relationship( "Registration", primaryjoin="and_(User.guid == Registration.user_guid, " "User.auth_type == Registration.user_auth_type)", back_populates="registrant", lazy="dynamic") submissions = db.relationship( "Document", primaryjoin="and_(User.guid == Document.user_guid, " "User.auth_type == Document.user_auth_type)", back_populates="submitter", lazy="dynamic") events = db.relationship("_Event", primaryjoin="and_(User.guid == _Event.user_guid, " "User.auth_type == _Event.user_auth_type)", back_populates="agent", lazy="dynamic") def __init__(self, guid, auth_type, first_name, middle_initial, last_name, email, email_validated, terms_of_use_accepted): self.guid = guid self.auth_type = auth_type self.first_name = first_name self.middle_initial = middle_initial self.last_name = last_name self.email = email self.email_validated = email_validated self.terms_of_use_accepted = terms_of_use_accepted def __repr__(self): return '<User "{}" ({}, {})>'.format(self.name, self.guid, self.auth_type, self.name) def get_id(self): """ Overrides UserMixin.get_id() """ return USER_ID_DELIMETER.join((self.guid, self.auth_type)) @property def registration(self): """ A user's latest registration, if any. """ return self.registrations.join("events").order_by( desc("timestamp")).first() @property def is_registered(self): """ Is the user's latest registration, if any, approved? """ return self.registration.is_approved if self.registration is not None else False @property def agency(self): """ A user's agency is determined by its latest approved registration, if any. """ if self.is_registered: return self.registration.agency @property def name(self): if self.middle_initial is not None: name = "{f} {m}. {l}".format(f=self.first_name.title(), m=self.middle_initial.upper(), l=self.last_name.title()) else: name = " ".join((self.first_name.title(), self.last_name.title())) return name