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}>'
