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 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 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 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 Lesson(db.Model):
__tablename__ = 'lessons'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
group_id = db.Column(db.Integer, db.ForeignKey('study_groups.id'), nullable=False)
subject_id = db.Column(db.Integer, db.ForeignKey('subjects.id'), nullable=False)
classroom_id = db.Column(db.Integer, db.ForeignKey('classrooms.id'), nullable=False)
start_time = db.Column(db.Time, nullable=False)
end_time = db.Column(db.Time, nullable=False)
week_day = db.Column(db.Integer, nullable=False)
on_even_week = db.Column(db.String(1), nullable=False)
def save(self):
db.session.add(self)
db.session.commit()
def formatted_output(self):
return '{since}—{till}: {subject}, {teacher}, {place} ({edu_org})'.format(
since = format_time(self.start_time),
till = format_time(self.end_time),
subject = self.subject.name,
teacher = self.subject.teacher.pd.short_name(),
place = self.classroom.get_name(),
edu_org = self.classroom.edu_org.short_name
)
def get_week_day(self):
return WEEK_DAYS[self.week_day].capitalize()
def is_on_even_week(self):
if self.on_even_week == 'e':
return True
elif self.on_even_week == 'o':
return False
else:
return None
class TickerSubscription(db.Model):
id = db.Column(db.Integer, primary_key=True)
ticker_id = db.Column(db.Integer, db.ForeignKey('ticker.id'))
user_id = db.Column(db.Integer, db.ForeignKey('user.id'))
def __repr__(self):
return '<Ticker {}>'.format(self.ticker_id)
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 Articles(db.Model):
__tablename__ = 'articles'
id = db.Column(db.Integer, primary_key=True)
title = db.Column(db.String(255), nullable=False)
body = db.Column(db.Text(), nullable=False)
summary = db.Column(db.String(150),nullable=False)
img_url = db.Column(db.String(255),nullable=False)
insert_date = db.Column(db.DateTime, nullable=False)
insert_id = db.Column(db.Integer, db.ForeignKey('users.id'), nullable=False)
update_date = db.Column(db.DateTime, nullable=True)
update_id = db.Column(db.Integer, db.ForeignKey('users.id'), nullable=True)
delete_flg = db .Column(db.Boolean, nullable=False, default=False)
version = db.Column(db.Integer, nullable=True)
__mapper_args__ = {'version_id_col': version}
def __init__(self,title,body,summary,img_url,insert_date,insert_id,version=0,update_date=None,update_id=None):
self.title = title
self.body = body
self.summary = summary
self.img_url = img_url
self.insert_date = insert_date
self.insert_id = insert_id
self.version = version
self.update_date = update_date
self.update_id = update_id
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 Friends(db.Model,UserMixin):
id = db.Column(db.Integer, primary_key=True)
Date = db.Column(db.DateTime,nullable=False) # default to datetime.today()
From_id = db.Column(db.Integer,db.ForeignKey('user.id',ondelete="CASCADE"),nullable=True) # if any one of these (From_id and To_id) are deleted, the entire row will be deleted.
To_id = db.Column(db.Integer,db.ForeignKey('user.id',ondelete='CASCADE'),nullable=True)
Status = db.Column(db.Integer, nullable=False) # 0 -> Pending, 1 -> Accepted, 2 -> Rejected
Friend_of_id = db.Column(db.Integer,nullable=False) # friend of id of someone in user table # if not a friend yet, then this value is 0
Priviledged = db.Column(db.Integer,nullable=False) # if someone is priviledged, then the From_id (in this table) can edit the To_id's shopping list # Priviledged 0 is just friends and 1 means priviledged
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 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 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 ArticleGenre(db.Model):
__tablename__ = 'article_genre'
id = db.Column(db.Integer, primary_key=True)
article_id = db.Column(db.Integer,
db.ForeignKey('articles.id'),
nullable=False)
genre_id = db.Column(db.Integer,
db.ForeignKey('genres.id'),
nullable=False)
def __init__(self, article_id, genre_id):
self.article_id = article_id
self.genre_id = genre_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 Log(db.Model):
__tablename__ = 'log'
id = db.Column(db.Integer, primary_key=True)
habit_id = db.Column(db.Integer, db.ForeignKey('habit.id'))
user_id = db.Column(db.Integer, db.ForeignKey('user.id'))
date = db.Column(db.DateTime)
status = db.Column(db.Boolean, default=False)
def __repr__(self):
return "<Log(id={}, habit_id={}, user_id={}, date={}, status={})>".format(
self.id, self.habit_id, self.user_id, self.date, self.status)
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 Comment(db.Model):
__tablename__ = 'Comment'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
text = db.Column(db.Text())
video_id = db.Column(db.Text(), db.ForeignKey('Video.id'), nullable=False)
user_id = db.Column(db.Integer, db.ForeignKey('User.id'), nullable=False)
def __init__(self, text, video_id, user_id):
self.text = text
self.user_id = user_id
self.video_id = video_id
def save(self):
db.session.add(self)
db.session.commit()
class Cart(db.Model):
id = db.Column(db.Integer, primary_key=True)
product_id = db.Column(db.String(50), nullable=False)
quantity = db.Column(db.Integer, nullable=False)
customer_details = db.Column(db.String(50),
db.ForeignKey('customer.customer_id'),
nullable=False)
class Productdetail(db.Model):
id = db.Column(db.Integer, primary_key=True)
cost = db.Column(db.String, nullable=False)
text = db.Column(db.String, nullable=False)
image = db.Column(db.String, nullable=False)
span = db.Column(db.String, nullable=False)
brand_id = db.Column(db.Integer, db.ForeignKey('brand.id'), nullable=False)
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 Email(db.Model):
id = db.Column(db.Integer,primary_key=True)
email = db.Column(db.String(60),nullable=False)
contact_id = db.Column(db.Integer,db.ForeignKey("contact.id"))
def __str__(self):
return self.email
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 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 Student(db.Model):
__tablename__ = 'students'
person_id = db.Column(db.Integer, db.ForeignKey('persons.id'), primary_key=True)
group_id = db.Column(db.Integer, db.ForeignKey('study_groups.id', use_alter=True), nullable=False)
def save(self):
db.session.add(self)
db.session.commit()
@staticmethod
def get_all():
return Student.query.all()
@staticmethod
def get(id):
return Student.query.filter_by(person_id=id).first()
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 PhotoThumbnails(db.Model):
__tablename__ = 'photo_thumbnails'
uuid = db.Column(UUID(as_uuid=True), unique=True, primary_key=True)
photo_uuid = db.Column(UUID(as_uuid=True), db.ForeignKey('photos.uuid'))
width = db.Column(INTEGER)
height = db.Column(INTEGER)
url = db.Column(TEXT())
created_at = db.Column(DateTime)
def __init__(self, uuid, photo_uuid, url, width, height, created_at):
self.uuid = uuid
self.photo_uuid = photo_uuid
self.url = url
self.width = width
self.height = height
self.created_at = created_at
def __repr__(self):
return ','.join([
str(self.uuid),
str(self.url),
str(self.width),
str(self.height),
str(self.created_at)
])
class Prev_order_products(db.Model):
id = db.Column(db.Integer, primary_key=True)
product_id = db.Column(db.String(50), nullable=False)
quantity = db.Column(db.Integer, nullable=False)
total_price = db.Column(db.Integer, nullable=False)
order = db.Column(db.String(50), db.ForeignKey('prev_order.order_id'),
nullable=False)
class Productratings(db.Model):
id = db.Column(db.Integer, primary_key=True)
customer_id = db.Column(db.String(50), unique=True, nullable=False)
rating = db.Column(db.Integer, nullable=False)
product_details = db.Column(db.String(50),
db.ForeignKey('products.product_id'),
nullable=False)
class Vendor_rating(db.Model):
id = db.Column(db.Integer, primary_key=True)
customer_id = db.Column(db.String(50), unique=True, nullable=False)
rating = db.Column(db.Integer, nullable=False)
vendor_details = db.Column(db.String(50),
db.ForeignKey('vendor.vendor_id'),
nullable=False)
