class Ticket(db.Model):
__tablename__ = "tickets"
id = db.Column(db.Integer(), primary_key=True)
title = db.Column(db.Unicode(50), nullable=False)
description = db.Column(db.Unicode(255), nullable=False)
status = db.Column(db.Enum(TicketStatus), nullable=False, index=True)
requester_id = db.Column(db.Integer(),
db.ForeignKey("users.id"),
nullable=False,
index=True)
assignee_id = db.Column(db.Integer(),
db.ForeignKey("users.id"),
nullable=True,
index=True)
create_date = db.Column(db.DateTime(), nullable=False, index=True)
# Relationships
requester = db.relationship("User",
back_populates="requested_tickets",
foreign_keys="Ticket.requester_id")
assignee = db.relationship("User",
back_populates="assigned_tickets",
foreign_keys="Ticket.assignee_id")
def __str__(self):
return f"{self.title} - {self.status} - {self.create_date}"
class Brand(db.Model):
__tablename__ = 'brands'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.Unicode(50), nullable=False)
country_code = db.Column(db.Unicode(2), nullable=False)
products = db.relationship('Product', backref='brand')
@property
def serialized(self):
return {
'id': self.id,
'name': self.name,
'country_code': self.country_code
}
@orm.validates('name')
def validate_name(self, key, name):
assert isinstance(name, str)
assert (len(name) > 0) and (len(name) <= 50)
return name
@orm.validates('country_code')
def validate_country_code(self, key, country_code):
assert isinstance(country_code, str)
assert (len(country_code) > 0) and (len(country_code) <= 2)
return country_code
class User(db.Model, UserMixin):
__tablename__ = 'users'
id = db.Column(db.Integer, primary_key=True)
# User authentication information (required for Flask-User)
email = db.Column(db.Unicode(255), nullable=False, server_default=u'', unique=True)
confirmed_at = db.Column(db.DateTime())
password = db.Column(db.String(255), nullable=False, server_default='')
# reset_password_token = db.Column(db.String(100), nullable=False, server_default='')
active = db.Column(db.Boolean(), nullable=False, server_default='0')
# User information
active = db.Column('is_active', db.Boolean(), nullable=False, server_default='0')
first_name = db.Column(db.Unicode(50), nullable=False, server_default=u'')
last_name = db.Column(db.Unicode(50), nullable=False, server_default=u'')
# Relationships
roles = db.relationship('Role', secondary='users_roles',
backref=db.backref('users', lazy='dynamic'))
def has_role(self, role):
for item in self.roles:
if item.name == 'admin':
return True
return False
def role(self):
print(self.roles)
for item in self.roles:
return item.name
def name(self):
return self.first_name + " " + self.last_name
class User(db.Model, UserMixin):
__tablename__ = 'users'
id = db.Column(db.Integer, primary_key=True)
# User authentication information (required for Flask-User)
email = db.Column(db.Unicode(255),
nullable=False,
server_default=u'',
unique=True)
email_confirmed_at = db.Column(db.DateTime())
password = db.Column(db.String(255), nullable=False, server_default='')
# reset_password_token = db.Column(db.String(100), nullable=False, server_default='')
active = db.Column(db.Boolean(), nullable=False, server_default='0')
# User information
active = db.Column('is_active',
db.Boolean(),
nullable=False,
server_default='0')
first_name = db.Column(db.Unicode(50), nullable=False, server_default=u'')
last_name = db.Column(db.Unicode(50), nullable=False, server_default=u'')
# Relationships
roles = db.relationship('Role',
secondary='users_roles',
backref=db.backref('users', lazy='dynamic'))
class CoMagicCall(db.Model):
__tablename__ = 'comagic_calls'
__humanname__ = 'Параметры звонков'
__order__ = 3
id = db.Column(db.Integer, primary_key=True, info={'verbose_name': 'Идентификатор звонка'})
account_id = db.Column(db.Integer, nullable=False, info={'verbose_name': 'Идентификатор подключенного аккаунта'})
call_id = db.Column(db.Integer, nullable=False, info={'verbose_name': 'Внутренний идентификатор звонка'})
finish_reason = db.Column(db.Unicode(128), nullable=False, info={'verbose_name': 'Причина окончания звонка'})
direction = db.Column(db.Unicode(16), nullable=False, info={'verbose_name': 'Направление звонка'})
call_source = db.Column(db.Unicode(32), nullable=False, info={'verbose_name': 'Источник звонка'})
is_lost = db.Column(db.Boolean, nullable=False, info={'verbose_name': 'Потерянный звонок'})
contact_phone_number = db.Column(db.Unicode(32), info={'verbose_name': 'Номер контакта'})
virtual_phone_number = db.Column(db.Unicode(16), info={'verbose_name': 'Виртуальный номер'})
visitor_id = db.Column(db.Unicode(16), info={'verbose_name': 'Идентификатор посетителя'})
visitor_session_id = db.Column(db.Unicode(16), info={'verbose_name': 'Идентификатор сессии посетителя'})
visitor_device = db.Column(db.Unicode(8), nullable=False, info={'verbose_name': 'Устройство пользователя'})
channel = db.Column(db.Unicode(16), info={'verbose_name': 'Канал'})
referrer = db.Column(db.Unicode(256), info={'verbose_name': 'Источник перехода'})
__table_args__ = (
db.Index('comagic_calls_idx_1', account_id),
db.Index('comagic_calls_idx_2', call_id),
)
def __repr__(self):
return '<CoMagicCall %r>' % self.id
class ClusterAnalysis(db.Model):
__tablename__ = 'cluster_analysis'
id = db.Column(db.Integer(), primary_key=True)
user_id = db.Column(db.Integer(),
db.ForeignKey('users.id', ondelete='CASCADE'))
data_id = db.Column(db.Integer(),
db.ForeignKey('users_data.id', ondelete='CASCADE'))
derived_data_id = db.Column(db.Integer())
project_id = db.Column(db.Integer(),
db.ForeignKey('projects.id', ondelete='CASCADE'))
name = db.Column(db.Unicode(255),
nullable=False,
server_default=u'',
unique=False)
cluster_type = db.Column(db.Unicode(30),
nullable=False,
server_default=u'',
unique=False)
created_at = db.Column(db.DateTime, default=datetime.datetime.utcnow)
params = db.Column(db.JSON)
project = db.relationship(Project,
backref=db.backref('cluster_analysis',
uselist=True,
cascade='delete,all'))
data = db.relationship(UserData,
backref=db.backref('cluster_analysis',
uselist=True,
cascade='delete,all'))
class User(UserMixin, db.Model):
__tablename__ = 'users'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
email = db.Column(db.String(64), unique=True, index=True)
name = db.Column(db.Unicode(128))
password_hash = db.Column(db.String(128))
social_id = db.Column(db.BIGINT)
social_type = db.Column(db.Unicode(64))
confirmed = db.Column(db.Boolean, default=False)
def __init__(self, **kwargs):
super(User, self).__init__(**kwargs)
@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) -> bool:
return check_password_hash(self.password_hash, password)
def to_json(self):
json_user = {
'email': self.username,
}
return json_user
def __repr__(self):
return '<User %r>' % self.name
class ApiKey(db.Model):
__tablename__ = 'api_keys'
id = db.Column(db.Unicode(255), primary_key=True, unique=True)
hash = db.Column(db.Unicode(255), nullable=False)
label = db.Column(db.Unicode(255), nullable=True)
user_id = db.Column(db.Integer(),
db.ForeignKey('users.id', ondelete='CASCADE'))
class Student(db.Model):
__tablename__ = 'student'
id = db.Column(db.Unicode(10), primary_key = True, unique = True)
name = db.Column(db.Unicode(1000))
gender = db.Column(db.Unicode(1000))
phone_number = db.Column(db.Unicode(1000))
class_number = db.Column(db.Unicode(1000))
native_place = db.Column(db.Unicode(1000))
email = db.Column(db.Unicode(1000))
department1 = db.Column(db.Unicode(1000))
department2 = db.Column(db.Unicode(1000))
skill = db.Column(db.UnicodeText)
former_job = db.Column(db.UnicodeText)
former_experience = db.Column(db.UnicodeText)
reason = db.Column(db.UnicodeText)
expection = db.Column(db.UnicodeText)
add_teams = db.Column(db.Unicode(20))
obey_swap = db.Column(db.Boolean)
turn_major = db.Column(db.Boolean)
def __repr__(self):
return '<name %r>' % self.name
class Child(db.Model):
__tablename__ = 'child'
__bind_key__ = 'soar'
id = db.Column(db.Integer, primary_key=True)
child_english_name = db.Column(db.Unicode(255))
child_chinese_name = db.Column(db.Unicode(255))
child_pinyin_name = db.Column(db.Unicode(255))
nickname = db.Column(db.Unicode(255))
sex = db.Column(db.Unicode(1))
birth_date = db.Column(db.DateTime)
abandonment_date = db.Column(db.DateTime)
program_entry_date = db.Column(db.DateTime)
program_departure_date = db.Column(db.DateTime)
program_departure_reason = db.Column(db.UnicodeText)
child_history = db.Column(db.UnicodeText)
medical_history = db.Column(db.UnicodeText)
child_notes = db.relationship('ChildNote')
# Association mapping
partners = db.relationship('ChildPartner', back_populates='child')
camps = db.relationship('ChildCamp', back_populates='child')
specialists = db.relationship('ChildAssessment', back_populates='child')
caregivers = db.relationship('ChildCaregiver', back_populates='child')
measurement_types = db.relationship('ChildMeasurement',
back_populates='child')
milestone_types = db.relationship('ChildMilestone', back_populates='child')
doctors = db.relationship('ChildDoctorVisit', back_populates='child')
medical_conditions = db.relationship('ChildMedicalCondition',
back_populates='child')
medications = db.relationship('ChildMedication', back_populates='child')
def __unicode__(self):
return self.child_english_name
class User(UserMixin, db.Model):
__tablename__ = 'user'
__bind_key__ = 'soar'
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.Unicode(255), unique=True, index=True)
password_hash = db.Column(db.Unicode(255))
is_admin = db.Column(db.Boolean(), default=False)
is_editor = db.Column(db.Boolean(), default=False)
#email = db.Column(db.Unicode(255))
#created = db.Column(db.DateTime)
def hash_password(self, password):
self.password_hash = unicode(pwd_context.hash(password), "utf-8")
def verify_password(self, password):
return pwd_context.verify(password, self.password_hash)
@property
def is_authenticated(self):
return True
@property
def is_active(self):
return True
@property
def is_anonymous(self):
return False
@property
def get_id(self):
return unicode(self.id)
class Color(db.Model):
"""
The Color model is a colection of all Colors appearing throughout all of the
Products in the database. Not all Products have a Color and some have more
than one Color. Color has an optional many-many relationship with the Product model.
Attributes:
id Integer numerical identifier for this model
name String name of the Color
hashcode String the hash value for the Color
num_products Integer number of products with this Color
"""
__tablename__ = 'color'
id = db.Column('id', db.Integer, primary_key=True, autoincrement=True)
name = db.Column('name', db.Unicode(255), nullable=False)
hashcode = db.Column('hashcode', db.Unicode(25), nullable=False)
num_products = db.Column('num_products', db.Integer, default=0)
def __init__(self, name, hashcode, num_products):
assert isinstance(name, str)
assert isinstance(hashcode, str)
assert isinstance(num_products, int) or num_products is None
self.name = name
self.hashcode = hashcode
self.num_products = num_products
def __repr__(self):
return '<Color %r>' % self.name
class Person(db.Model, ValidationMixin):
# auto keys
id = db.Column(db.Integer, primary_key=True)
utc_created = db.Column(db.DateTime, nullable=False, default=dt.utcnow())
utc_updated = db.Column(
db.DateTime, nullable=False, default=dt.utcnow(), onupdate=dt.utcnow())
# foreign keys
currency_id = db.Column(
db.Integer, db.ForeignKey(
'commodity.id', onupdate="CASCADE", ondelete="CASCADE"),
nullable=False)
currency = db.relationship(
'Commodity', lazy='joined',
backref=backref('people', cascade='all, delete'))
# other keys
first_name = db.Column(db.Unicode(64), nullable=False)
last_name = db.Column(db.Unicode(64), nullable=False)
email = db.Column(db.String(64), unique=True, nullable=False)
phone = db.Column(db.String(16))
birth_date = db.Column(db.Date)
monthly_income = db.Column(db.Float)
monthly_expenses = db.Column(db.Float)
marginal_tax_rate = db.Column(db.Float)
# validation
val.validates_email('email')
val.validates_constraints()
def __repr__(self):
return ('<Exchange(%r, %r)>' % (self.name, self.email))
def __str__(self):
return ('%s: %s' % (self.name, self.email))
class DeviceType(db.Model):
'''models.DeviceType(db.Model)'''
__tablename__ = 'device_types'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.Unicode(64), unique=True, index=True)
icon = db.Column(db.Unicode(64))
devices = db.relationship('Device', backref='type', lazy='dynamic')
@staticmethod
def insert_entries(data, verbose=False):
'''DeviceType.insert_entries(data, verbose=False)'''
yaml_file = os.path.join(current_app.config['DATA_DIR'], data, 'device_types.yml')
entries = load_yaml(yaml_file=yaml_file)
if entries is not None:
print('---> Read: {}'.format(yaml_file))
for entry in entries:
device_type = DeviceType(
name=entry['name'],
icon=entry['icon']
)
db.session.add(device_type)
if verbose:
print('导入设备类型信息', entry['name'], entry['icon'])
db.session.commit()
else:
print('文件不存在', yaml_file)
def __repr__(self):
return '<Device Type {}>'.format(self.name)
class Tester(UserMixin, db.Model):
__tablename__ = "tester"
# id is used for flask.login
id = db.Column(db.Integer, primary_key=True)
Email = db.Column(db.String(32), unique=True, nullable=False)
Password = db.Column(db.String(32), nullable=False)
Name = db.Column(db.Unicode(64), nullable=False)
Role = db.Column(db.String(1), nullable=False)
Address = db.Column(db.Unicode(64))
Contacts = db.Column(db.Unicode(16), nullable=False)
Telephone = db.Column(db.String(16), nullable=False)
RegTime = db.Column(db.DateTime, nullable=False)
LogCount = db.Column(db.Integer) # for login limitation
LogTime = db.Column(db.DateTime)
# new for Tester
HasCMA = db.Column(db.Boolean, nullable=False)
CMAStart = db.Column(db.DateTime)
CMAEnd = db.Column(db.DateTime)
CMAPath = db.Column(db.String(64))
HasCNAS = db.Column(db.Boolean, nullable=False)
CNASStart = db.Column(db.DateTime)
CNASEnd = db.Column(db.DateTime)
CNASPath = db.Column(db.String(64))
HasCert = db.Column(db.Boolean, nullable=False)
CertStart = db.Column(db.DateTime)
CertEnd = db.Column(db.DateTime)
CertPath = db.Column(db.String(64))
TestRange = db.Column(db.String(64))
EstbTime = db.Column(db.DateTime)
RegTime = db.Column(db.DateTime, nullable=False)
IsChecked = db.Column(db.Boolean, nullable=False)
CheckName = db.Column(db.Unicode(64))
CheckTime = db.Column(db.DateTime)
class Thread(db.Model):
__tablename__ = 'Thread'
id = db.Column(db.Integer, primary_key=True)
title = db.Column(db.Unicode(255), nullable=False)
body = db.Column(db.UnicodeText, nullable=True)
date_created = db.Column(db.DateTime, nullable=False, default=datetime.now())
created_by = db.Column(db.Integer, ForeignKey(User.id))
user = relationship(User, backref='threads')
role_id = db.Column(db.Integer, ForeignKey(Role.id))
role = relationship(Role, backref='threads')
display_hash = db.Column(db.Unicode(255), nullable=False, unique=True)
display_name = db.Column(db.Unicode(255), nullable=True)
nsfw = db.Column(db.Boolean, nullable=False, default=False)
last_updated = db.Column(db.DateTime, nullable=False)
def __init__(self, title=None, body=None, category_id=None, display_name=None):
self.title = title
self.body = body
self.category_id = category_id
self.display_name = display_name
self.display_hash = custom_uuid()
self.last_updated = self.date_created
def __repr__(self):
return u'<Thread %r>' % (self.title)
def slug(self):
""" Generates an ASCII-only slug. """
result = []
for word in _punct_re.split(self.title.lower()):
result.extend(unidecode(word).split())
return unicode(u'-'.join(result))
class UserData(db.Model):
__tablename__ = 'users_data'
id = db.Column(db.Integer(), primary_key=True)
user_id = db.Column(db.Integer(),
db.ForeignKey('users.id', ondelete='CASCADE'))
project_id = db.Column(db.Integer(),
db.ForeignKey('projects.id', ondelete='CASCADE'))
name = db.Column(db.Unicode(255),
nullable=False,
server_default=u'',
unique=False)
description = db.Column(db.Unicode(2055),
nullable=False,
server_default=u'',
unique=False)
path = db.Column(db.Unicode(255),
nullable=False,
server_default=u'',
unique=False)
fname = db.Column(db.Unicode(255),
nullable=False,
server_default=u'',
unique=False)
sname = db.Column(db.Unicode(255),
nullable=False,
server_default=u'',
unique=False)
num_rows = db.Column(db.Integer(), nullable=False, unique=False)
num_cols = db.Column(db.Integer(), nullable=False, unique=False)
stats = db.Column(db.JSON)
uploaded_at = db.Column(db.DateTime, default=datetime.datetime.utcnow)
project = db.relationship(Project,
backref=db.backref('users_data',
uselist=True,
cascade='delete,all'))
class Product(UserMixin, db.Model):
"""
Create a Quotation table
"""
__tablename__ = 'products'
p_id = db.Column('ProductID', db.Integer, primary_key=True)
p_number = db.Column('Part Number', db.String(50), unique=True, nullable=False)
p_name = db.Column('ProductName', db.String(50))
unit_price = db.Column('UnitPrice', db.Float)
p_note = db.Column('Product Note to show', db.String(200))
cost_native = db.Column('Cost Native', db.Float)
exchange_rate = db.Column('Exchange Rate used', db.Float)
unit_cost = db.Column('Unit Cost', db.Float)
supplier = db.Column('Supplier', db.String(50))
p_category = db.Column('Product Category', db.String(50))
p_status = db.Column('Product Status', db.String(50))
date_created = db.Column('Date Created', db.Date)
person_created = db.Column('Person Created', db.String(50))
remarks = db.Column('Remarks', db.String(50))
japanese_p_name = db.Column('Japanese ProductName', db.Unicode(200, collation='utf8_bin'))
japanese_unit_price = db.Column('Japanese UnitPrice', db.Float)
japanese_note = db.Column('Japanese Note to show', db.Unicode(200, collation='utf8_bin'))
quote_details = db.relationship('Quotation_Detail', backref='product',
lazy='dynamic')
def __repr__(self):
return '<Product: {}>'.format(self.p_id)
def get_id(self):
return (self.p_id)
class User(db.Model, UserMixin):
__tablename__ = 'users'
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.Unicode(255),
nullable=False,
server_default=u'',
unique=True,
index=True)
password = db.Column(db.String(255), nullable=False, server_default='')
role = db.Column(db.Enum(RolesAvailable))
email = db.Column(db.Unicode(255),
nullable=False,
server_default=u'',
unique=True,
index=True)
created_at = db.Column(db.DateTime,
nullable=False,
default=datetime.utcnow)
updated_at = db.Column(db.DateTime,
nullable=False,
default=datetime.utcnow,
onupdate=datetime.utcnow)
def __init__(self, username, password, role, email):
self.username = username
self.password = generate_password_hash(password)
user_role = role
if user_role:
self.role = user_role
else:
self.role = RolesAvailable.member
self.email = email
class Light(db.Model):
__tablename__ = 'light'
id = db.Column(db.Integer(), primary_key=True, autoincrement=True)
name = db.Column(db.Unicode(64), nullable=False, index=True)
x_pos = db.Column(db.Integer(), nullable=False)
y_pos = db.Column(db.Integer(), nullable=False)
color = db.Column(db.Unicode(16))
class Image(db.Model):
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.Unicode(64))
path = db.Column(db.Unicode(128))
def __unicode__(self):
return self.name
class EffectGroup(db.Model):
__tablename__ = 'effect_group'
id = db.Column(db.Integer(), primary_key=True, autoincrement=True)
name = db.Column(db.Unicode(64), nullable=False, index=True)
color = db.Column(
db.Unicode(16),
nullable=False,
default=lambda: random.choice(Color.ALL_COLORS_NAMES[1:]) + ':4',
server_default='PINK:4')
effects = db.relationship('effect_to_effect_group',
cascade='all,delete-orphan')
# For WTForms
@property
def raw_color(self):
return self.color.split(':')[0] or 'OFF'
@property
def color_intensity(self):
try:
return int(self.color.split(':')[1])
except:
return 4
def play(self, bpm, bpmeasure=None):
for effect_info in self.effects:
# color, intensity = self.color.split(':')
lights = [
effect_info.lights
] if effect_info.lights == '*' else list(
map(lambda v: v.strip(), effect_info.lights.split(',')))
duration = effect_info.effect.duration_to_seconds(
bpm, bpmeasure=bpmeasure)
yield ('effect' if duration else
'state'), lights, duration, effect_info.effect
class User(db.Model, UserMixin):
__tablename__ = 'users'
id = db.Column(db.Integer, primary_key=True)
# User authentication information (required for Flask-User)
email = db.Column(db.Unicode(255),
nullable=False,
server_default=u'',
unique=True)
confirmed_at = db.Column(db.DateTime())
password = db.Column(db.String(255), nullable=False, server_default='')
# reset_password_token = db.Column(db.String(100), nullable=False, server_default='')
active = db.Column(db.Boolean(), nullable=False, server_default='0')
# User information
active = db.Column('is_active',
db.Boolean(),
nullable=False,
server_default='0')
first_name = db.Column(db.Unicode(50), nullable=False, server_default=u'')
last_name = db.Column(db.Unicode(50), nullable=False, server_default=u'')
ph_no = db.Column(db.Unicode(12), nullable=False, server_default=u'')
medicines = db.relationship('UserMedicine',
backref='user',
cascade="all, delete-orphan",
lazy='dynamic')
class User(db.Model):
__tablename__ = 'user'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.Unicode(256), nullable=False, unique=True, index=True)
password = db.Column(db.Unicode(64), nullable=False)
salt = db.Column(db.Unicode(255), nullable=False)
class User(db.Model, UserMixin):
__tablename__ = "users"
id = db.Column(db.Integer, primary_key=True)
# User authentication information (required for Flask-User)
email = db.Column(db.Unicode(255),
nullable=False,
server_default=u"",
unique=True)
email_confirmed_at = db.Column(db.DateTime())
password = db.Column(db.String(255), nullable=False, server_default="")
# reset_password_token = db.Column(db.String(100), nullable=False, server_default='')
active = db.Column(db.Boolean(), nullable=False, server_default="0")
# User information
active = db.Column("is_active",
db.Boolean(),
nullable=False,
server_default="0")
first_name = db.Column(db.Unicode(50), nullable=False, server_default=u"")
last_name = db.Column(db.Unicode(50), nullable=False, server_default=u"")
# Relationships
roles = db.relationship("Role",
secondary="users_roles",
backref=db.backref("users", lazy="dynamic"))
requested_tickets = db.relationship("Ticket",
back_populates="requester",
foreign_keys="Ticket.requester_id")
assigned_tickets = db.relationship("Ticket",
back_populates="assignee",
foreign_keys="Ticket.assignee_id")
class Board(db.Model):
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.Unicode(255))
trello_id = db.Column(db.Unicode(127))
def __repr__(self):
return '<Board %r>' % self.body
class Role(db.Model):
__tablename__ = 'roles'
id = db.Column(db.Integer(), primary_key=True)
description = db.Column(db.Unicode(255), nullable=True, server_default=u'')
name = db.Column(db.String(50), nullable=True,
unique=True) # for @roles_accepted()
label = db.Column(db.Unicode(255), nullable=False,
server_default=u'') # for display purposes
class Video(db.Model):
id = db.Column(db.Integer, primary_key=True)
title = db.Column(db.Unicode(64))
embed_code = db.Column(db.Unicode(1528))
img = db.Column(db.Unicode(128))
def __repr__(self):
return self.title
class Media(db.Model):
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
title = db.Column(db.Unicode(300))
content = db.Column(db.Text)
media_type = db.Column(db.Unicode(300))
fiction_id = db.Column(db.Integer, db.ForeignKey('fiction.id'))
author_id = db.Column(db.Integer, db.ForeignKey('author.id'))
user_id = db.Column(db.Integer, db.ForeignKey('user.id'))
class User(db.Model):
__tablename__ = "user"
id = db.Column(db.Integer, primary_key=True)
phone = db.Column(db.Unicode(16), nullable=False)
admin = db.Column(db.Boolean, default=False)
password = db.Column(db.Unicode(256), nullable=True)
user = db.relationship("Order", backref="user", lazy='dynamic')
