class TimelineEntry(db.Model):
id = db.Column(db.Integer, primary_key=True)
user_id = db.Column(db.Integer, db.ForeignKey('user_profile.id'))
public = db.Column(db.String(128), default="True")
headline = db.Column(db.String(500), nullable=False)
year = db.Column(db.Integer, nullable=False)
month = db.Column(db.Integer)
day = db.Column(db.Integer)
end_year = db.Column(db.Integer)
end_month = db.Column(db.Integer)
end_day = db.Column(db.Integer)
display_date = db.Column(db.String(128))
media = db.Column(db.String(500))
media_credit = db.Column(db.String(128))
media_caption = db.Column(db.String(500))
media_thumbnail = db.Column(db.String(500))
entry_type = db.Column(db.String(128))
entry_group = db.Column(db.String(128))
background = db.Column(db.String(128))
entry_teaser = db.Column(db.Text(),
info={'widget': CKTextAreaWidget()},
nullable=False)
entry_essay = db.Column(db.Text(),
info={'widget': CKTextAreaWidget()},
nullable=False)
def __repr__(self):
return '<Timeline Entry %r >' % self.headline
class Tariff(db.Model):
id:int
item:int
description:str
procedure:str
units:int
units_specification:str
value_cent:int
anaesthetic_units:int
anaesthetic_value_cent:int
category:str
sub_category:str
sub_sub_category:str
sub_sub_sub_category:str
note:str
tariff:str
__tablename__ = 'namaf_tariffs'
id = db.Column(db.Integer(), primary_key=True)
item = db.Column(db.Integer(), nullable=False)
description = db.Column(db.Text(), nullable=False)
procedure = db.Column(db.String(500), nullable=True)
units = db.Column(db.Integer(), nullable=False)
units_specification = db.Column(db.String(255), nullable=True)
value_cent = db.Column(db.Integer(), nullable=True)
anaesthetic_units = db.Column(db.Integer(), nullable=True)
anaesthetic_value_cent = db.Column(db.Integer(), nullable=True)
category = db.Column(db.String(255),nullable=True)
sub_category = db.Column(db.String(255),nullable=True)
sub_sub_category = db.Column(db.String(255),nullable=True)
sub_sub_sub_category = db.Column(db.String(255),nullable=True)
note = db.Column(db.Text(),nullable=True)
tariff = db.Column(db.String(255),nullable=False)
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 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 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 Book(db.Model):
id = db.Column(db.Integer, primary_key=True)
bookname = db.Column(db.String(64), index=True)
author = db.Column(db.String(64), index=True)
tag = db.Column(db.String(64), index=True)
book_id = db.Column(db.String(64), index=True)
words = db.Column(db.Integer)
chapters = db.Column(db.Integer)
cover = db.Column(db.Text())
pc_url = db.Column(db.Text())
m_url = db.Column(db.Text())
source = db.Column(db.String(64))
intro = db.Column(db.Text())
last_update = db.Column(ArrowType, index=True)
last_chapter = db.Column(db.String(64))
avg = db.Column(db.Float, default=0.0)
comments = db.relationship('Comment', backref='book', lazy='dynamic')
def __repr__(self):
return '<Book {}>'.format(self.bookname)
@staticmethod
def insert_book():
with open(Config.BOOK_INFO, 'r') as f:
for line in f:
item = json.loads(line.strip())
b = Book(bookname=item['name'],
book_id=item['book_id'],
chapters=int(
re.search('\d+', item['chapters']).group(0)),
words=int(re.search('\d+', item['words']).group(0)),
author=item['author'],
tag=item['tag'],
cover=item['cover'],
pc_url=item['pc_url'],
m_url=item['m_url'],
source=item['source'],
intro=item['intro'],
last_update=arrow.get(
item['last_update'],
'YY/MM/DD HHmm').replace(tzinfo='Asia/Shanghai'),
last_chapter=item['last_chapter'])
try:
db.session.add(b)
db.session.commit()
except Exception as e:
print(e)
db.session.rollback()
def set_avg(self):
total = 0
count = 0
for c in self.comments:
total += c.score
count += 1
if count:
self.avg = total / count
class Post(db.Model):
__tablenaem__ = 'post'
id = db.Column(db.Integer(), primary_key=True)
header_img = db.Column(db.String(255))
title = db.Column(db.String(255), unique=True)
subtitle = db.Column(db.Text())
post = db.Column(db.Text())
create_at = db.Column(db.DateTime(), default=db.func.now())
user_id = db.Column(db.Integer(), db.ForeignKey('user.id'))
def __str__(self):
return str(self.title)
class Project(db.Model):
"""Production project folders
This is a temporary table to get quickly up and running with project
support in flamenco. In the future, project definitions could come from
attract or it could be defined in another way.
"""
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(120))
path_server = db.Column(db.Text())
path_linux = db.Column(db.Text())
path_win = db.Column(db.Text())
path_osx = db.Column(db.Text())
render_path_server = db.Column(db.Text())
render_path_linux = db.Column(db.Text())
render_path_win = db.Column(db.Text())
render_path_osx = db.Column(db.Text())
@property
def is_active(self):
active_project = Setting.query.filter_by(name='active_project').first()
if active_project:
return int(active_project.value) == self.id
else:
return False
def __repr__(self):
return '<Project %r>' % self.name
class Establishment(db.Model):
"""This class represents the establishments table."""
__tablename__ = 'establishments'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(255))
location = db.Column(db.String(255))
description = db.Column(db.Text())
open_time = db.Column(db.Time())
end_time = db.Column(db.Time())
img_url = db.Column(db.String(255))
def __init__(self, name, location, description, open_time, end_time,
img_url):
self.name = name
self.location = location
self.description = description
self.open_time = open_time
self.end_time = end_time
self.img_url = img_url
def save(self):
db.session.add(self)
db.session.commit()
@staticmethod
def get_all():
return Establishment.query.all()
def delete(self):
db.session.delete(self)
db.session.commit()
def __repr__(self):
return "<Establishments: {}>".format(self.name)
class Post(db.Model):
__tablename__ = 'posts'
id = db.Column(db.Integer, primary_key=True)
body = db.Column(db.Text())
timestamp = db.Column(db.DateTime(), index=True, default=datetime.utcnow)
author_id = db.Column(db.Integer, db.ForeignKey('users.id'))
comments = db.relationship('Comment', backref='post', lazy='dynamic')
class UserProfile(db.Model):
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(250), index=True, unique=True)
is_admin = db.Column(db.Boolean, default=True)
profile_image = db.Column(db.String(250), index=True, unique=False)
display_name = db.Column(db.String(250), index=True, unique=True)
email = db.Column(db.String(250), index=True, unique=True)
authenticated = db.Column(db.Boolean, default=False)
custom_blog_title = db.Column(db.String(1224), nullable=True)
custom_blog_path = db.Column(db.String(512), default="")
custom_blog_description = db.Column(db.Text(), default="")
approved = db.Column(db.Boolean, default=False)
def __repr__(self):
return '<User %r>' % self.username
def is_active(self):
"""True, as all users are active."""
return True
def get_id(self):
"""Return the email address to satisfy Flask-Login's requirements."""
return self.id
def is_authenticated(self):
"""Return True if the user is authenticated."""
return self.authenticated
def is_approved(self):
"""Return True if the user is authenticated."""
return self.approved
def is_anonymous(self):
"""False, as anonymous users aren't supported."""
return False
class StaticPage(db.Model):
id = db.Column(db.Integer, primary_key=True)
user_id = db.Column(db.Integer, db.ForeignKey('user_profile.id'))
public = db.Column(db.String(128), default="True")
title = db.Column(db.String(500), nullable=False)
route = db.Column(db.String(512), nullable=False)
page_data = db.Column(db.Text(), nullable=False)
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 SysLog(db.Model):
__tablename__ = 'sys_log'
id = db.Column(db.String(64), primary_key=True)
type = db.Column(db.String(1, 'utf8_bin'),
index=True,
server_default=db.FetchedValue())
title = db.Column(db.String(255, 'utf8_bin'))
create_by = db.Column(db.String(64), index=True)
create_date = db.Column(db.DateTime, index=True)
remote_addr = db.Column(db.String(255, 'utf8_bin'))
user_agent = db.Column(db.String(255, 'utf8_bin'))
request_uri = db.Column(db.String(255, 'utf8_bin'), index=True)
method = db.Column(db.String(5, 'utf8_bin'))
params = db.Column(db.Text(collation='utf8_bin'))
exception = db.Column(db.Text(collation='utf8_bin'))
class Snap(db.Model):
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(128))
extension = db.Column(db.String(12))
content = db.Column(db.Text())
def content_hash(context):
content = context.current_parameters['content']
created_on = context.current_parameters['created_on']
return hashlib.sha1(content + str(created_on)).hexdigest()
hash_key = db.Column(db.String(40), unique=True, default=content_hash)
created_on = db.Column(db.DateTime,
default=datetime.datetime.utcnow,
index=True)
user_id = db.Column(db.Integer, db.ForeignKey('user.id'))
user = db.relationship('User', backref=db.backref('snaps', lazy='dynamic'))
def __repr__(self):
return '<Snap {!r}>'.format(self.id)
class CarsInfo(db.Model):
__tablename__ = 'cars_info'
id = db.Column(db.Integer, primary_key=True, unique=True)
title = db.Column(db.String(200, 'utf8mb4_bin'), server_default=db.FetchedValue(), info='????')
brand = db.Column(db.String(200, 'utf8mb4_bin'), server_default=db.FetchedValue(), info='??')
cars_local = db.Column(db.String(collation='utf8mb4_bin'), info='?????')
arctic = db.Column(db.String(200, 'utf8mb4_bin'), server_default=db.FetchedValue(), info='??')
regist_date = db.Column(db.String(20, 'utf8mb4_bin'), index=True, server_default=db.FetchedValue(), info='????')
mileage = db.Column(db.String(200, 'utf8mb4_bin'), server_default=db.FetchedValue(), info='????')
gear = db.Column(db.String(200, 'utf8mb4_bin'), server_default=db.FetchedValue(), info='??')
emissions = db.Column(db.String(200, 'utf8mb4_bin'), server_default=db.FetchedValue(), info='????')
price = db.Column(db.String(200, 'utf8mb4_bin'), server_default=db.FetchedValue(), info='??')
img_desc = db.Column(db.String(200, 'utf8mb4_bin'), info='????')
describe = db.Column(db.Text(collation='utf8mb4_bin'), info='????')
created_date = db.Column(db.DateTime, info='????')
picture1 = db.Column(db.String(2000, 'utf8mb4_bin'), server_default=db.FetchedValue(), info='?1')
picture2 = db.Column(db.String(2000, 'utf8mb4_bin'), server_default=db.FetchedValue(), info='?2')
picture3 = db.Column(db.String(2000, 'utf8mb4_bin'), server_default=db.FetchedValue(), info='?3')
picture4 = db.Column(db.String(2000, 'utf8mb4_bin'), server_default=db.FetchedValue(), info='?4')
picture5 = db.Column(db.String(2000, 'utf8mb4_bin'), server_default=db.FetchedValue(), info='?5')
picture6 = db.Column(db.String(2000, 'utf8mb4_bin'), server_default=db.FetchedValue(), info='?6')
def __init__(self, **items):
for key in items:
if hasattr(self, key):
setattr(self, key, items[key])
class UrlPair(db.Model):
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
original_url = db.Column(db.Text(), nullable=False)
shortened_url = db.Column(db.String(32), nullable=False, index=True)
timestamp = db.Column(db.DateTime,
index=True,
default=datetime.utcnow,
nullable=False)
class Setting(db.Model):
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(64), nullable=False)
value = db.Column(db.Text(), nullable=False)
data_type = db.Column(db.String(128), nullable=False)
def __str__(self):
return "<{0}>".format(str(self.name))
class Policy(db.Model):
id = db.Column(db.Integer, primary_key=True)
user_id = db.Column(db.Integer, db.ForeignKey('user_profile.id'))
public = db.Column(db.String(128), default="True")
title = db.Column(db.String(128))
description = db.Column(db.Text(),
info={'widget': CKTextAreaWidget()},
nullable=False)
class Role(db.Model, RoleMixin):
__tablenaem__ = 'role'
id = db.Column(db.Integer(), primary_key=True)
name = db.Column(db.String(80), unique=True)
description = db.Column(db.Text())
def __str__(self):
return str(self.name)
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 Department(db.Model):
__tablename__ = 'departments'
id = db.Column(db.Integer, primary_key=True)
department_name = db.Column(db.String(64), unique=True)
parental_department_id = db.Column(db.Integer)
head_id = db.Column(db.Integer, unique=True)
about = db.Column(db.Text())
class Comment(db.Model):
id = db.Column(db.Integer, primary_key = True)
body = db.Column(db.Text())
created_time = db.Column(db.DateTime, default = db.func.now())
post_id = db.Column(db.Integer, db.ForeignKey('post.id'))
post = db.relationship('Post', backref = db.backref('comments', cascade = 'all, delete-orphan', lazy = 'dynamic'))
user_id = db.Column(db.Integer, db.ForeignKey('user.id'))
user = db.relationship('User')
class Contact(db.Model):
__tablenaem__ = 'contact'
id = db.Column(db.Integer, primary_key=True)
fullname = db.Column(db.String(255))
email = db.Column(db.String(255))
message = db.Column(db.Text())
create_at = db.Column(db.DateTime(), default=db.func.now())
class Setting(db.Model):
"""General manager settings. Currently containing the UUID of the manager.
"""
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(128))
value = db.Column(db.Text())
def __repr__(self):
return '<Setting %r>' % self.name
class Comment(db.Model):
id = db.Column(db.Integer, primary_key=True)
body = db.Column(db.Text())
score = db.Column(db.Integer)
timestamp = db.Column(ArrowType, index=True, default=arrow.utcnow)
user_id = db.Column(db.Integer, db.ForeignKey('user.id'))
book_id = db.Column(db.Integer, db.ForeignKey('book.id'))
def __repr__(self):
return '<Comment score: {0}, body: {1}>'.format(self.score, self.body)
class Dataset(db.Model):
id = db.Column(db.Integer, primary_key=True)
user_id = db.Column(db.Integer, db.ForeignKey('user_profile.id'))
lib_id = db.Column(db.String(128))
public = db.Column(db.String(128), default="True")
title = db.Column(db.String(500), nullable=False)
field_notes = db.Column(db.Text(), info={'widget': CKTextAreaWidget()})
def __repr__(self):
return '<Dataset %r >' % self.title
class Worker(db.Model):
id = db.Column(db.Integer, primary_key=True)
ip_address = db.Column(db.String(15))
port = db.Column(db.Integer())
hostname = db.Column(db.String(50), nullable=True)
status = db.Column(db.String(20))
connection = db.Column(db.String(20))
system = db.Column(db.String(20))
current_task = db.Column(db.String(20))
activity = db.Column(db.String(64))
log = db.Column(db.Text())
time_cost = db.Column(db.Integer())
__table_args__ = (UniqueConstraint('ip_address',
'port',
name='connection_uix'), )
@property
def host(self):
return self.ip_address + ':' + str(self.port)
@property
def is_connected(self):
try:
r = requests.get("http://" + self.host + '/info', timeout=0.5)
r.raise_for_status()
info = r.json()
if self.status != 'disabled':
self.status = info['status']
self.activity = info['activity']
self.log = info['log']
self.time_cost = info['time_cost']
db.session.commit()
return True
except Timeout:
logging.warning("Worker {0} is offline (Timeout)".format(
self.host))
self.connection = 'offline'
db.session.commit()
return False
except ConnectionError:
logging.warning("Worker {0} is offline (Connection Error)".format(
self.host))
self.connection = 'offline'
db.session.commit()
return False
except HTTPError:
logging.warning("Worker {0} is offline (HTTP Error)".format(
self.host))
self.connection = 'offline'
db.session.commit()
return False
def __repr__(self):
return '<Worker %r>' % self.id
class Log(db.Model):
"""Store actions performed by users or by the system on different
entities. The entity gets mapped back via the category (add mixing).
"""
id = db.Column(db.Integer, primary_key=True)
#: gets mapped with mixing
item_id = db.Column(db.Integer(), nullable=False)
#: category connection, like User, Job, Task, Manager
category = db.Column(db.String(64), nullable=False)
log = db.Column(db.Text())
creation_date = db.Column(db.DateTime(), default=datetime.datetime.now)
class Post(db.Model):
id = db.Column(db.Integer, primary_key = True)
body = db.Column(db.Text())
created_time = db.Column(db.DateTime, default = db.func.now())
edited_time = db.Column(db.DateTime, default = db.func.now(), onupdate = db.func.now())
is_edited = db.Column(db.Boolean, default = '0', onupdate = '1')
is_secret = db.Column(db.Boolean, default = '0')
user_id = db.Column(db.Integer, db.ForeignKey('user.id'))
user = db.relationship('User', foreign_keys = [user_id])
wall_id = db.Column(db.Integer, db.ForeignKey('user.id'))
wall = db.relationship('User', foreign_keys = [wall_id], backref = db.backref('wall_posts', cascade = 'all, delete-orphan', lazy = 'dynamic'))
