class TagsPosts(db.Model):
__tablename__ = "tags_posts"
id = db.Column(db.Integer(), primary_key=True)
tag_id = db.Column(db.Integer(), db.ForeignKey('tag.id',
ondelete='CASCADE'))
blog_post_id = db.Column(db.Integer(),
db.ForeignKey('blog_post.id', ondelete='CASCADE'))
class Job(db.Model):
"""A Job is the basic work unit of Flamenco
The creation of a job can happen in different ways:
* within Flamenco (using the job creation form)
* via a query from an external software (e.g. Attract)
* withing Blender itself
Possible statuses for a job are:
* Waiting (tasks for this job are ready to be dispatched)
* Active
* Canceled
* Failed
* Paused (will be added later)
* Completed
* Waiting
"""
id = db.Column(db.Integer, primary_key=True)
project_id = db.Column(db.Integer, db.ForeignKey('project.id'))
project = db.relationship('Project',
backref=db.backref('jobs', lazy='dynamic'))
name = db.Column(db.String(120))
status = db.Column(db.String(64))
priority = db.Column(db.Integer())
settings = db.Column(db.Text())
creation_date = db.Column(db.DateTime(), default=datetime.datetime.now)
date_edit = db.Column(db.DateTime())
type = db.Column(db.String(64))
tasks_status = db.Column(db.String(256))
notes = db.Column(db.Text())
user_id = db.Column(db.Integer(), db.ForeignKey('user.id'))
user = db.relationship('User', backref=db.backref('job', lazy='dynamic'))
def __repr__(self):
return '<Job %r>' % self.name
class Attachment(Base):
__tablename__ = 'attachments'
__table_args__ = {'sqlite_autoincrement': True}
permalink = db.Column(db.String(128), nullable=False)
issue_id = db.Column(db.Integer(), nullable=True)
comment_id = db.Column(db.Integer(), nullable=True)
def __init__(self, permalink, issue_id=None, comment_id=None):
if comment_id is None and issue_id is None:
raise ValueError(
"Exception on Attachment class, issue_id or comment_id must be provided."
)
if comment_id is not None and issue_id is not None:
raise ValueError(
"Exception on Attachment class, issue_id and comment_id can't be both specified."
)
self.permalink = permalink
self.issue_id = issue_id
self.comment_id = comment_id
def get_attached_id(self):
return ("issue", self.issue_id) if self.issue_id is not None else (
"comment", self.comment_id)
class Student(db.Model):
__tablename__ = 'students'
id = db.Column(db.Integer, primary_key=True)
user_id = db.Column(db.Integer(), db.ForeignKey('users.id'), nullable = False, unique = True)
educational_group_id = db.Column(db.Integer(), db.ForeignKey('EducationalGroup.id'), nullable = False)
entry_year = db.Column(db.Integer(), nullable = False)
degree = db.Column(db.String(100), nullable = False)
tuition_format = db.Column(db.String(100), nullable = False)
tuition_base = db.Column(db.String(100), nullable = False)
__table_args__ = (db.CheckConstraint(degree.in_(["бакалавр", "специалист", "магистр"])),
db.CheckConstraint(tuition_format.in_(["очная", "заочная", "вечерняя"])),
db.CheckConstraint(tuition_base.in_(["контрактная", "бюджетная"])),
)
def __init__(self, user_id, educational_group_id, entry_year, degree, tuition_format, tuition_base):
self.user_id = user_id
self.educational_group_id = educational_group_id
self.entry_year = entry_year
self.degree = degree
self.tuition_format = tuition_format
self.tuition_base = tuition_base
@staticmethod
def create_student(name, surname, second_name, educational_group_id, entry_year, degree, tuition_format, tuition_base):
user = User.create_user(name, surname, second_name)
student = Student(user_id = user.id, educational_group_id=educational_group_id, entry_year=entry_year, degree=degree, tuition_format=tuition_format, tuition_base=tuition_base)
db_add_objects(student)
return student
def __repr__(self):
return "<Student {}:educational_group_id:{}>".format(self.id, self.educational_group_id)
class Task(Base):
__tablename__ = 'task'
name = db.Column(db.String(30), nullable=False)
description = db.Column(db.String(60))
estimated_time = db.Column(db.Integer())
used_time = db.Column(db.Integer())
username = db.Column(db.String(20))
account_id = db.Column(db.Integer, db.ForeignKey('account.id'),
nullable=False)
tags = db.relationship('Tag', secondary='tagtask', back_populates='tasks')
def __init__(self, name, description, estimated_time):
self.name = name
self.description = description
self.estimated_time = estimated_time
@staticmethod
def find_users_tasks(id):
stmt = text("SELECT Task.name FROM Task WHERE (Task.Account_id = :id) LIMIT (100);").params(id=id)
res = db.engine.execute(stmt)
response = []
for row in res:
response.append({"name":row[0]})
return response
class Job(db.Model):
id = db.Column(db.Integer(), primary_key=True)
external_id = db.Column(db.String(256), nullable=False)
description = db.Column(db.String(512), nullable=False)
status = db.Column(db.Integer(), nullable=False)
user_id = db.Column(db.Integer, db.ForeignKey('user.id'), nullable=False)
user = db.relationship('User')
# Note that the datastore is not read-only, it is possible to edit via the API.
# Is this ideal?
datastore_id = db.Column(db.Integer,
db.ForeignKey('datastore.id'),
nullable=True)
datastore = db.relationship('Datastore')
def __init__(self, external_id, description, user, datastore, status=None):
self.external_id = external_id
self.description = description
if status is None:
status = JobTypes.QUEUED
if datastore is None:
raise IOError("Datastore must not be null")
self.status = status
self.user = user
self.datastore = datastore
def complete(self, spec, result):
self.datastore.spec = spec
self.datastore.set_value(result)
db.session.commit()
class BookReview(db.Model):
__tablename__ = "book_review"
id = db.Column(db.Integer, primary_key=True)
book_id = db.Column(db.Integer(), db.ForeignKey("book.id"))
user_id = db.Column(db.Integer(), db.ForeignKey("user.id"))
rating = db.Column(db.Float(), nullable=True)
review = db.Column(db.Text(), nullable=True)
class Day(db.Model):
__tablename__ = 'days'
id = db.Column(db.Integer(), primary_key=True)
date = db.Column(db.DateTime(),
default=datetime.datetime.utcnow,
nullable=False)
habit_id = db.Column(db.Integer(), db.ForeignKey('habits.id'))
user_id = db.Column(db.Integer(), db.ForeignKey('users.id'))
habit_complete = db.Column(db.Boolean())
#Parent
habit = relationship("Habit", back_populates="days")
#Child
daydescs = relationship("DayDesc",
back_populates='day',
cascade="all, delete, delete-orphan")
def __init__(self, date, habit_id, user_id, habit_complete):
self.date = date
self.habit_id = habit_id
self.user_id = user_id
self.habit_complete = habit_complete
def __repr__(self):
return f'{self.date}:{self.habit_id}:{self.habit_complete}'
class UserRoles(db.Model):
__tablename__ = 'user_roles'
id = db.Column(db.Integer(), primary_key=True)
user_id = db.Column(db.Integer(),
db.ForeignKey('account.id', ondelete='CASCADE'))
role_id = db.Column(db.Integer(),
db.ForeignKey('role.id', ondelete='CASCADE'))
class Committed_by(db.Model):
Criminal_id = db.Column(db.Integer(),
db.ForeignKey("criminal.Criminal_id"),
primary_key=True)
Case_No = db.Column(db.Integer(),
db.ForeignKey("crime.Case_No"),
primary_key=True)
class CourseHometask(db.Model):
__tablename__ = 'course_hometask'
id = db.Column(db.Integer, nullable = False, primary_key=True)
course_id = db.Column(db.Integer(), db.ForeignKey('EducationalСourse.id'), nullable = False )
name = db.Column(db.String(100), nullable = False)
content = db.Column(db.String(10000), nullable = False)
start_dttm = db.Column(db.DateTime(), nullable = False)
end_dttm = db.Column(db.DateTime(), nullable = False)
created_on = db.Column(db.DateTime(), default=datetime.utcnow)
updated_on = db.Column(db.DateTime(), default=datetime.utcnow, onupdate=datetime.utcnow)
deleted = db.Column(db.Integer() )
def __init__(self, course_id, name, content, start_dttm, end_dttm):
self.course_id = course_id
self.name = name
self.content = content
self.start_dttm = start_dttm
self.end_dttm = end_dttm
self.deleted = 0
def set_content(self, content):
self.content = content
def delete(self):
self.deleted = 1
def __repr__(self):
return "<CourseHometask Info {}:{}:{}>".format(self.id, self.course_id, self.name)
class Task(db.Model):
"""Tasks are created after a Shot is added
Tasks can be reassigned individually to a different worker, but can be
deleted and recreated all together. A task is made of "orders" or
instructions, for example:
* Check out SVN revision 1954
* Clean the /tmp folder
* Render frames 1 to 5 of scene_1.blend
* Send email with results to [email protected]
"""
id = db.Column(db.Integer, primary_key=True)
job_id = db.Column(db.Integer, db.ForeignKey('job.id'))
job = db.relationship('Job',
backref=db.backref('tasks', lazy='dynamic'))
manager_id = db.Column(db.Integer())
name = db.Column(db.String(64))
status = db.Column(db.String(64))
priority = db.Column(db.Integer())
type = db.Column(db.String(64))
settings = db.Column(db.Text())
log = db.Column(db.Text())
activity = db.Column(db.String(128))
child_id = db.Column(db.Integer())
parser = db.Column(db.String(64))
time_cost = db.Column(db.Integer())
last_activity = db.Column(db.DateTime())
# Currently the hostname, later will be a serialized dictionary, storing
# id and hostname of a worker
worker = db.Column(db.String(128))
def __repr__(self):
return '<Task %r>' % self.id
class OtherComponent(db.Model):
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(250))
hours = db.Column(db.Integer())
code = db.Column(db.String(250))
univ_id = db.Column(db.Integer())
prog_id = db.Column(db.Integer())
class User_info(db.Model):
id = db.Column(db.Integer,primary_key=True)
user_id = db.Column(db.Integer, db.ForeignKey('user.id'))
user_type = db.Column(db.String(), unique=False, default="student")
food_preference = db.Column(db.String(), unique=False, default=None)
warnings = db.Column(db.Integer(), unique=False, default=0)
semester = db.Column(db.Integer(), unique=False, nullable=False)
class UserRoles(Base):
__tablename__ = 'user_roles'
user_id = db.Column(db.Integer(),
db.ForeignKey('account.id', ondelete='CASCADE'))
role_id = db.Column(db.Integer(),
db.ForeignKey('roles.id', ondelete='CASCADE'))
class Notification(db.Model):
"""Basic notification. We create one notification per object per user.
"""
id = db.Column(db.Integer, primary_key=True)
user_id = db.Column(db.Integer(),
db.ForeignKey('user.id'), nullable=False)
notification_object_id = db.Column(db.Integer(),
db.ForeignKey('notification_object.id'), nullable=False)
notification_object = db.relationship('NotificationObject',
backref=db.backref('notification'))
is_read = db.Column(db.Boolean(), default=False)
date_read = db.Column(db.DateTime())
def get_subscription(self):
context_object_type_id = self.notification_object.context_object_type_id
context_object_id = self.notification_object.context_object_id
notification_subscription = NotificationSubscriptions.query\
.filter(NotificationSubscriptions.context_object_type_id == context_object_type_id)\
.filter(NotificationSubscriptions.context_object_id == context_object_id)\
.filter(NotificationSubscriptions.user_id == current_user.id)\
.first()
return notification_subscription
@property
def is_subscribed(self):
subscription = self.get_subscription()
if subscription:
return subscription.is_subscribed
else:
return False
def __str__(self):
return u"Notification {0}".format(self.id)
class UserRequest(db.Model):
"""Define the UserRequest data-model"""
__tablename__ = 'user_requests'
id = db.Column(db.Integer(), primary_key=True)
user_id = db.Column(db.Integer(),
db.ForeignKey('users.id', ondelete='CASCADE'))
authorizer_id = db.Column(db.Integer(),
db.ForeignKey('users.id', ondelete='CASCADE'))
request_date = db.Column(db.DateTime())
auth_date = db.Column(db.DateTime())
start_date = db.Column(db.DateTime())
end_date = db.Column(db.DateTime())
request_type_id = db.Column(
db.Integer(), db.ForeignKey('request_types.id', ondelete='CASCADE'))
prv_note_to_auth = db.Column(db.UnicodeText(255), server_default='')
prv_note_from_auth = db.Column(db.UnicodeText(255), server_default='')
pub_note = db.Column(db.UnicodeText(255), server_default='')
authorized = db.Column('is_authorized',
db.Boolean(),
nullable=False,
server_default='0')
# Define relationships to User
user = db.relationship('User', backref='requests', foreign_keys=[user_id])
authorizer = db.relationship('User',
backref='authorizations',
foreign_keys=[authorizer_id])
# Define relationship to RequestType
request_type = db.relationship('RequestType', backref='user_requests')
# Define relationship to Allowance
allowance = db.relationship(
'Allowance',
primaryjoin=
'and_(foreign(UserRequest.user_id) == remote(Allowance.user_id), foreign(UserRequest.request_type_id) == remote(Allowance.request_type_id))',
backref='user_requests')
class PricingCategory(db.Model):
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String())
description = db.Column(db.String())
price_per_day = db.Column(db.Integer())
price_per_week = db.Column(db.Integer())
price_per_month = db.Column(db.Integer())
rooms = db.relationship("Room", backref="pricing_category")
class JobManagers(db.Model):
id = db.Column(db.Integer, primary_key=True)
job_id = db.Column(db.Integer(), db.ForeignKey('job.id'))
job = db.relationship('Job',
backref=db.backref('manager_list', lazy='dynamic'))
manager_id = db.Column(db.Integer(), db.ForeignKey('manager.id'))
manager = db.relationship('Job',
backref=db.backref('jobs_list', lazy='dynamic'))
class UserRole(db.Model):
"""Define the User-Role association table"""
__tablename__ = 'user_roles'
id = db.Column(db.Integer(), primary_key=True)
user_id = db.Column(db.Integer(),
db.ForeignKey('users.id', ondelete='CASCADE'))
role_id = db.Column(db.Integer(),
db.ForeignKey('roles.id', ondelete='CASCADE'))
class Purdetails(db.Model):
autoid = db.Column(db.Integer(), primary_key=True)
pid = db.Column(db.String(9))
medid = db.Column(db.String(4))
medname = db.Column(db.String(40))
qtypur = db.Column(db.Integer())
rate = db.Column(db.Float())
amt = db.Column(db.Float())
class Comment(db.Model):
__tablename__='comments'
commentID = db.Column(db.Integer(), primary_key=True)
body = db.Column(db.Text())
comment_date = db.Column(db.DateTime(), default=datetime.utcnow())
disabled = db.Column(db.Boolean(), default=False)
userID = db.Column(db.Integer(), db.ForeignKey('users.userID'))
postID = db.Column(db.Integer(), db.ForeignKey('posts.postID'))
class PatientDiagnostics(db.Model):
__tablename__ = "patient_diagnostics"
id = db.Column(db.Integer(), primary_key=True)
patient_id = db.Column(db.Integer(), db.ForeignKey('patients.patient_id'))
patients = db.relationship("Patient")
diagnostics_conducted = db.Column(
db.Integer(), db.ForeignKey('diagnostics.diagnostics_id'))
diagnostics = db.relationship("Diagnostics")
class Website(db.Model):
id = db.Column(db.Integer(), primary_key=True)
url = db.Column(db.String(), nullable=False)
job_type = db.Column(db.String(10), nullable=False)
hours = db.Column(db.Integer(), nullable=False, default=0)
minutes = db.Column(db.Integer(), nullable=False, default=0)
seconds = db.Column(db.Integer(), nullable=False, default=0)
last_ping = db.Column(db.DateTime, default=datetime.datetime.now())
class Invoice(db.Model):
id:int
practice_uuid:str
patient_id:str
medical_aid:str
date_created:datetime
date_invoice:datetime
invoice_id:str
invoice_file_url:str
tariff:str
po_number:int
hospital_name:str
admission_date:datetime
discharge_date:datetime
procedure:str
procedure_date:str
diagnosis:str
diagnosis_date:datetime
implants:str
intra_op:str
post_op:str
submitted_on:datetime
invoice_layout:int
status:str
credit_cent:int
remind_me:datetime
last_edited:datetime
last_edited_by:str
__tablename__ = 'invoices'
id = db.Column(db.Integer(), primary_key=True)
practice_uuid = db.Column(db.String(36), nullable=False)
patient_id = db.Column(db.String(255), nullable=False)
medical_aid = db.Column(db.String(255), nullable=False)
date_created = db.Column(db.DateTime(),default=datetime.utcnow)
date_invoice = db.Column(db.Date(),nullable=False)
invoice_id = db.Column(db.String(255),nullable=False)
invoice_file_url = db.Column(db.String(255),nullable=False)
tariff = db.Column(db.String(255),nullable=False)
po_number = db.Column(db.Integer(), nullable=True)
hospital_name = db.Column(db.String(255), nullable=True)
admission_date = db.Column(db.Date(), nullable=True)
discharge_date = db.Column(db.Date(), nullable=True)
procedure = db.Column(db.Text(), nullable=True)
procedure_date = db.Column(db.Date(), nullable=True)
diagnosis = db.Column(db.Text(), nullable=True)
diagnosis_date = db.Column(db.Date(), nullable=True)
implants = db.Column(db.Text(), nullable=True)
intra_op = db.Column(db.String(255), nullable=True)
post_op = db.Column(db.String(255), nullable=True)
submitted_on = db.Column(db.Date(),nullable=True)
invoice_layout = db.Column(db.Integer(), nullable=True)
status = db.Column(db.String(255), default="not-submitted")
credit_cent = db.Column(db.Integer(), default=0)
remind_me = db.Column(db.DateTime, nullable=True)
last_edited = db.Column(db.DateTime(),default=datetime.utcnow,onupdate=datetime.utcnow)
last_edited_by = db.Column(db.String(255), nullable=True)
class Event(db.Model):
id = db.Column(db.Integer(), primary_key=True)
event_id = db.Integer(db.ForeingKey('post.id'))
event_name = db.String(db.ForeingKey('post.title'))
location = db.Column(db.String(), nullable=True, unique=False)
event_date = db.Column(db.String(), nullable=True)
event_time = db.Column(db.String(), nullable=True)
last_registration = db.Column(db.String, nullable=False)
max_participants = db.Column(db.Integer,unique=false, default=0)
class MedicineCount(db.Model):
__tablename__ = "medicine_track_data"
id = db.Column(db.Integer(), primary_key=True)
patient_id = db.Column(db.Integer(), db.ForeignKey('patients.patient_id'))
patients = db.relationship("Patient")
medicine_id = db.Column(db.Integer(),
db.ForeignKey("medicine.medicine_id"))
medicine = db.relationship("Medicine")
issue_count = db.Column(db.Integer())
class UserKarma(db.Model):
id = db.Column(db.Integer(), primary_key=True)
user_id = db.Column(db.Integer(), db.ForeignKey('user.id'), nullable=False)
positive = db.Column(db.Integer(), default=0)
negative = db.Column(db.Integer(), default=0)
value = db.Column(db.Integer(), default=0)
def __str__(self):
return str(self.value)
class UserOauth(db.Model):
id = db.Column(db.Integer(), primary_key=True)
user_id = db.Column(db.Integer(), db.ForeignKey('user.id'), nullable=False)
service = db.Column(db.String(80), nullable=False)
service_user_id = db.Column(db.String(80))
token = db.Column(db.String(255))
def __str__(self):
return self.service_user_id
class witness(db.Model):
Case_No = db.Column(db.Integer(),
db.ForeignKey("crime.Case_No"),
primary_key=True)
Name = db.Column(db.String(128), primary_key=True, index=True)
Age = db.Column(db.Integer(), nullable=False)
Phone_No = db.Column(db.String(11))
Address = db.Column(db.String(128))
witnessed = db.relationship("Witnessed", backref="witness")
