class DireitoAcesso(db.Model, CRUD):
__tablename__ = "direito_acesso"
id = db.Column(db.Integer, primary_key=True)
id_usuario = db.Column(db.Integer, db.ForeignKey("usuario.id"), nullable=False)
id_sala = db.Column(db.Integer, db.ForeignKey("sala.id"), nullable=False)
nome_sala = db.relationship("Sala", uselist=False)
alive = db.Column(db.Boolean, nullable=False)
def __init__(self, id_usuario, id_sala):
self.id_usuario = id_usuario
self.id_sala = id_sala
self.alive = True
class Conferencia(db.Model):
id = db.Column(db.Integer, unique=True, primary_key=True)
nombre = db.Column(db.String(200), unique=True)
descripcion = db.Column(db.Text)
fecha = db.Column(db.Text)
precio = db.Column(db.Integer)
sillas = db.relationship('Silla',
backref=db.backref('conferecias', lazy='dynamic'))
def __init__(self, nombre, descripcion, fecha, precio):
self.nombre = nombre
self.descripcion = descripcion
self.fecha = fecha
self.precio = precio
class Thing(db.Model):
__tablename__ = 'things'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(length=100), unique=True)
userID = db.Column(db.Integer, db.ForeignKey('users.id'))
triggers = db.relationship('Trigger',
backref='thing',
cascade='all, delete, delete-orphan')
def __init__(self, name):
self.name = name
@staticmethod
def fullyQualifiedName(thingName):
return 'arn:aws:iot:us-east-1:845043522277:thing/' + thingName
class LimboUser(db.Model):
__tablename__ = "limbo_users"
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(128))
surname = db.Column(db.String(128))
email = db.Column(db.String(128))
phone = db.Column(db.String(10))
lab = db.Column(db.String(128))
position = db.Column(db.String(128))
login = db.Column(db.String(128), unique=True)
active = db.Column(db.Boolean, default=False)
comment = db.Column(db.Text)
modified = db.Column(db.DateTime(True))
created = db.Column(db.DateTime(True))
ref_id = db.Column(db.Integer, db.ForeignKey("users.id"))
reference = db.relationship("User", foreign_keys=ref_id)
acl_id = db.Column(db.Integer, db.ForeignKey("acl.id"))
def __repr__(self):
return '<Limbo User {}>'.format(self.login)
def full_name(self):
if self.name and self.surname:
return "%s %s" % (self.name.capitalize(),
self.surname.capitalize())
return "Not available"
def task_ready(self):
return "login: %s and name: %s and surname: %s and email: %s" % (
self.login, self.name, self.surname, self.email)
def to_dict(self):
return {
"id": self.id,
"login": self.login if self.login else "",
"name": self.name if self.name else "",
"fullname": self.full_name(),
"surname": self.surname if self.surname else "",
"email": self.email if self.email else "",
"phone": self.phone if self.phone else "",
"lab": self.lab if self.lab else "",
"position": self.position if self.position else "",
"active": self.active if self.active else "",
"comment": self.comment if self.comment else "",
}
class Bookmark(db.Model):
id = db.Column(db.Integer, primary_key=True)
url = db.Column(db.Text, nullable=False)
date = db.Column(db.DateTime, default=datetime.utcnow)
description = db.Column(db.String(300))
user_id = db.Column(db.Integer, db.ForeignKey('user.id'), nullable=False)
# Set the relationship with the Tag class, need to use a string as it's not defined until later. ToDo: Move it up
# and replace it with the class name for future proofing. The second argument to the relationship call is the
# argument 'secondary' which tells the relationship to use our junction table called "tags" above. We also defined
# a backref called 'bookmarks' which will add an attribute called bookmarks to the other side of the relationship.
# So each tag will get a bookmarks attribute containing a list of the associated bookmarks. Dynamic loading in case
# there are a large number of bookmarks associated with each tag.
# Underscore as I don't want to access this directly from other classes.
_tags = db.relationship('Tag', secondary=tags, lazy='joined', backref=db.backref('bookmarks', lazy='dynamic'))
@staticmethod
def newest(num):
return Bookmark.query.order_by(desc(Bookmark.date)).limit(num)
# In the view and the form, we handle the list of tags as a comma separated string. So it's convenient to create a
# tag property that provides a list of strings as well. The getter takes the contents of the _tags list which holds
# actual Tag model objects. Then it takes the name from each and joins it into a string. So when we ask for the
# value of the tags property on a bookmark, we get a string, with a list of tag names.
@property
def tags(self):
return ",".join([t.name for t in self._tags])
# When we pass a string with a list of tags to be set to this property, we need to find out for each of those tags
# whether it already exists in the database. If it doesn't, we need to insert a new tag into the tag table and then
# add the new model object to the tag list for this bookmark. If it does exist, we can simply retrieve it and put it
# in the list. So if it exists, we create a new method get_or_create that takes the name of a tag and returns a tag
# model instance by either creating or retrieving a tag with that name. We then do a for loop over all the words in
# the string we received and then call the method on each of those words. The resulting list is a list of tag model
# objects and we can assign that to the _tags attribute. Assigning a list of tag objects is all we have to do and
# SQLAlchemy will take it from there and create all the relevant rows in the database.
@tags.setter
def tags(self, string):
# Check if the tags are a string
if string:
self._tags = [Tag.get_or_create(name) for name in string.split(',')]
# If not, set the list ot an empty list, otherwise, it will always fail the test.
else:
self._tags = []
def __repr__(self):
return "Bookmark '{}': '{}'>".format(self.description, self.url)
class pub_id_db(db.Model):
"""
"""
__tablename__ = 'subreddits_subreddit'
id = db.Column(db.Integer, primary_key=True)
journal_title = db.Column(db.String(PUB), unique=True)
issn = db.Column(db.String(SUBREDDIT.MAX_DESCRIPTION))
admin_id = db.Column(db.Integer, db.ForeignKey('users_user.id'))
created_on = db.Column(db.DateTime, default=db.func.now())
updated_on = db.Column(db.DateTime,
default=db.func.now(),
onupdate=db.func.now())
threads = db.relationship('Thread', backref='subreddit', lazy='dynamic')
status = db.Column(db.SmallInteger, default=SUBREDDIT.ALIVE)
class Usuario(db.Model, CRUD):
__tablename__ = "usuario"
id = db.Column(db.Integer, primary_key=True)
nome = db.Column(db.String(80), nullable=False)
tipo = db.Column(db.Enum(TipoUsuario), nullable=False)
email = db.Column(db.String(100), nullable=False, unique=True)
rfid = db.Column(db.String(16), nullable=False, unique=True)
direito_acesso = db.relationship("DireitoAcesso", cascade="delete")
last_update = db.Column(db.DateTime(), nullable=False)
alive = db.Column(db.Boolean, nullable=False)
def __init__(self, nome, email, rfid, tipo):
self.nome = nome
self.email = email
self.rfid = rfid
self.tipo = tipo
self.alive = True
self.last_update = datetime.now()
class TasksModel(db.Model):
"""
任务
"""
__tablename__ = "tasks_model"
id = db.Column(db.Integer, primary_key=True)
task_no = db.Column(db.String(128),
nullable=False,
default=gen_task_no,
comment="备注")
task_type = db.Column(db.Enum('cron', 'interval', 'date'),
server_default='cron',
nullable=False)
name = db.Column(db.String(128), nullable=False, comment="任务名")
project_id = db.Column(db.ForeignKey("requirement_model.id"))
project = db.relationship('RequirementModel',
backref=db.backref('tasks_model',
lazy='dynamic'))
comments = db.Column(db.String(256), nullable=True, comment="备注")
year = db.Column(db.Integer, nullable=True, comment="年")
month = db.Column(db.Integer, nullable=True, comment="月")
day = db.Column(db.Integer, nullable=True, comment="日")
week = db.Column(db.Integer, nullable=True, comment="周")
day_of_week = db.Column(db.Integer, nullable=True, comment="周期")
hour = db.Column(db.Integer, nullable=True, comment="时")
minute = db.Column(db.Integer, nullable=True, comment="分")
second = db.Column(db.Integer, nullable=True, comment="秒")
status = db.Column(db.Boolean, default=False, comment="状态")
is_deleted = db.Column(db.Boolean, default=False)
dt_create = db.Column(db.DateTime, default=time_utils.now_dt)
dt_update = db.Column(db.DateTime,
default=time_utils.now_dt,
onupdate=time_utils.now_dt)
def __repr__(self):
return self.name
def __str__(self):
return self.name
class LogDB(db.Model):
__tablename__ = "logs"
id = db.Column(db.Integer, primary_key=True)
created = db.Column(db.DateTime(True), default=dt.utcnow)
event = db.Column(db.Text, nullable=False)
author_id = db.Column(db.Integer,
db.ForeignKey("users.id"),
nullable=False)
author = db.relationship("User", foreign_keys=author_id)
project_id = db.Column(db.Integer, db.ForeignKey("projects.id"))
project = db.relationship("Project", foreign_keys=project_id)
user_id = db.Column(db.Integer, db.ForeignKey("users.id"))
user = db.relationship("User", foreign_keys=user_id)
articles_id = db.Column(db.Integer, db.ForeignKey("project_articles.id"))
articles = db.relationship("ArticleDB", foreign_keys=articles_id)
extension_id = db.Column(db.Integer, db.ForeignKey("project_extension.id"))
extension = db.relationship("Extend", foreign_keys=extension_id)
files_id = db.Column(db.Integer, db.ForeignKey("project_files.id"))
files = db.relationship("File", foreign_keys=files_id)
resources_id = db.Column(db.Integer, db.ForeignKey("project_resources.id"))
resources = db.relationship("Resources", foreign_keys=resources_id)
register_id = db.Column(db.Integer, db.ForeignKey("register.id"))
register = db.relationship("Register", foreign_keys=register_id)
def __repr__(self):
return "<Log event for project {}>".format(self.project.get_name())
def brief(self):
event = self.event[0].upper() + self.event[1:]
creator = self.author.full_name() if self.author else "Unknown author"
return {
"created": self.created,
"event": "%s by %s" % (event, creator)
}
def to_web(self):
event = self.event[0].upper() + self.event[1:]
creator = self.author.full_name(
) if self.author else "Author is unknown"
msg = "%s by %s" % (event, creator)
if self.project:
item = self.project.name
elif self.register:
item = self.register.project_id()
elif self.user:
item = self.user.full_name()
else:
item = ""
return {
"project": self.project.name if self.project else "",
"item": item,
"date": self.created.strftime("%Y-%m-%d %X %Z"),
"date_full": self.created.strftime("%c"),
"message": msg
}
def to_dict(self):
event = self.event[0].upper() + self.event[1:]
creator = self.author.full_name(
) if self.author else "Author is unknown"
msg = "%s by %s" % (event, creator)
short = shorten(msg, width=50, placeholder="...")
return {
"date": self.created.strftime("%Y-%m-%d %X %Z"),
"date_full": self.created.strftime("%c"),
"message": short,
"message_full": msg
}
class Comment(FullText, db.Model):
"""
This class is here because comments can only be made on threads,
so it is contained in the threads module.
Note the parent_id and children values. A comment can be commented
on, so a comment has a one to many relationship with itself.
Backrefs:
A comment can refer to its parent thread with 'thread'
A comment can refer to its parent comment (if exists) with 'parent'
"""
__tablename__ = 'threads_comment'
__fulltext_columns__ = ('text', )
id = db.Column(db.Integer, primary_key=True)
text = db.Column(db.String(THREAD.MAX_BODY), default=None)
user_id = db.Column(db.Integer, db.ForeignKey('users_user.id'))
thread_id = db.Column(db.Integer, db.ForeignKey('threads_thread.id'))
parent_id = db.Column(db.Integer, db.ForeignKey('threads_comment.id'))
children = db.relationship('Comment',
backref=db.backref('parent', remote_side=[id]),
lazy='dynamic')
depth = db.Column(db.Integer, default=1) # savet at depth 1
created_on = db.Column(db.DateTime, default=now)
updated_on = db.Column(db.DateTime, default=now)
votes = db.Column(db.Integer, default=1)
@reconstructor
def setup_fields(self):
self.text = format_comment(self.text)
def __repr__(self):
return '<Comment %r>' % (self.text[:25])
def set_depth(self):
"""
call after initializing
"""
if self.parent:
self.depth = self.parent.depth + 1
db.session.commit()
def get_comments(self, order_by='votes'):
"""
default order by votes
"""
if order_by == 'votes':
return self.children.order_by(db.desc(Comment.votes)).\
all()[:THREAD.MAX_COMMENTS]
elif order_by == 'timestamp':
return self.comments.order_by(db.desc(Comment.votes)).\
all()[:THREAD.MAX_COMMENTS]
def pretty_date(self, typeof='created'):
"""
returns a humanized version of the raw age of this thread,
eg: 34 minutes ago versus 2040 seconds ago.
"""
if typeof == 'created':
logger.info(arrow.get(self.created_on, 'UTC'))
logger.info(arrow.get(self.created_on, 'UTC').humanize())
return arrow.get(self.created_on, 'UTC').humanize()
elif typeof == 'updated':
return arrow.get(self.updated_on, 'UTC').humanize()
def has_voted(self, user_id):
select_votes = comment_upvotes.select(
db.and_(comment_upvotes.c.user_id == user_id,
comment_upvotes.c.comment_id == self.id))
rs = db.engine.execute(select_votes)
return False if rs.rowcount == 0 else True
def vote(self, user_id):
"""
Add a vote from user id to a comment.
"""
already_voted = self.has_voted(user_id)
vote_status = None
if not already_voted:
# vote up the thread
db.engine.execute(comment_upvotes.insert(),
user_id=user_id,
comment_id=self.id)
self.votes = self.votes + 1
vote_status = True
else:
# unvote the thread
db.engine.execute(
comment_upvotes.delete(
db.and_(comment_upvotes.c.user_id == user_id,
comment_upvotes.c.comment_id == self.id)))
self.votes = self.votes - 1
vote_status = False
db.session.commit() # for the vote count
return vote_status
def comment_on(self):
"""
when someone comments on this particular comment
"""
pass
class Publication(FullText, db.Model):
__tablename__ = 'publication'
__fulltext_columns__ = (
'pub_title',
'pub_authors',
'pub_abstract',
)
__table_args__ = (db.UniqueConstraint('pub_doi',
'pub_pmid',
'pub_pmc',
'pub_arxiv',
'pub_biorxiv',
name='_pub_unique'), )
# Publication information
id = db.Column(db.Integer, primary_key=True)
pub_title = db.Column(db.String(300))
pub_authors = db.Column(db.String(1000))
pub_abstract = db.Column(db.Text())
pub_doi = db.Column(db.String(250))
pub_pmid = db.Column(db.Integer())
pub_pmc = db.Column(db.Integer())
pub_arxiv = db.Column(db.String(25))
pub_biorxiv = db.Column(db.String(250))
pub_biorxiv_url = db.Column(db.String(250))
pub_url = db.Column(db.String(250))
pub_pdf_url = db.Column(db.String(250))
pub_journal = db.Column(db.String(100))
pub_date = db.Column(db.DateTime)
pub_created_on = db.Column(db.DateTime, default=now)
pub_thumbnail = db.Column(db.String(THREAD.MAX_LINK), default=None)
threads = db.relationship('Thread', back_populates='publication')
downloads = db.relationship('Publication_Download',
back_populates='publication')
@property
def download_count(self):
return db.session.query(Publication_Download) \
.filter(Publication_Download.publication_id == self.id) \
.count()
@property
def pub_id(self):
if self.pub_pmid:
return self.pub_pmid
elif self.pub_pmc:
return f"PMC{self.pub_pmc}"
elif self.pub_arxiv:
return f"arxiv-{self.pub_arxiv}"
elif self.pub_biorxiv:
return f"biorxiv-{self.pub_biorxiv}"
else:
return self.pub_doi
@validates('pub_title', 'pub_authors', 'pub_abstract', 'pub_journal')
def truncate(self, key, value):
max_len = getattr(self.__class__, key).prop.columns[0].type.length
if value and max_len:
if len(value) > max_len:
return value[:max_len]
return value
def fetch_abstract(self):
"""
Used to process text within an abstract
"""
if self.pub_abstract:
return linkify(self.pub_abstract)
def fetch_github_links(self):
if self.pub_abstract:
return find_github_links(self.pub_abstract)
def mark_downloaded(self, user_id):
"""
Marks a publication as having been downloaded.
"""
td = Publication_Download(user_id=user_id, publication_id=self.id)
td, exists = get_or_create(Publication_Download,
user_id=user_id,
publication_id=self.id)
def has_downloaded(self, user_id):
"""
Has the user downloaded the PDF?
"""
rs = Publication_Download.query.filter(
db.and_(Publication_Download.user_id == user_id,
Publication_Download.publication_id == self.id))
return True if rs.first() else False
def __repr__(self):
return '<Publication %r>' % (self.pub_title)
class Apartment(db.Model):
id = db.Column(db.Integer, primary_key=True)
public_id = db.Column(db.String(), nullable=False)
love = db.Column(db.Integer, default=0)
apartment_name = db.Column(db.String(), nullable=False)
description = db.Column(db.String(), nullable=False)
client = db.relationship('Client', backref='housing', lazy=True)
review = db.relationship('Review', backref='reviews', lazy=True)
sold_by = db.Column(db.String())
purchased_by = db.Column(db.String())
agent = db.Column(db.Integer, db.ForeignKey('agent.id'))
sold = db.Column(db.Boolean, nullable=False, default=False)
rented = db.Column(db.Boolean, nullable=False, default=False)
for_sale = db.Column(db.Boolean, nullable=False, default=False)
for_rent = db.Column(db.Boolean, nullable=False, default=False)
country = db.Column(db.String(), nullable=False)
city = db.Column(db.String(), nullable=False)
neighbourhood = db.Column(db.String(), nullable=False)
location = db.Column(db.String(), nullable=False)
postal_code = db.Column(db.String(), nullable=False)
property_status = db.Column(db.String(), nullable=False)
property_type = db.Column(db.String(), nullable=False)
no_of_bedrooms = db.Column(db.Integer, nullable=False, default=0)
no_of_bathrooms = db.Column(db.Integer, nullable=False, default=0)
area_size = db.Column(db.Integer, nullable=False)
property_id = db.Column(db.Integer, nullable=False)
no_of_garages = db.Column(db.Integer, nullable=False, default=0)
year_built = db.Column(db.String, nullable=False)
video_tour = db.Column(db.String)
video_data = db.Column(db.LargeBinary)
image_file = db.Column(db.String(20), nullable=False)
photo_data = db.Column(db.LargeBinary)
image_file2 = db.Column(db.String(20), nullable=False)
photo_data2 = db.Column(db.LargeBinary)
image_file3 = db.Column(db.String(20), nullable=False)
photo_data3 = db.Column(db.LargeBinary)
image_file4 = db.Column(db.String(20), nullable=False)
photo_data4 = db.Column(db.LargeBinary)
image_file5 = db.Column(db.String(20), nullable=False)
photo_data5 = db.Column(db.LargeBinary)
image_file6 = db.Column(db.String(20), nullable=False)
photo_data6 = db.Column(db.LargeBinary)
image_file7 = db.Column(db.String(20), nullable=False)
photo_data7 = db.Column(db.LargeBinary)
image_file8 = db.Column(db.String(20), nullable=False)
photo_data8 = db.Column(db.LargeBinary)
image_file9 = db.Column(db.String(20), nullable=False)
photo_data9 = db.Column(db.LargeBinary)
image_file0 = db.Column(db.String(20), nullable=False)
photo_data0 = db.Column(db.LargeBinary)
floor_plan_file = db.Column(db.String(20), nullable=False)
floor_plan_photo_data = db.Column(db.LargeBinary)
price = db.Column(db.Integer)
second_price = db.Column(db.Integer)
price_label = db.Column(db.String())
size_prefix = db.Column(db.String(), default="sqft")
date_uploaded = db.Column(db.DateTime,
nullable=False,
default=datetime.now)
cleared = db.Column(db.Boolean, default=False)
air_conditioning = db.Column(db.Boolean, default=False)
laundry = db.Column(db.Boolean, default=False)
refrigerator = db.Column(db.Boolean, default=False)
washer = db.Column(db.Boolean, default=False)
barbecue = db.Column(db.Boolean, default=False) # change to balcony
lawn = db.Column(db.Boolean, default=False)
sauna = db.Column(db.Boolean, default=False)
wifi = db.Column(db.Boolean, default=False)
dryer = db.Column(db.Boolean, default=False)
microwave = db.Column(db.Boolean, default=False)
swimming_pool = db.Column(db.Boolean, default=False)
window_coverings = db.Column(db.Boolean, default=False)
gym = db.Column(db.Boolean, default=False)
outdoor_shower = db.Column(db.Boolean, default=False)
tv_cable = db.Column(db.Boolean, default=False)
villa = db.Column(db.Boolean, default=False) # change to fireplace
class Thread(db.Model):
"""
We will mimic reddit, with votable threads. Each thread may have either
a body text or a link, but not both.
"""
__tablename__ = 'threads_thread'
__table_args__ = (db.UniqueConstraint('subreddit_id',
'publication_id',
name='_sub_pub_unique'), )
id = db.Column(db.Integer, primary_key=True)
# Publication information
publication_id = db.Column(db.Integer,
db.ForeignKey('publication.id'),
nullable=False)
publication = db.relationship('Publication',
back_populates='threads',
uselist=False)
user_id = db.Column(db.Integer, db.ForeignKey('users_user.id'))
subreddit_id = db.Column(db.Integer,
db.ForeignKey('subreddits_subreddit.id'))
created_on = db.Column(db.DateTime, default=now)
updated_on = db.Column(db.DateTime, default=now, onupdate=now)
comments = db.relationship('Comment', backref='thread', lazy='dynamic')
status = db.Column(db.SmallInteger, default=THREAD.ALIVE)
votes = db.Column(db.Integer, default=0)
saves = db.Column(db.Integer, default=0)
n_comments = db.Column(db.Integer, default=0)
# Gives bonus for pubs with pdfs.
# hotness = db.column_property(db.func.ROUND(db.func.COALESCE(publication.pub_pdf_url, 0)*5 + 100+(db.func.LN(votes+1)*50 - db.func.POW(db.func.LN(1+db.func.TIMESTAMPDIFF(text('SECOND'), created_on, db.func.UTC_TIMESTAMP())), 2)), 2))
hotness = db.column_property(
(100 + (db.func.LN(votes + (saves / 2) + (n_comments) + 2) * 50)) -
db.func.POW(
db.func.LN(2 + db.func.TIMESTAMPDIFF(text('SECOND'), created_on,
db.func.UTC_TIMESTAMP())), 2))
def __repr__(self):
return '<Thread %r>' % (self.id)
def get_comments(self, order_by='votes'):
"""
default order by timestamp
return top level
"""
if order_by == 'votes':
return self.comments.filter_by(depth=1). \
order_by(db.desc(Comment.votes)).all()[:THREAD.MAX_COMMENTS]
elif order_by == 'timestamp':
return self.comments.filter_by(depth=1). \
order_by(db.desc(Comment.created_on)).all()[:THREAD.MAX_COMMENTS]
def get_status(self):
"""
returns string form of status, 0 = 'dead', 1 = 'alive'
"""
return THREAD.STATUS[self.status]
def pretty_date(self, typeof='created'):
"""
returns a humanized version of the raw age of this thread,
eg: 34 minutes ago versus 2040 seconds ago.
"""
return arrow.get(self.created_on).humanize()
def add_comment(self, comment_text, comment_parent_id, user_id):
"""
add a comment to this particular thread
"""
if len(comment_parent_id) > 0:
# parent_comment = Comment.query.get_or_404(comment_parent_id)
# if parent_comment.depth + 1 > THREAD.MAX_COMMENT_DEPTH:
# flash('You have exceeded the maximum comment depth')
comment_parent_id = int(comment_parent_id)
comment = Comment(thread_id=self.id,
user_id=user_id,
text=comment_text,
parent_id=comment_parent_id)
else:
comment = Comment(thread_id=self.id,
user_id=user_id,
text=comment_text)
db.session.add(comment)
db.session.commit()
comment.set_depth()
return comment
def get_voter_ids(self):
"""
return ids of users who voted this thread up
"""
select = thread_upvotes.select(thread_upvotes.c.thread_id == self.id)
rs = db.engine.execute(select)
ids = rs.fetchall() # list of tuples
return ids
def has_saved(self, user_id):
"""
did the user save already
"""
select_stars = thread_saves.select(
db.and_(thread_saves.c.user_id == user_id,
thread_saves.c.thread_id == self.id))
rs = db.engine.execute(select_stars)
return False if rs.rowcount == 0 else True
def save(self, user_id):
"""
allow a user to save a thread. if we have savered already
(and they are clicking again), this means that they are trying
to unsave the thread, return status of the star for that user
"""
already_saved = self.has_saved(user_id)
save_status = None
if not already_saved:
# star up the thread
db.engine.execute(thread_saves.insert(),
user_id=user_id,
thread_id=self.id)
self.saves = self.saves + 1
save_status = True
else:
# unstar the thread
db.engine.execute(
thread_saves.delete(
db.and_(thread_saves.c.user_id == user_id,
thread_saves.c.thread_id == self.id)))
self.saves = self.saves - 1
vote_status = False
db.session.commit() # for the vote count
return save_status
def has_voted(self, user_id):
"""
did the user vote already
"""
select_votes = thread_upvotes.select(
db.and_(thread_upvotes.c.user_id == user_id,
thread_upvotes.c.thread_id == self.id))
rs = db.engine.execute(select_votes)
return False if rs.rowcount == 0 else True
def vote(self, user_id):
"""
allow a user to vote on a thread. if we have voted already
(and they are clicking again), this means that they are trying
to unvote the thread, return status of the vote for that user
"""
already_voted = self.has_voted(user_id)
vote_status = None
if not already_voted:
# vote up the thread
db.engine.execute(thread_upvotes.insert(),
user_id=user_id,
thread_id=self.id)
self.votes = self.votes + 1
vote_status = True
else:
# unvote the thread
db.engine.execute(
thread_upvotes.delete(
db.and_(thread_upvotes.c.user_id == user_id,
thread_upvotes.c.thread_id == self.id)))
self.votes = self.votes - 1
vote_status = False
db.session.commit() # for the vote count
return vote_status
@classmethod
def similar_threads(cls, query):
"""
Return threads with the same publication ID.
"""
return cls.query.filter(cls.publication_id == query).all()
class Tweet(db.Model):
__tablename__ = "tweets"
id = db.Column(db.Integer, autoincrement=True, primary_key=True)
text = db.Column(db.String(140), nullable=False)
user_id = db.Column(db.Integer, db.ForeignKey('users.id'), nullable=False)
user = db.relationship('User', backref=db.backref('tweets', lazy=True))
class Extend(db.Model):
__tablename__ = "project_extension"
id = db.Column(db.Integer, primary_key=True)
extend = db.Column(db.Boolean)
exception = db.Column(db.Boolean)
reason = db.Column(db.Text)
hours = db.Column(db.Integer, db.CheckConstraint("cpu>=0"))
created = db.Column(db.DateTime(True))
modified = db.Column(db.DateTime(True))
accepted = db.Column(db.Boolean)
processed = db.Column(db.Boolean, default=False)
decision = db.Column(db.Text)
done = db.Column(db.Boolean, default=False)
present_use = db.Column(db.Integer)
present_total = db.Column(db.Integer)
usage_percent = db.Column(db.String(10))
activate = db.Column(db.Boolean, default=False)
transform = db.Column(db.String(1), default="")
doc_id = db.Column(db.Integer, db.ForeignKey("project_files.id"))
doc = db.relationship("File", foreign_keys=[doc_id])
project_id = db.Column(db.Integer, db.ForeignKey("projects.id"))
project = db.relationship("Project", foreign_keys=project_id)
approve_id = db.Column(db.Integer, db.ForeignKey("users.id"))
approve = db.relationship("User", foreign_keys=approve_id)
def __repr__(self):
return "<Extension for project {}>".format(self.project.get_name())
def api(self):
return {
"cpu": self.hours,
"finish": self.project.resources.ttl.strftime("%Y-%m-%d %X"),
"start": self.project.resources.created.strftime("%Y-%m-%d %X"),
"notify": self.project.responsible.email,
"name": self.project.responsible.full_name(),
"id": self.id,
"add_hours": self.extend,
"project": self.project.get_name(),
"transform": self.transform
}
def to_dict(self):
start = self.created.strftime("%Y-%m-%d %X %Z") if self.created else ""
mod = self.modified.strftime("%Y-%m-%d %X %Z") if self.modified else ""
approve = self.approve.full_name() if self.approve else ""
if hasattr(self.project, "consumed"):
conso = self.project.consumed
else:
conso = ""
if hasattr(self.project, "consumed_use"):
use = self.project.consumed_use
else:
use = ""
return {
"id": self.id,
"extension": self.extend,
"exception": self.exception,
"reason": self.reason,
"hours": self.hours,
"created": start,
"modified": mod,
"accepted": self.accepted,
"processed": self.processed,
"decision": self.decision,
"done": self.done,
"activate": self.activate,
"transform": self.transform,
"project": self.project.id,
"total": self.present_total,
"initial_use": self.present_use,
"initial_usage": self.usage_percent,
"present_use": conso,
"present_usage": use,
"name": self.project.get_name(),
"approve": approve,
"responsible": self.project.responsible.full_name(),
"responsible_login": self.project.responsible.login
}
class Obozn(db.Model):
__tablename__ = "vacaobozn"
id = db.Column('id_6', db.Integer, primary_key=True)
title = db.Column("aobozn", db.String(50))
kontkurs = db.relationship("Kontkurs", backref=db.backref("aobozn", lazy="joined"))
class Raspnagr(db.Model):
id = db.Column('id_51', db.Integer, primary_key=True)
kontkurs_id = db.Column("kont", db.Integer, db.ForeignKey('kontkurs.id_1'))
kontgrp_id = db.Column("kontid", db.Integer, db.ForeignKey('kontgrp.id_7'))
op = db.Column("op", db.Integer)
nt = db.Column(db.Integer, db.ForeignKey("normtime.id_40"))
sem = db.Column(db.Integer)
pred_id = db.Column("pred", db.Integer, db.ForeignKey("vacpred.id_15"))
kaf_id = db.Column("kaf", db.Integer, db.ForeignKey("vackaf.id_17"))
fobuch = db.Column(db.SmallInteger)
afobuch = db.Column(db.SmallInteger)
nagrid = db.Column(db.Integer)
h = db.Column(db.Float)
hy = db.Column(db.Integer)
dbeg = db.Column(db.Date)
days = db.Column(db.Integer)
prep_id = db.Column("prep", db.Integer, db.ForeignKey('prepods.id_61'))
aud_id = db.Column("aud", db.Integer, db.ForeignKey('auditories.id_60'))
nagrtype = db.Column(db.SmallInteger)
nagrprop = db.Column(db.Integer)
nagr_h = db.Column(db.Float)
stud = db.Column(db.Integer)
editstud = db.Column(db.Integer)
rnprep = db.Column(db.Integer)
# hy1 = db.Column(db.Integer)
# hy2 = db.Column(db.Integer)
syear = db.Column(db.Integer)
raspis = db.relationship('Raspis', backref=db.backref('raspnagr', lazy='joined'), lazy='dynamic')
raspis_zaoch = db.relationship('RaspisZaoch', backref=db.backref('raspnagr', lazy='joined'), lazy='dynamic')
kontlist = db.relationship('Kontlist', backref='raspnagr', lazy='subquery')
kontgrplist = db.relationship('Kontgrplist', backref='raspnagr', lazy='subquery')
@classmethod
def get_for_kontgrp(self, kontgrp):
raspnagrs = Raspnagr.query.filter(
or_(Raspnagr.kontgrp_id == kontgrp.id, Raspnagr.kontkurs_id == kontgrp.kont_id)
)
return raspnagrs
@classmethod
def get_for_kontkurs_id(self, kontkurs_id, sem=1, subgroup_number=0):
Kontgrp2 = aliased(Kontgrp)
KontgrpCommon = aliased(Kontgrp)
KontgrpParent = aliased(Kontgrp)
if not isinstance(kontkurs_id, list):
kontkurs_id = [kontkurs_id, ]
if int(subgroup_number):
filter_ = and_(or_(
Raspnagr.kontkurs_id.in_(kontkurs_id),
Kontlist.kontkurs_id.in_(kontkurs_id),
KontgrpCommon.kont_id.in_(kontkurs_id),
), or_(
KontgrpCommon.id == None,
and_(KontgrpParent.id == None, KontgrpCommon.ngroup == subgroup_number),
KontgrpParent.ngroup == subgroup_number
), )
else:
filter_ = or_(
Raspnagr.kontkurs_id.in_(kontkurs_id),
KontgrpCommon.kont_id.in_(kontkurs_id),
Kontlist.kontkurs_id.in_(kontkurs_id),
)
raspnagrs = Raspnagr.query.filter(
Raspnagr.id.in_(Raspnagr.query
.outerjoin(Kontgrp, Raspnagr.kontgrp_id == Kontgrp.id)
.outerjoin(Kontgrplist, Kontgrplist.op == Raspnagr.op)
.outerjoin(Kontlist, Kontlist.op == Raspnagr.op)
.outerjoin(Kontgrp2, Kontgrp2.id == Kontgrplist.kontgrp_id)
.outerjoin(KontgrpCommon, func.coalesce(Kontgrp2.id, Kontgrp.id) == KontgrpCommon.id)
.outerjoin(KontgrpParent, KontgrpCommon.parent_id == KontgrpParent.id)
.filter(filter_).filter(Raspnagr.sem == sem).with_entities(Raspnagr.id)))
return raspnagrs
class User(UserMixin, db.Model):
__tablename__ = "users"
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(128))
surname = db.Column(db.String(128))
email = db.Column(db.String(128))
phone = db.Column(db.String(10))
lab = db.Column(db.String(128))
position = db.Column(db.String(128))
login = db.Column(db.String(128), unique=True)
acl_id = db.Column(db.Integer, db.ForeignKey("acl.id"))
acl = db.relationship("ACLDB", uselist=False, backref="users")
project = db.relationship("Project", secondary="user_project")
active = db.Column(db.Boolean, default=False)
comment = db.Column(db.Text)
modified = db.Column(db.DateTime(True))
created = db.Column(db.DateTime(True))
uid = db.Column(db.Integer)
def __repr__(self):
return '<User {}>'.format(self.login)
def full(self):
return "%s <%s> [%s]" % (self.full_name(), self.email, self.login)
def full_name(self):
if self.name and self.surname:
return "%s %s" % (self.name.capitalize(),
self.surname.capitalize())
return "%s %s" % (self.name, self.surname)
def permissions(self):
perm = []
if self.acl.is_user:
perm.append("user")
if self.acl.is_responsible:
perm.append("responsible")
if self.acl.is_manager:
perm.append("manager")
if self.acl.is_tech:
perm.append("tech")
if self.acl.is_committee:
perm.append("committee")
if self.acl.is_admin:
perm.append("admin")
return perm
def project_names(self):
projects = list(self.project)
names = map(lambda x: x.get_name(), projects)
return list(names)
def project_ids(self):
projects = list(self.project)
ids = map(lambda x: x.id, projects)
return list(ids)
def details(self):
start = self.acl.created.strftime(
"%Y-%m-%d %X %Z") if self.acl.created else ""
mod = self.acl.modified.strftime(
"%Y-%m-%d %X %Z") if self.acl.modified else ""
return {
"id": self.id,
"login": self.login,
"name": self.name,
"fullname": self.full_name(),
"surname": self.surname,
"email": self.email,
"phone": self.phone,
"lab": self.lab,
"position": self.position,
"active": self.active,
"comment": self.comment,
# "last_seen": self.last_seen.isoformat() + 'Z',
"modified": self.modified,
"created": self.created,
"acl_id": self.acl.id,
"user": self.acl.is_user,
"responsible": self.acl.is_responsible,
"manager": self.acl.is_manager,
"tech": self.acl.is_tech,
"committee": self.acl.is_committee,
"admin": self.acl.is_admin,
"acl_created": start,
"acl_modified": mod,
"uid": self.uid,
"brief": self.full(),
"projects": self.project_names()
}
def info_acl(self):
return {
"active": self.active,
"user": self.acl.is_user,
"responsible": self.acl.is_responsible,
"manager": self.acl.is_manager,
"tech": self.acl.is_tech,
"committee": self.acl.is_committee,
"admin": self.acl.is_admin,
"login": self.login,
"name": self.name,
"surname": self.surname,
"email": self.email
}
def to_dict(self):
return {
"id": self.id,
"login": self.login,
"name": self.name,
"fullname": self.full_name(),
"surname": self.surname,
"email": self.email,
"phone": self.phone,
"lab": self.lab,
"position": self.position,
"active": self.active,
"comment": self.comment,
# "last_seen": self.last_seen.isoformat() + 'Z',
"modified": self.modified,
"uid": self.uid,
"created": self.created
}
class Faculty(db.Model):
__tablename__ = "vacfac"
id = db.Column('id_5', db.Integer, primary_key=True)
title = db.Column("fac", db.String(65))
kontkurs = db.relationship('Kontkurs', backref=db.backref('faculty', lazy='joined'), lazy='dynamic')
class Project(db.Model):
__tablename__ = "projects"
id = db.Column(db.Integer, primary_key=True)
title = db.Column(db.String(256))
description = db.Column(db.String)
scientific_fields = db.Column(db.String(256))
genci_committee = db.Column(db.String(256))
numerical_methods = db.Column(db.String)
computing_resources = db.Column(db.String)
project_management = db.Column(db.String)
project_motivation = db.Column(db.String)
active = db.Column(db.Boolean, default=False)
modified = db.Column(db.DateTime(True))
created = db.Column(db.DateTime(True))
comment = db.Column(db.Text)
gid = db.Column(db.Integer)
privileged = db.Column(db.Boolean, default=False)
name = db.Column(db.String(128))
type = db.Column(db.String(1))
responsible_id = db.Column(db.Integer, db.ForeignKey("users.id"))
responsible = db.relationship("User",
backref="responsible",
uselist=False,
foreign_keys=responsible_id)
files = db.relationship("File", back_populates="project")
articles = db.relationship("ArticleDB", back_populates="project")
users = db.relationship("User", secondary="user_project")
approve_id = db.Column(db.Integer, db.ForeignKey("users.id"))
approve = db.relationship("User", foreign_keys=approve_id)
resources_id = db.Column(db.Integer, db.ForeignKey("project_resources.id"))
resources = db.relationship("Resources", foreign_keys=resources_id)
ref_id = db.Column(db.Integer, db.ForeignKey("register.id"))
ref = db.relationship("Register", foreign_keys=ref_id)
def __repr__(self):
return '<Project {}>'.format(self.get_name())
def get_responsible(self):
return self.responsible
def get_name(self):
if self.name:
return self.name
pid = self.id
genre = self.type
return "%s%s" % (genre, str(pid).zfill(3))
def api_resources(self):
return {
"cpu": self.resources.cpu,
"finish": self.resources.ttl.strftime("%Y-%m-%d %X"),
"start": self.resources.created.strftime("%Y-%m-%d %X"),
"notify": self.responsible.email,
"name": self.responsible.full_name(),
"id": self.id,
"project": self.get_name()
}
def pretty_dict(self):
rec = self.to_dict()
rec["approve"] = rec["approve"]["fullname"]
rec["responsible"] = rec["responsible"]["fullname"]
rec["resources"] = rec["resources"]["cpu"]
tmp = []
for user in rec["users"]:
tmp.append("%s <%s>" % (user["fullname"], user["email"]))
rec["users"] = tmp
return rec
def with_usage(self):
result = self.to_dict()
result["consumed"] = getattr(self, "consumed", 0)
result["consumed_use"] = getattr(self, "consumed_use", 0)
return result
def to_dict(self):
if self.created:
created = self.created.strftime("%Y-%m-%d %X %Z")
else:
created = ""
if self.modified:
modified = self.modified.strftime("%Y-%m-%d %X %Z")
else:
modified = ""
if self.resources.created:
start = self.resources.created.strftime("%Y-%m-%d %X %Z")
else:
start = ""
if self.resources.ttl:
end = self.resources.ttl.strftime("%Y-%m-%d %X %Z")
else:
end = ""
if self.responsible:
responsible = self.responsible.to_dict()
responsible_login = self.responsible.login
else:
responsible = ""
responsible_login = ""
if self.ref:
ref = self.ref.id
else:
ref = ""
return {
"id": self.id,
"title": self.title,
"description": self.description,
"scientific_fields": self.scientific_fields,
"genci_committee": self.genci_committee,
"numerical_methods": self.numerical_methods,
"computing_resources": self.computing_resources,
"project_management": self.project_management,
"project_motivation": self.project_motivation,
"active": self.active,
"modified": modified,
"created": created,
"comment": self.comment,
"gid": self.gid,
"privileged": self.privileged,
"name": self.get_name(),
"type": self.type,
"responsible": responsible,
"responsible_login": responsible_login,
"files": list(map(lambda x: x.path, self.files)),
"articles": list(map(lambda x: x.info, self.articles)),
"users": list(map(lambda x: x.to_dict(), self.users)),
"approve": self.approve.to_dict(),
"resources": self.resources.to_dict(),
"allocation_start": start,
"allocation_end": end,
"ref": ref
}
class User(db.Model):
"""
"""
__tablename__ = 'users_user'
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(USER.MAX_USERNAME), unique=True)
email = db.Column(db.String(USER.MAX_EMAIL), unique=True)
email_verified = db.Column(db.Boolean())
email_token = db.Column(db.String(18), default=random_string)
password = db.Column(db.String(USER.MAX_PASSW))
created_on = db.Column(db.DateTime, default=now)
threads = db.relationship('Thread', backref='user', lazy='dynamic')
comments = db.relationship('Comment', backref='user', lazy='dynamic')
subreddits = db.relationship('Subreddit', backref='user', lazy='dynamic')
university = db.Column(db.String(100))
status = db.Column(db.SmallInteger, default=USER.ALIVE)
role = db.Column(db.SmallInteger, default=USER.USER)
subreddit_subs = db.Column(
db.JSON, default={"subs": sum(BASE_SUBREDDITS.values(), [])})
def __repr__(self):
return '<User %r>' % (self.username)
def get_status(self):
"""
returns string form of status, 0 = 'dead', 1 = 'alive'
"""
return USER.STATUS[self.status]
def get_role(self):
"""
analogous to above but for roles
"""
return USER.ROLE[self.role]
def get_thread_karma(self):
"""
fetch the number of votes this user has had on his/her threads
1.) Get id's of all threads by this user
2.) See how many of those threads also were upvoted but not by
the person him/her self.
"""
thread_ids = [t.id for t in self.threads]
select = thread_upvotes.select(
db.and_(thread_upvotes.c.thread_id.in_(thread_ids),
thread_upvotes.c.user_id != self.id))
rs = db.engine.execute(select)
return rs.rowcount
def get_comment_karma(self):
"""
fetch the number of votes this user has had on his/her comments
"""
comment_ids = [c.id for c in self.comments]
select = comment_upvotes.select(
db.and_(comment_upvotes.c.comment_id.in_(comment_ids),
comment_upvotes.c.user_id != self.id))
rs = db.engine.execute(select)
return rs.rowcount
class Tasks(db.Model):
__tablename__ = "tasks"
id = db.Column(db.Integer, primary_key=True)
action = db.Column(db.Text, nullable=False)
author_id = db.Column(db.Integer,
db.ForeignKey("users.id"),
nullable=False)
author = db.relationship("User", foreign_keys=author_id)
approve_id = db.Column(db.Integer,
db.ForeignKey("users.id"),
nullable=False)
approve = db.relationship("User", foreign_keys=approve_id)
decision = db.Column(
db.String(6),
db.CheckConstraint("decision IN ('accept', 'reject',"
" 'ignore')"))
processed = db.Column(db.Boolean)
done = db.Column(db.Boolean)
created = db.Column(db.DateTime(True), default=dt.utcnow)
modified = db.Column(db.DateTime(True))
uid = db.Column(db.Integer, db.ForeignKey("users.id"))
user = db.relationship("User", foreign_keys=uid)
limbo_uid = db.Column(db.Integer, db.ForeignKey("limbo_users.id"))
limbo_user = db.relationship("LimboUser", foreign_keys=limbo_uid)
pid = db.Column(db.Integer, db.ForeignKey("projects.id"))
project = db.relationship("Project", foreign_keys=pid)
def __repr__(self):
return "<Task queue record {}>".format(self.id)
def brief(self):
act, entity, login, project, task = self.action.split("|")
if act in ["create", "add", "assign", "delete", "remove"]:
act += " a user "
elif act in ["update"]:
act += " user's info "
act = act[0].upper() + act[1:].lower()
act += "by %s" % self.author.full_name()
return act
def description(self):
act, entity, login, project, task = self.action.split("|")
if act in ["create"]:
act += " a user with %s for the project %s" % (task, project)
if act in ["assign", "remove"]:
return task
elif act in ["update"]:
act += " user info for %s with following data: %s" % (login, task)
act = act[0].upper() + act[1:]
return act
def notify(self):
if "update" in self.action and self.project:
return self.author.email
elif ("change" in self.action) and ("password" in self.action):
return self.user.email
elif (self.author and self.project):
return self.project.responsible.email
else:
return ""
def api(self):
act, entity, login, project, task = self.action.split("|")
return {
"id": self.id,
"notify": self.notify(),
"pid": self.pid if self.pid else "",
"uid": self.uid if self.uid else "",
"action": act,
"user": login,
"project": project,
"entity": entity,
"task": task
}
def to_dict(self):
if self.done:
status = "done"
elif self.processed:
status = "processed"
else:
status = ""
mod = self.modified.strftime("%Y-%m-%d %X %Z") if self.modified else ""
return {
"id": self.id,
"description": self.description(),
"action": self.brief(),
"done": self.done,
"author": self.author.full_name() if self.author else "",
"approve": self.approve.full_name() if self.approve else "",
"decision": self.decision,
"processed": self.processed,
"created": self.created.strftime("%Y-%m-%d %X %Z"),
"status": status,
"modified": mod
}
