class Complaint(db.Model): id = db.Column(db.Integer, primary_key=True) merchant_id = db.Column(db.Integer, index=True) complaint_body = db.Column(db.String(20000)) expected_solution_body = db.Column(db.String(20000)) complain_type = db.Column(db.Enum(EnumComplaintType)) complaint_status = db.Column(db.Enum(EnumComplaintState)) audit_status = db.Column(db.Enum(EnumAuditState)) complain_timestamp = db.Column(db.DateTime, index=True, default=datetime.utcnow) user_id = db.Column(db.Integer, db.ForeignKey('user.id'), index=True) if_negotiated_by_merchant = db.Column(db.Boolean(), default=False) negotiate_timestamp = db.Column(db.DateTime, index=True) allow_public = db.Column(db.Boolean(), default=False) allow_contact_by_merchant = db.Column(db.Boolean(), default=False) allow_press = db.Column(db.Boolean(), default=False) item_price = db.Column(db.String(200)) item_model = db.Column(db.String(200)) trade_info = db.Column(db.String(20000)) relatedProducts = db.Column(db.String(5000)) purchase_timestamp = db.Column(db.DateTime, index=True) invoice_files = db.Column(JSONType) evidence_files = db.Column(JSONType)
class User(db.Model): __tablename__ = 'users' id = db.Column(db.Integer, primary_key=True) access_token = db.Column(db.String()) jit_feature = db.Column(db.Boolean()) recurrence_resch_feature = db.Column(db.Boolean()) streaks_feature = db.Column(db.Boolean()) in_line_comment_feature = db.Column(db.Boolean()) def __init__(self, id, access_token, jit_feature, recurrence_resch_feature, streaks_feature, in_line_comment_feature): self.id = id self.access_token = access_token self.jit_feature = jit_feature self.recurrence_resch_feature = recurrence_resch_feature self.streaks_feature = streaks_feature self.in_line_comment_feature = in_line_comment_feature def __repr__(self): return '<id {}, access token {}, jit feature {}, recurrence resch feature {}, streaks feature {}, in-line comment feature {}>'.\ format(self.id, self.access_token, self.jit_feature, self.recurrence_resch_feature, self.streaks_feature, self.in_line_comment_feature) def launch_task(self, name, description, *args, **kwargs): current_app.task_queue.enqueue('app.tasks.' + name, self.id, *args, **kwargs)
class Todo(db.Model): __tablename__ = 'todos' id = db.Column(db.Integer, autoincrement=True, primary_key=True) title = db.Column(db.String(20), nullable=False) description = db.Column(db.String(200), nullable=True) completed = db.Column(db.Boolean(), default=False) delayed = db.Column(db.Boolean(), default=False) created_at = db.Column(db.DateTime, nullable=False, default=dt.datetime.now) date_at = db.Column(db.DateTime, nullable=True) user_id = db.Column(db.Integer, db.ForeignKey('users.id')) @property def serialize(self): return { 'id': self.id, 'title': self.title, 'description': self.description, 'completed': self.completed, 'delayed': self.delayed, 'date_at': self.date_at, 'user_id': self.user_id } def __init__(self, title, description, date_at, user_id): self.title = title self.description = description self.user_id = user_id def __repr__(self): return f"<Todo {'%s','%s'}>" % (self.id, self.user_id)
class User(db.Model, UserMixin): __tablename__ = 'users' __table_args__ = {'extend_existing': True} id = db.Column(db.Integer, autoincrement=True, primary_key=True) email = db.Column(db.String(80), nullable=False, unique=True, index=True) username = db.Column(db.String(60), nullable=False) password = db.Column(db.String(128), nullable=False) active = db.Column(db.Boolean(), default=True) is_admin = db.Column(db.Boolean(), default=False) created_at = db.Column(db.DateTime, nullable=False, default=dt.datetime.now) #dt.datetime.utcnow last_seen = db.Column(db.DateTime, nullable=True, default=dt.datetime.now) todos = db.relationship('Todo', backref='tasks', lazy='dynamic') def __init__(self, username, email, password, **kwargs): self.username = username self.email = email self.password = generate_password_hash(password) def checkPassword(self, password): return check_password_hash(self.password, password) def __repr__(self): return f"<username={self.username}>"
class User(db.Model, SurrogatePK, UserMixin): """A user of the app.""" __tablename__ = 'user' username = db.Column(db.String(80), unique=True, nullable=False) email = db.Column(db.String(80), unique=True, nullable=False) #: The hashed password password = db.Column(db.String(), nullable=True) created_at = db.Column(db.DateTime, nullable=False, default=dt.datetime.utcnow) first_name = db.Column(db.String(30), nullable=True) last_name = db.Column(db.String(30), nullable=True) active = db.Column(db.Boolean(), default=True) is_admin = db.Column(db.Boolean(), default=False) user_group_id = reference_col('user_group') user_group = db.relationship('UserGroup', back_populates='users') # 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 '{0} {1}'.format(self.first_name, self.last_name) def __repr__(self): """Represent instance as a unique string.""" return '<User({username!r})>'.format(username=self.username)
class User(CURDMixin, UserMixin, db.Model): id = db.Column(db.Integer, primary_key=True) username = db.Column(db.String(20), nullable=False, unique=True) nickname = db.Column(db.String(64), server_default='无名氏') mobile = db.Column(db.String(128), nullable=True, unique=True) pw_hash = db.Column(db.String(120), nullable=False) created_at = db.Column( db.DateTime(), server_default=db.func.current_timestamp(), ) updated_at = db.Column( db.DateTime(), onupdate=db.func.current_timestamp(), ) remote_addr = db.Column(db.String(20)) is_active = db.Column(db.Boolean()) is_admin = db.Column(db.Boolean()) roles = db.relationship('Role', secondary=roles_users, backref=db.backref('users', lazy='dynamic')) list_columns = [ 'id', 'username', 'nickname', 'mobile', 'created_at', 'updated_at', 'roles' ] 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(cls): active_users = cache.get('active_users') if not active_users: active_users = cls.query.filter_by(is_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(is_active=False).count() cache.set('inactive_users', inactive_users) return { 'all': active_users + inactive_users, 'active': active_users, 'inactive': inactive_users }
class User(db.Model, UserMixin): __tablename__ = 'user' 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(100, collation='NOCASE'), nullable=False, unique=True) password = db.Column(db.String(255), nullable=False, server_default='') password_hash = db.Column(db.String(255), nullable=False, server_default='') email_confirmed_at = db.Column(db.DateTime()) # 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='')
class UserModel(db.Model, UserMixin): """ User Model for storing user related details """ __tablename__ = "user" __repr_attrs__ = ['username'] id = db.Column(db.Integer, primary_key=True) # User authentication information username = db.Column(db.String(50), nullable=False, unique=True) password = db.Column(db.String(255), nullable=False, server_default='') # User email information email = db.Column(db.String(255), nullable=False, unique=True) confirmed_at = db.Column(db.DateTime()) # User information active = db.Column('is_active', db.Boolean(), nullable=False, default=1) first_name = db.Column(db.String(100), nullable=False, server_default='') last_name = db.Column(db.String(100), nullable=False, server_default='') roles = db.relationship( RolesModel, secondary=users_roles_association, backref="users", lazy="dynamic" ) @classmethod def get(cls, uid): return cls.query.filter(cls.id == uid).first() def __str__(self): return "{last}, {first}".format( last=self.last_name, first=self.first_name )
class User(db.Model, UserMixin): __tablename__ = 'users' id = db.Column(db.Integer, primary_key=True) email = db.Column(db.Unicode(255), nullable=False, server_default=u'', unique=True) first_name = db.Column(db.String(40)) last_name = db.Column(db.Unicode(50), nullable=False, server_default=u'') active = db.Column('is_active', db.Boolean(), nullable=False, server_default='0', default=False) password_hash = db.Column(db.String(255), nullable=False, server_default='') last_login = db.Column(db.DateTime) is_admin = db.Column(db.Boolean, default=False) create_date = db.Column(db.DateTime, default=db.func.now()) @property def password(self): return self.password_hash @password.setter def password(self, password): self.password_hash = generate_password_hash(password) def check_password(self, password): return check_password_hash(self.password_hash, password) def __repr__(self): return '<User: {}>'.format(self.email)
class User(db.Model, UserMixin): def __init__(self, username, email, password, description=None, admin=None): self.username = username self.email = email self.password = pbkdf2_sha256.hash(password) self.description = description self.admin = admin 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) password = db.Column(db.String(60), nullable=False) description = db.Column(db.String()) image_file = db.Column(db.String(), default="default.jpg", nullable=False) last_seen = db.Column(db.String(), default=datetime.now().strftime("%d/%m/%y %H:%M:%S")) date_created = db.Column(db.String(), default=datetime.now().strftime("%d/%m/%y")) admin = db.Column(db.Boolean(), default=False, nullable=False) def verify_password(self, pwd): """ Verify actual password with hashed """ return pbkdf2_sha256.verify(pwd, self.password) def is_admin(self): """ Verify admin """ return self.admin def __repr__(self): return f"User('{self.username}','{self.password}')"
class User(UserJsonSerializer, UserMixin, db.Model): __tablename__ = 'users' id = db.Column(db.Integer, primary_key=True) username = db.Column(db.String(64), unique=True, index=True) email = db.Column(db.String(255), unique=True) mobile = db.Column(db.String(32), unique=True) password_hash = db.Column(db.String(128)) active = db.Column(db.Boolean()) 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) registered_at = db.Column(db.DateTime()) @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 __repr__(self): return '<User %r>' % self.username
class Codes(db.Model): __tablename__ = 't_codes' id = db.Column(db.Integer, primary_key=True, comment="主键id") code = db.Column(db.String(64), comment="代码") code_value = db.Column(db.String(660), comment="代码值") type = db.Column(db.String(20), comment="代码类型") revision = db.Column(db.Integer, comment="乐观锁") active = db.Column(db.Boolean(), comment="状态") created_by = db.Column(db.String(20), server_default="sys", comment="创建人") created_time = db.Column(db.DateTime, default=datetime.datetime.now, comment="创建时间") updated_by = db.Column(db.String(20), server_default="sys", comment="更新人") updated_time = db.Column(db.DateTime, default=datetime.datetime.now, onupdate=datetime.datetime.now, comment="更新时间") memo = db.Column(db.String(20), comment="备注") # 索引 __table_args__ = (UniqueConstraint("code", "type", name="code_code_type"), ) def to_dict(self): dict = { c.code_value: getattr(self, c.code_value, None) for c in self.__table__.columns } return dict
class User(db.Model, UserMixin): id = db.Column(db.Integer, primary_key=True) email = db.Column(db.String(255), 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'))
class USER(UserMixin, db.Model): # структура данных пользователей __tablename__ = 'USERS' id = db.Column(db.Integer, primary_key=True) email = db.Column(db.String, nullable=False, 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()) login = db.Column(db.String, nullable=True, unique=True) password_hash = db.Column(db.String, nullable=True) date_user_made = db.Column(db.String, nullable=True) family = db.Column(db.String, nullable=True) name = db.Column(db.String, nullable=True) second_name = db.Column(db.String, nullable=True) individual_key = db.Column(db.String, nullable=True) information = db.Column(db.String, nullable=True) rank = db.Column(db.Integer, nullable=True) events = db.relationship('EVENTS', backref='author', lazy='dynamic') role_events = db.relationship('RoleEvents', backref='RoleEventsUser', lazy='dynamic') roles = db.relationship('Role', secondary='roles_users', backref=db.backref('users', lazy='dynamic')) # def __init__(self, login, email, password, date_user_made): # self.login = login # self.email = email # self.password = password # self.date_user_made = date_user_made def __repr__(self): return '%d, %s, %s, %s' % (self.id, self.login, self.email, self.password_hash) 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)
class GenEmail(db.Model, ModelMixin): """Generated email""" user_id = db.Column(db.ForeignKey(User.id, ondelete="cascade"), nullable=False) email = db.Column(db.String(128), unique=True, nullable=False) enabled = db.Column(db.Boolean(), default=True, nullable=False) custom_domain_id = db.Column(db.ForeignKey("custom_domain.id", ondelete="cascade"), nullable=True) # To know whether an alias is created "on the fly", i.e. via the custom domain catch-all feature automatic_creation = db.Column(db.Boolean, nullable=False, default=False, server_default="0") # to know whether an alias belongs to a directory directory_id = db.Column(db.ForeignKey("directory.id", ondelete="cascade"), nullable=True) note = db.Column(db.Text, default=None, nullable=True) user = db.relationship(User) @classmethod def create_new(cls, user_id, prefix, note=None): if not prefix: raise Exception("alias prefix cannot be empty") # find the right suffix - avoid infinite loop by running this at max 1000 times for i in range(1000): suffix = random_word() email = f"{prefix}.{suffix}@{EMAIL_DOMAIN}" if not cls.get_by(email=email): break return GenEmail.create(user_id=user_id, email=email, note=note) @classmethod def create_new_random(cls, user_id, scheme: int = AliasGeneratorEnum.word.value, in_hex: bool = False): """create a new random alias""" random_email = generate_email(scheme=scheme, in_hex=in_hex) return GenEmail.create(user_id=user_id, email=random_email) def __repr__(self): return f"<GenEmail {self.id} {self.email}>"
class OAuth2Token(db.Model, OAuth2TokenMixin): __tablename__ = 'oauth2_token' id = db.Column(db.Integer, primary_key=True) user_id = db.Column( db.Integer, db.ForeignKey('user.id', ondelete='CASCADE')) user = db.relationship('User') revoked = db.Column(db.Boolean(name='revoked'), default=False) # override because of bug in alembic def is_refresh_token_expired(self): expires_at = self.issued_at + self.expires_in * 2 return expires_at < time.time()
class Task(db.Model): id = db.Column(db.Integer(), primary_key=True) title = db.Column(db.String(), nullable=False) description = db.Column(db.String(), nullable=False) created_at = db.Column(db.String(), default=datetime.utcnow()) deadline = db.Column(db.String()) priority = db.Column(db.Enum(priorityEnum), default="high") is_done = db.Column(db.Boolean(), default=False) category_id = db.Column(db.Integer(), db.ForeignKey("category.id")) def __repr__(self): return f"<Task-{self.id}\n \
class User(UserMixin, db.Model): __tablename__ = 'user' id = db.Column(db.Integer, primary_key=True) username = db.Column(db.String(64), index=True, unique=True, nullable=False) email = db.Column(db.String(120), index=True, unique=True, nullable=False) registered_date = db.Column(db.String(120)) if_verified = db.Column(db.Boolean()) is_founder = db.Column(db.Boolean()) real_name = db.Column(db.String(120)) sex = db.Column(db.Enum(EnumGender), nullable=False) minority = db.Column(db.String(120)) account_active = db.Column(db.Boolean()) first_name = db.Column(db.String(120)) urole = db.Column(db.String(140), default="normal") last_name = db.Column(db.String(120), nullable=False) password_hash = db.Column(db.String(128)) complaints = db.relationship(Complaint, backref='User') comments = db.relationship(Comment, backref='User') def __init__(self, username, sex, registered_date): self.username = username self.sex = sex self.registered_date = registered_date def __repr__(self): return '<User {}>'.format(self.username) 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 get_urole(self): return self.urole
class Jobsite(CRUD_Model, db.Model): __tablename__ = 'site' id = db.Column(db.Integer, autoincrement=True, primary_key=True) site = db.Column(db.String(100)) have_detail = db.Column(db.Boolean(), default=False) brief_id = db.Column(db.Integer, nullable=False)######################### #brief_id = db.Column(db.Integer, db.ForeignKey('brief.id')) #brief = db.relationship('Jobbrief', back_populates='job_link') def __repr__(self): return '<object Jobsite, id: {}>'.format(self.id)
class Indicator(db.Model): id = db.Column(db.Integer(), primary_key=True) name = db.Column(db.String(120), nullable=False, index=True) source = db.Column(db.JSON(), nullable=False) unit = db.Column(db.String(20), nullable=False, default='') aggregation = db.Column(db.String(80), default='average') is_deleted = db.Column(db.Boolean(), default=False, index=True, server_default=false()) product_id = db.Column(db.Integer(), db.ForeignKey('product.id'), nullable=False, index=True) slug = db.Column(db.String(120), nullable=False, index=True) targets = db.relationship('Target', backref=db.backref('indicator', lazy='joined'), lazy='dynamic') values = db.relationship('IndicatorValue', backref='indicator', lazy='dynamic', passive_deletes=True) username = db.Column(db.String(120), default='') created = db.Column(db.DateTime(), default=datetime.utcnow) updated = db.Column(db.DateTime(), onupdate=datetime.utcnow, default=datetime.utcnow) __table_args__ = (db.UniqueConstraint( 'name', 'product_id', 'is_deleted', name='indicator_name_product_id_key'), ) def get_owner(self): return self.product.product_group.name def __repr__(self): return '<SLI {} | {} | {}>'.format(self.product.name, self.name, self.source)
class User(db.Model, UserMixin): __tablename__ = 's_user' id = db.Column(db.Integer, primary_key=True) email = db.Column(db.String(50), unique=True) username = db.Column(db.String(50)) 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='s_roles_users', backref=db.backref('users', lazy='dynamic')) def __repr__(self): return self.username
class ScheduleDispatchItemModel(db.Model): __tablename__ = 'scheduled_items' __repr_attrs__ = ['name'] """ View information """ id = db.Column(db.Integer, primary_key=True) name = db.Column(db.String(80), unique=True, nullable=False) description = db.Column(db.Text) """ Housekeeping """ active = db.Column(db.Boolean(), nullable=False) date_created = db.Column(db.DateTime, default=datetime.datetime.utcnow()) last_active = db.Column(db.DateTime) """ Interval Information """ when_to_run = db.Column(db.String(1), default='D') start_time = db.Column(db.Time(), nullable=False) end_time = db.Column(db.Time, nullable=False) """ Activity by __tablename__""" what_to_run = db.Column(db.String) def __str__(self): return self.name
class User(db.Model, UserMixin): id = db.Column(db.Integer(), primary_key=True) username = db.Column(db.String(50), unique=True) email = db.Column(db.String(255), 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')) # 如果你配置了SECURITY_CONFIRMABLE=True,那么你的User模型需要添加以下字段: confirmed_at = db.Column(db.DateTime()) # 如果你配置了SECURITY_TRACKABLE=True,那么你的User模型需要添加以下字段: last_login_at = db.Column(db.DateTime()) current_login_at = db.Column(db.DateTime()) last_login_ip = db.Column(db.String(50)) current_login_ip = db.Column(db.String(50)) login_count = db.Column(db.BigInteger()) def __repr__(self): return "<User %s--%s>" % self.name
class User(Base, UserMixin): __tablename__ = 'user' __table_args__ = (db.CheckConstraint('email = lower(email)', 'lowercase_email'), ) username = db.Column(db.String(256), unique=True) email = db.Column(db.String, nullable=False, unique=True) password = db.Column(db.String(255), nullable=False) active = db.Column(db.Boolean(), default=True) confirmed_at = db.Column(db.DateTime()) has_auto_generated_password = db.Column(db.Boolean, default=False) avatar = db.Column(db.String(256)) roles = db.relationship('Role', secondary=roles_users, backref=db.backref('users', lazy='dynamic')) def __repr__(self): return '<User({}, {}, username={}): {}>'.format( self.id, self.username, self.email, self.is_authenticated)
class UserModel(db.Model, UserMixin): __tablename__ = 'users' id = db.Column(db.Integer, primary_key=True) username = db.Column(db.String(80)) password = db.Column(db.String(255)) is_active = db.Column(db.Boolean(), nullable=False, server_default='1') def __init__(self, username, password): self.username = username self.password = password def save(self): db.session.add(self) db.session.commit() # # @classmethod # def get_id(cls): # return str(cls.id) @classmethod def find_by_username(cls, username): return cls.query.filter_by(username=username).first() @classmethod def find_by_id(cls, _id): return cls.query.filter_by(id=_id).first() def authenticated(self, with_password=True, password=''): """ Ensure a user is authenticated, and optionally check their password. :param with_password: Optionally check their password :type with_password: bool :param password: Optionally verify this as their password :type password: str :return: bool """ if with_password: return check_password_hash(self.password, password)
class QueueBoard(db.Model, SurrogatePK): __tablename__ = 'queue_board' name = db.Column(db.String(80), unique=True, nullable=False) is_active = db.Column(db.Boolean(), nullable=False, default=True) # opened/closed schedule_id = db.Column(db.Integer(), db.ForeignKey('schedule.id')) schedule = db.relationship('QueueBoardSchedule', foreign_keys=schedule_id, back_populates='queue_board') # members json members = db.Column(MutableList.as_mutable(JSONB())) # mutation tracking # settings max_on_deck = db.Column(db.Integer(), default=0) max_allowed_break = db.Column(db.Integer(), default=0) next_break_wait_time = db.Column(db.Integer(), default=0) max_duration = db.Column(db.Integer(), nullable=False) def __repr__(self): """Represent instance as a unique string.""" return '<QueueBoard({name})>'.format(name=self.name)
class User(db.Model, UserMixin): id = db.Column(db.Integer, primary_key=True) email = db.Column(db.String(255), unique=True) name = db.Column(db.String(255)) 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')) 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(32)) current_login_ip = db.Column(db.String(32)) login_count = db.Column(db.Integer()) timezone = db.Column(db.String(64)) def get_tz(self): if self.timezone: return pytz.timezone(self.timezone) else: return app.config.get("DEFAULT_TIMEZONE", pytz.utc) def has_role(self, role): return role in self.roles def dict(self): """ A dictionary representation that can be used for JSON serialization """ return { "email": self.email, "active": self.active, "confirmed_at": api.serialize_date(self.confirmed_at), "timezone": self.timezone } def __str__(self): return self.name or self.email
class User(db.Model, UserMixin): __tablename__ = "users" # User auth keys are not stored in the db # Because catalyst utilzies auth files in the .catalyst directory # We can simply create auth files with the user ID and pass the file to the strategy id = db.Column(db.Integer, primary_key=True) active = db.Column("is_active", db.Boolean(), nullable=False, server_default="1") # User Authentication fields email = db.Column(db.String(255), nullable=False, unique=True) email_confirmed_at = db.Column(db.DateTime()) password = db.Column(db.String(255), nullable=False) telegram_id = db.Column(db.Integer, nullable=True, unique=True) telegram_username = db.Column(db.String(255), nullable=True, unique=True) telegram_photo = db.Column(db.String(), nullable=True, unique=False) telegram_auth_date = db.Column(db.Integer, nullable=True, unique=False) strategies = db.relationship("StrategyModel", backref="user", lazy=True) authenticated_exchanges = db.relationship("UserExchangeAuth", backref="user", lazy=True) # User information # first_name = db.Column(db.String(100), nullable=False, server_default='') # last_name = db.Column(db.String(100), nullable=False, server_default='') def unlink_telegram(self): self.telegram_id = None self.telegram_username = None self.telegram_photo = None self.telegram_auth_date = None db.session.add(self) db.session.commit()
class User(CRUD_Model, UserMixin, db.Model): __tablename__ = 'user' id = db.Column(db.Integer, autoincrement=True, primary_key=True) name = db.Column(db.String(30), unique=True, nullable=False) passwd_hash = db.Column(db.String(512), nullable=False) mail = db.Column(db.String(30), unique=True, nullable=False) focus = db.Column(db.String(100)) time = db.Column(db.DateTime(), default=datetime.now()) confirm = db.Column(db.Boolean(), default=False) ''' posts = db.relationship('Post', back_populates='author', lazy='dynamic') comments = db.relationship('Comment', back_populates='author', lazy='dynamic') sub_info = db.relationship('Subscribe', back_populates='user', lazy='dynamic') profile = db.relationship('Profile', back_populates='user', lazy='dynamic') ''' @property def password(self): return ('You can not access it!') @password.setter def password(self, num): self.passwd_hash = generate_password_hash(num) def verify_passwd(self, num): return check_password_hash(self.passwd_hash, num) def generate_token(self): s = Serializer(current_app.config['SECRET_KEY'], 600) return s.dumps({'id':self.id}) def decode_token(self, token): s = Serializer(current_app.config['SECRET_KEY'], 600) return s.loads(token) def __repr__(self): return '<object User, name: {}>'.format(self.name)
class User(db.Model, UserMixin): # default table name = class name __tablename__ = 'users' id = db.Column(db.Integer, primary_key=True) username = db.Column(db.String(64), unique=True, nullable=False) email = db.Column(db.String(64), unique=True, nullable=False, index=True) # add index password_hash = db.Column(db.String(255), nullable=False) is_admin = db.Column(db.Boolean(), default=False) # cascade delete albums from user, delete-orphan to kids for album albums = db.relationship('Album', backref='user', lazy='dynamic', cascade='all, delete-orphan') tours = db.relationship('Tour', backref='user', lazy='dynamic', cascade='all, delete-orphan') def __init__(self, username='', email='', password=''): self.username = username self.email = email self.password_hash = generate_password_hash(password) 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) @cache.memoize(timeout=180) # remember parameter def is_album_owner(self, album): # pure function, memorizing return self.id == album.user_id def is_tour_owner(self, tour): return self.id == tour.user_id def make_admin(self): self.is_admin = True def __repr__(self): return f'<User {self.username}>'