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 }