class Customer(db.Model, UserMixin):
id = db.Column(db.Integer, primary_key=True)
customer_id = db.Column(db.String(50), unique=True, nullable=False)
email = db.Column(db.String(80), unique=True)
password = db.Column(db.String(80), nullable=False)
name = db.Column(db.String(50), nullable=False)
contact_one = db.Column(db.String(20), nullable=False)
contact_two = db.Column(db.String(20))
admin = db.Column(db.Boolean, default=False)
const_house_no = db.Column(db.Text, nullable=False)
const_landmark = db.Column(db.Text, nullable=False)
const_locality = db.Column(db.Text, nullable=False)
const_city = db.Column(db.String(50), nullable=False)
const_state = db.Column(db.Text, nullable=False)
const_pincode = db.Column(db.Integer, nullable=False)
delivery_house_no = db.Column(db.Text, nullable=False)
delivery_landmark = db.Column(db.Text, nullable=False)
delivery_locality = db.Column(db.Text, nullable=False)
delivery_city = db.Column(db.String(50), nullable=False)
delivery_state = db.Column(db.Text, nullable=False)
delivery_pincode = db.Column(db.Integer, nullable=False)
latitude = db.Column(db.String(60), nullable=False,
default='00.00')
longitude = db.Column(db.String(60), nullable=False,
default='00.00')
device_id = db.Column(db.String(180), nullable=False,
default='key')
cart_items = db.relationship('Cart',
cascade='all,delete',
backref='customer_cart',
lazy=True)
fav_items = db.relationship('Favourites',
cascade='all,delete',
backref='customer_fav',
lazy=True)
class EventType(db.Model, BaseModel):
__bind_key__ = 'term'
__tablename__ = 'event_type'
id = db.Column(db.Integer, primary_key=True)
term_type = db.Column(db.Integer, db.ForeignKey('term.id'))
term = db.relationship('Term')
event_id = db.Column(db.Integer, db.ForeignKey('event.id'))
event = db.relationship('Event')
@staticmethod
def get_types(term_type=False):
if isinstance(term_type, (bool)):
return EventType.query.all()
return EventType.query.filter_by(term_type=term_type).all()
@staticmethod
def get_dict(term_type=False):
from models.event import Event
types = EventType.get_types(term_type)
events = Event.get_dict()
result = {}
for row in types:
result[row.event_id] = events[row.event_id]
return result
class ReferralToCourses(db.Model):
__tablename__ = "referral_to_courses"
referral_number = db.Column(db.Integer, primary_key=True)
proff_course_start_date = db.Column(db.Date, nullable=False)
proff_course_end_date = db.Column(db.Date, nullable=False)
sertificate = db.Column(db.Boolean, nullable=False)
personnel_number = db.Column(db.Integer,
db.ForeignKey('teacher.personnel_number',
onupdate="CASCADE",
ondelete="CASCADE"),
nullable=False)
teacher = db.relationship("Teacher", back_populates="referral_to_courses")
selective_course_date = db.relationship(
"SelectiveCourseDate", back_populates="referral_to_courses")
def __init__(self, referral_number, proff_course_start_date,
proff_course_end_date, sertificate, personnel_number):
self.referral_number = referral_number
self.proff_course_start_date = datetime.strptime(
proff_course_start_date, '%Y-%m-%d').date()
self.proff_course_end_date = datetime.strptime(proff_course_end_date,
'%Y-%m-%d').date()
self.sertificate = sertificate if sertificate else False
self.personnel_number = personnel_number
class User(UserMixin, db.Model):
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(64), index=True, unique=True)
email = db.Column(db.String(120), index=True, unique=True)
password_hash = db.Column(db.String(128))
ticker_per_page = db.Column(db.Integer, default=3)
activated = db.Column(db.Boolean, default=False)
tasks = db.relationship('Task', backref='user', lazy='dynamic')
subscriptions = db.relationship('TickerSubscription',
backref='user',
lazy='dynamic')
# followed = db.relationship(
# 'User', secondary=followers,
# primaryjoin=(followers.c.follower_id == id),
# secondaryjoin=(followers.c.followed_id == id),
# backref=db.backref('followers', lazy='dynamic'), lazy='dynamic')
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 __repr__(self):
return '<User {}>'.format(self.username)
class UserRoles(db.Model):
__tablename__ = 'user_roles'
id = db.Column(db.Integer(), primary_key=True)
user_id = db.Column(db.Integer(), db.ForeignKey('user.id', ondelete='CASCADE'))
user = db.relationship('User')
role_id = db.Column(db.Integer(), db.ForeignKey('role.id', ondelete='CASCADE'))
user = db.relationship('Role')
class User(UserMixin, db.Model):
__tablename__ = 'users'
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(64), index=True, unique=True)
email = db.Column(db.String(128), index=True, unique=True)
password_hash = db.Column(db.String(128))
language = db.Column(db.String(2), default='en')
credentials = db.relationship('AccountCredential',
backref='owner',
lazy='dynamic')
scan_profiles = db.relationship('ScanProfile',
backref='owner',
lazy='dynamic')
tasks = db.relationship('Task', backref='owner', lazy='dynamic')
results = db.relationship('TaskResult',
backref='owner',
lazy='dynamic',
order_by='desc(TaskResult.started)')
def set_password(self, password: str) -> None:
self.password_hash = generate_password_hash(password)
def check_password(self, password: str) -> bool:
return check_password_hash(self.password_hash, password)
def __repr__(self) -> str:
return f'User({self.username})'
class StudyGroup(db.Model):
__tablename__ = 'study_groups'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
start_date = db.Column(db.Date, nullable=False)
end_date = db.Column(db.Date, nullable=False)
name_format = db.Column(db.String(6), nullable=False)
elder_id = db.Column(db.Integer, db.ForeignKey('students.person_id'))
department_id = db.Column(db.Integer, db.ForeignKey('departments.id'), nullable=False)
students = db.relationship('Student', foreign_keys='Student.group_id', backref='group', uselist=True)
lessons = db.relationship('Lesson', backref='group', uselist=True)
def save(self):
db.session.add(self)
db.session.commit()
def format_name(self):
now = date.today()
if now < self.end_date:
return self.name_format.replace('*', str(now.year - self.start_date.year + 1))
else:
return '—'
def get_elder(self):
if self.elder_id is None:
return None
return Student.get(id=self.elder_id)
def get_lessons(self, week_day=None, is_week_even=None):
if week_day is None and is_week_even is None:
return sorted(self.lessons, key=lambda l: (l.week_day, l.start_time))
else:
lessons = self.lessons
if week_day is not None:
lessons = [l for l in lessons if l.week_day == week_day]
if is_week_even is not None:
lessons = [l for l in lessons if (l.on_even_week == 'u') or (l.on_even_week == is_week_even)]
return sorted(lessons, key=lambda l: (l.week_day, l.start_time))
@staticmethod
def get_all():
return StudyGroup.query.all()
@staticmethod
def get_by_name(name):
all = StudyGroup.query.all()
filtered = filter(lambda group: name == group.format_name(), all)
return list(filtered)
@staticmethod
def get(id=None, name_format=None, department_id=None):
if id is not None:
return StudyGroup.query.filter_by(id=id).first()
if name_format is not None:
return StudyGroup.query.filter_by(name_format=name_format).first()
if id is not None:
return StudyGroup.query.filter_by(department_id=department_id).all()
class AlarmStack(db.Model, BaseModel):
__bind_key__ = 'stack'
__tablename__ = 'alarm_stack'
DEFAULT_COUNT = 1
DEFAULT_INTERVAL = 86400
LOCK_FREE = 0
LOCK_SET = 1
id = db.Column(db.Integer, primary_key=True)
firm_id = db.Column(db.Integer, db.ForeignKey('firm.id'))
firm = db.relationship('Firm')
term_id = db.Column(db.Integer, db.ForeignKey('term.id'))
term = db.relationship('Term')
emails = db.Column(db.Text, nullable=False)
interval = db.Column(db.Integer, nullable=False)
count = db.Column(db.Integer, nullable=False)
lock = db.Column(db.Integer, index=True, nullable=False)
def __init__(self, firm_id=None, term_id=None):
self.lock = self.LOCK_FREE
self.interval = self.DEFAULT_INTERVAL
self.count = self.DEFAULT_COUNT
self.term_id = term_id
self.firm_id = firm_id
def get_term_alarm(self):
alarm = AlarmStack.query.filter_by(term_id=self.term_id,
firm_id=self.firm_id).first()
if not alarm:
alarm = self
m, s = divmod(alarm.interval, 60)
h, m = divmod(m, 60)
alarm.interval = "%d:%02d" % (h, m)
return alarm
@staticmethod
def reset_count(term_id):
result = False
alarm = AlarmStack.query.filter_by(term_id=term_id).first()
if not alarm:
return result
alarm.count = AlarmStack.DEFAULT_COUNT
if alarm.save():
result = True
return result
def save(self):
self.emails = self.encode_field(self.emails)
return BaseModel.save(self)
class EducationalOrganization(db.Model):
__tablename__ = 'edu_orgs'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
name = db.Column(db.String(132), nullable=False, unique=True)
short_name = db.Column(db.String(10), nullable=False)
departments = db.relationship('Department', backref='edu_org')
classrooms = db.relationship('Classroom', backref='edu_org')
def __init__(self, name, short_name):
self.name = name
self.short_name = short_name
def save(self):
db.session.add(self)
db.session.commit()
def get_department(self, name=None, short_name=None):
if name is not None:
name = name.lower()
filtered = filter(lambda d: d.name.lower() == name, self.departments)
elif short_name is not None:
short_name = short_name.lower()
filtered = filter(lambda d: d.short_name.lower() == short_name, self.departments)
filtered = list(filtered)
if len(filtered) > 1:
raise DepartmentIsNotUniqueException('More than one department for a educational organization with definite name')
elif len(filtered) == 1:
return filtered[0]
else:
return None
def get_classroom(self, name):
name = name.lower()
classrooms = filter(lambda c: c.get_name().lower() == name.lower(), self.classrooms)
classrooms = list(classrooms)
if len(classrooms) > 1:
raise ClassroomIsNotUniqueException('More than one group for a department with definite name')
elif len(classrooms) == 1:
return classrooms[0]
else:
return None
@staticmethod
def get_all():
return EducationalOrganization.query.all()
@staticmethod
def get(id=None, name=None, short_name=None):
if id is not None:
return EducationalOrganization.query.filter_by(id=id).first()
if name is not None:
return EducationalOrganization.query.filter_by(name=name).first()
if short_name is not None:
return EducationalOrganization.query.filter_by(short_name=short_name).all()
return None
class Task(db.Model):
__table_args__ = (db.UniqueConstraint('name', 'owner_id',
name='task_uniq'), )
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(64), index=True)
status = db.Column(
db.Enum(TaskStatus),
default=TaskStatus.Idle,
server_default=TaskStatus.Idle.name,
nullable=False,
)
uid = db.Column(db.String(128))
owner_id = db.Column(db.Integer,
db.ForeignKey('users.id',
name='task_fk',
ondelete='CASCADE'),
nullable=False)
settings = db.relationship('TaskSetting', backref='task', lazy='dynamic')
results = db.relationship('TaskResult',
backref='task',
lazy='dynamic',
order_by='TaskResult.started')
def to_list(self) -> List:
return [
dict(address=item.hostname, **item.profile.to_dict())
for item in self.settings
]
def update_status(self, status: TaskStatus):
if status == TaskStatus.Wait:
if self.status != TaskStatus.Idle:
return
self.status = TaskStatus.Wait
elif status == TaskStatus.Idle:
if self.uid is None:
self.status = TaskStatus.Idle
return
if self.status == TaskStatus.Idle:
return
self.status = TaskStatus.Idle
celery_task = AsyncResult(self.uid)
if celery_task:
CeleryControl(celery).revoke(self.uid, terminate=True)
self.uid = None
def __repr__(self):
return f'Task(name={self.name})'
class TermUserFirm(db.Model, BaseModel):
__bind_key__ = 'term'
__tablename__ = 'user_firm'
id = db.Column(db.Integer, primary_key=True)
user_id = db.Column(db.Integer, db.ForeignKey('term_user.id'))
user = db.relationship(
'TermUser',
primaryjoin="TermUser.id==TermUserFirm.user_id")
firm_id = db.Column(db.Integer, db.ForeignKey('firm.id'))
firm = db.relationship('Firm', primaryjoin="Firm.id==TermUserFirm.firm_id")
class RelUserProject(JsonSerializer, db.Model):
id = db.Column(db.Integer, primary_key=True)
user_id = db.Column(db.Integer, db.ForeignKey("users.id"))
project_id = db.Column(db.Integer, db.ForeignKey("projects.id"))
created_at = db.Column(db.DateTime, default=db.func.now())
updated_at = db.Column(db.DateTime, default=db.func.now(),
onupdate=db.func.now())
user = db.relationship("Users",
backref=db.backref("projects", lazy="dynamic"))
project = db.relationship("Projects",
backref=db.backref("users", lazy="dynamic"))
class TeacherSubject(db.Model):
__tablename__ = "teacher_subject"
subject_id = db.Column(db.Integer, db.ForeignKey('subject.subject_id', onupdate="CASCADE",
ondelete="NO ACTION"), primary_key=True)
personnel_number = db.Column(db.Integer, db.ForeignKey('teacher.personnel_number', onupdate="CASCADE",
ondelete="CASCADE"), primary_key=True)
teacher = db.relationship("Teacher", back_populates="teacher_subject")
subject = db.relationship("Subject", back_populates="teacher_subject")
def __init__(self, subject_id, personnel_number):
self.subject_id = subject_id
self.personnel_number = personnel_number
class ScanProfile(db.Model):
__table_args__ = (db.UniqueConstraint('name',
'owner_id',
name='scan_profile_uniq'), )
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String)
owner_id = db.Column(db.Integer,
db.ForeignKey('users.id',
name='scan_profile_fk',
ondelete='CASCADE'),
nullable=False)
settings = db.relationship('ProfileSetting',
lazy='dynamic',
cascade="save-update, delete")
def __repr__(self) -> str:
return f'ScanProfile(name={self.name})'
def to_dict(self) -> Dict[str, Dict[str, str]]:
result = defaultdict(dict)
for item in self.settings:
if item.setting == 'credential':
credential = AccountCredential.query.get(item.value)
result[item.transport].update(
dict(username=credential.username,
password=credential.password))
continue
result[item.transport][item.setting] = item.value
return result
class OutgoingMessage(db.Model):
__tablename__ = 'outgoing_messages'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
message_id = db.Column(db.Integer, db.ForeignKey('messages.id'), nullable=False)
to_id = db.Column(db.Integer, db.ForeignKey('vk_users.vk_id'), nullable=False)
message = db.relationship('Message', backref='out_message', uselist=False)
def __init__(self, to_id, text):
self.to_id = to_id
self.text = text
def send(self):
random_id = VK.send_message(text=self.text, user_id=self.to_id)
if random_id is None:
return False
message = Message(
datetime = datetime.utcnow(),
random_id = random_id,
text = self.text
)
message.save()
self.message_id = message.id
db.session.add(self)
db.session.commit()
return True
class IncomingMessage(db.Model):
__tablename__ = 'incoming_messages'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
message_id = db.Column(db.Integer, db.ForeignKey('messages.id'), nullable=False)
from_id = db.Column(db.Integer, db.ForeignKey('vk_users.vk_id'), nullable=False)
message = db.relationship('Message', backref='inc_message', uselist=False)
def save(self, message):
send_date = datetime.strptime(
time.ctime(message['date']),
'%a %b %d %H:%M:%S %Y'
)
msg_obj = Message(
datetime = send_date,
random_id = message['random_id'],
text = message['text']
)
msg_obj.save()
self.message_id = msg_obj.id
self.from_id = message['from_id']
db.session.add(self)
db.session.commit()
def get_text(self):
return self.message.get_text()
class Message(db.Model):
__tablename__ = 'messages'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
datetime = db.Column(db.DateTime, nullable=False)
random_id = db.Column(db.Integer, nullable=False)
text = db.Column(db.String(1000), nullable=False)
long_text = db.relationship('LongText', backref='message', uselist=False)
def save(self):
text = self.text
self.text = text[:1000]
long_text = None
db.session.add(self)
db.session.commit()
if len(text) > 1000:
long = LongText(text=text, message_id=self.id)
long.save()
self.long_text = long
db.session.add(self)
db.session.commit()
def format_datetime(self):
return format_datetime(self.datetime)
def get_text(self):
if self.long_text is not None:
return self.long_text.text
return self.text
class Hotel(db.Model):
url = db.Column(db.String(500))
id = db.Column(db.Integer, primary_key=True)
crawledAt = db.Column(db.DateTime)
priority = db.Column(db.Integer)
vacation = db.relationship('Vacation')
localityId = db.Column(db.Integer, db.ForeignKey('locality.id'))
locality = db.relationship('Locality', enable_typechecks=False)
def __init__(self, id, locality):
self.id = id
self.url = '-'
self.locality = locality
def __repr__(self):
return 'Hotel ' + str(self.id)
class Vacation(db.Model):
url = db.Column(db.String(500), primary_key=True)
createdAt = db.Column(db.String(50), primary_key=True)
term = db.Column(db.String(50))
locationFrom = db.Column(db.String(50))
food = db.Column(db.String(50))
urlCrawled = db.Column(db.String(500))
days = db.Column(db.String(50))
price = db.Column(db.String(50))
hotelId = db.Column(db.Integer, db.ForeignKey('hotel.id'))
hotel = db.relationship('Hotel', enable_typechecks=False)
def __init__(self, url, term, locationFrom, food, days, price, urlCrawled,
hotel):
self.url = url
self.createdAt = datetime.utcnow()
self.term = term
self.locationFrom = locationFrom
self.food = food
self.days = days
self.price = price
self.urlCrawled = urlCrawled
self.hotel = hotel
def __repr__(self):
return 'Vacation ' + str(self.createdAt) + str(self.url)
class Classroom(db.Model):
__tablename__ = 'classrooms'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
edu_org_id = db.Column(db.Integer, db.ForeignKey('edu_orgs.id'), nullable=False)
number_format = db.Column(db.String(5), nullable=False)
number = db.Column(db.Integer)
lessons = db.relationship('Lesson', backref='classroom', uselist=True)
def save(self):
db.session.add(self)
db.session.commit()
def get_name(self):
return self.number_format.replace('*', str(self.number))
@staticmethod
def get_all():
return Classroom.query.all()
@staticmethod
def get(id=None, name=None):
if id is not None:
return Classroom.query.filter_by(id=id).first()
if name is not None:
classrooms = Classroom.get_all()
name = name.lower()
return [c for c in classrooms if c.get_name().lower() == name]
class Teacher(db.Model):
__tablename__ = 'teachers'
person_id = db.Column(db.Integer, db.ForeignKey('persons.id'), primary_key=True)
department_id = db.Column(db.Integer, db.ForeignKey('departments.id'), nullable=False)
subjects = db.relationship('Subject', backref='teacher', uselist=True)
def save(self):
db.session.add(self)
db.session.commit()
def get_subject(self, name):
name = name.lower()
filtered = filter(lambda s: s.name.lower() == name, self.subjects)
filtered = list(filtered)
if len(filtered) > 1:
raise SubjectIsNotUniqueException('More than one subject for a teacher with definite name')
elif len(filtered) == 1:
return filtered[0]
else:
return None
def get_subject_by_part(self, name):
name = name.lower()
filtered = filter(lambda s: name in s.name.lower(), self.subjects)
return list(filtered)
@staticmethod
def get_all():
return Teacher.query.all()
class TaskResult(db.Model):
id = db.Column(db.Integer, primary_key=True)
task_id = db.Column(db.Integer,
db.ForeignKey('task.id',
name='task_result_fk',
ondelete='SET NULL'),
nullable=False)
owner_id = db.Column(db.Integer,
db.ForeignKey('users.id',
name='task_fk',
ondelete='CASCADE'),
nullable=False)
started = db.Column(db.DateTime, server_default=func.now())
finished = db.Column(db.DateTime)
host_results = db.relationship('HostResult',
backref='task',
lazy='dynamic',
cascade='all, delete-orphan')
@property
def duration(self) -> Optional[datetime]:
if self.finished is None:
return
return self.finished - self.started
def finish(self):
self.finished = datetime.utcnow()
def __repr__(self):
return f'TaskResult(started="{self.started.isoformat()}")'
class User(db.Model):
id = db.Column(db.Integer, primary_key=True)
login = db.Column(db.String(32), unique=True) #, nullable=False)
password = db.Column(db.String(32), unique=False) #, nullable=False)
email = db.Column(db.String(128), unique=True) #, nullable=False)
date_created = db.Column(db.DateTime, default=db.func.current_timestamp())
verified = db.Column(db.Boolean, default=False)
link = db.Column(db.String(32), nullable=True)
personalInfo = db.relationship('PersonalInfo', backref='user', uselist=False)
def __init__(self, login):
self.login = login
def save(self, password):
"""
Функция сохранения нового пользователя в базе данных
:param password: Пароль
"""
self.password = hashlib.sha512(
password.encode("utf-8")).hexdigest()
db.session.add(self)
db.session.commit()
def check_pass(self, password):
hash = hashlib.sha512(password.encode("utf-8")).hexdigest()
return self.password == hash
@staticmethod
def get(id=None, login=None):
if login:
return User.query.filter_by(login=login).first()
if id:
return User.query.get(id)
return User.query.all()
class Subject(db.Model):
__tablename__ = 'subjects'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
name = db.Column(db.String(75), nullable=False)
short_name = db.Column(db.String(10), nullable=False)
teacher_id = db.Column(db.Integer, db.ForeignKey('teachers.person_id'), nullable=False)
lessons = db.relationship('Lesson', backref='subject', uselist=True)
def save(self):
db.session.add(self)
db.session.commit()
@staticmethod
def get_all():
return Subject.query.all()
@staticmethod
def get(id=None, name=None):
if id is not None:
return Subject.query.filter_by(id=id).first()
if name is not None:
subjects = Subject.query.all()
name = name.lower()
return [s for s in subjects if name.lower() in s.name.lower()]
class Raspberry(db.Model, Base):
id: int
updateAt: datetime
name: str
name = db.Column(db.String, nullable=True)
hardwares = db.relationship("Hardware",
backref="raspberry",
lazy='dynamic')
users = db.relationship('User',
secondary=RaspberryUser,
back_populates='raspberries',
lazy='joined')
def __hash__(self):
return hash(self.id)
class ExtraApplication(db.Model):
__tablename__ = "extra_application"
extra_application_number = db.Column(db.Integer,
primary_key=True,
autoincrement=True)
extra_application_date = db.Column(db.Date, nullable=False)
extra_application_reason = db.Column(db.String(1500), nullable=False)
extra_application_status = db.Column(db.String(50), nullable=False)
teacher_position = db.Column(db.String(100), nullable=False)
teacher_pib = db.Column(db.String(100), nullable=False)
personnel_number = db.Column(db.Integer,
db.ForeignKey('teacher.personnel_number',
onupdate="CASCADE",
ondelete="CASCADE"),
nullable=False)
teacher = db.relationship("Teacher", back_populates="extra_application")
def __init__(self, extra_application_reason, extra_application_date,
extra_application_status, teacher_position, teacher_pib,
personnel_number):
self.extra_application_date = datetime.strptime(
extra_application_date, '%Y-%m-%d').date()
self.extra_application_reason = extra_application_reason
self.extra_application_status = STATUS[extra_application_status].value
self.teacher_position = teacher_position
self.teacher_pib = teacher_pib
self.personnel_number = personnel_number
class Alias(db.Model):
id = db.Column(db.Integer, primary_key=True)
owner_id = db.Column(db.Integer, db.ForeignKey('user.id'))
domain_id = db.Column(db.Integer, db.ForeignKey('domain.id'))
alias = db.Column(db.String(255), index=True, nullable=False)
forward = db.Column(db.String(255), nullable=False)
comment = db.Column(db.Text, default='')
enabled = db.Column(db.Boolean, default=True)
expires = db.Column(db.DateTime, default=None)
num_accepted = db.Column(db.Integer, default=0)
num_rejected = db.Column(db.Integer, default=0)
domain = db.relationship('Domain',
backref=db.backref('aliases', lazy=True))
owner = db.relationship('User', backref=db.backref('aliases'))
class Book(db.Model):
__tablename__ = _TABLE_BOOKS
id = db.Column(db.Integer, primary_key=True)
title = db.Column(db.String)
genre = db.Column(db.String)
authors = db.relationship('Author', secondary='books_authors', back_populates='books')
def __init__(self, title, genre, authors):
self.title = title
self.genre = genre
self.authors = authors
def __repr__(self):
return "Book #{0}: {1} ({2}) - {3}.".format(self.id, self.title, self.genre, self.authors)
@property
def to_dict(self):
return {'id': self.id, 'title': self.title, 'genre': self.genre, 'authors': self.serialize_authors}
@property
def serialize_authors(self):
authors_list = map(str, self.authors)
return ','.join(authors_list)
class Brand(db.Model):
id = db.Column(db.Integer, primary_key=True)
nike = db.Column(db.String, nullable=False)
adidas = db.Column(db.String, nullable=False)
merrel = db.Column(db.String, nullable=False)
gucci = db.Column(db.String, nullable=False)
sheckhers = db.Column(db.String, nullable=False)
product = db.relationship('Productdetail', backref='brand', lazy=True)
class Director(db.Model):
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(64), index=True, unique=True)
extras = db.Column(db.String(128))
movies = db.relationship('Movie', backref='writer', lazy='dynamic')
def __repr__(self):
return '<Director {}>'.format(self.name)
