class SpaceAccessGroup(db.Model): __tablename__ = 'spaceaccess_groups' id = db.Column(db.Integer, primary_key=True) users = db.relationship( "User", backref=db.backref("spaceaccess_accessgroup", uselist=False, lazy=True), secondary=AccessgroupUserMap.__tablename__, lazy='subquery', ) spaces = db.relationship( "SpaceAccessSpace", backref=db.backref("spaceaccess_accessgroup", lazy=True), secondary=AccessgroupSpaceMap.__tablename__, lazy='subquery', ) name = db.Column(db.String(120), default="") note = db.Column(db.String(120), default="") access_type = db.Column(db.Enum(SpaceAccessType), default=SpaceAccessType.NO_ACCESS) entry_accounting_type = db.Column(db.Enum(SpaceAccessEntryAccounting), default=SpaceAccessEntryAccounting.DAYS) access_need_budget = db.Column(db.Boolean, default=False) access_gets_recharged = db.Column(db.Boolean, default=False) access_recharge_budget_amount = db.Column(db.Integer, default=15) access_recharge_budget_period = db.Column(db.Enum(SpaceAccessRechargePeriod), default=SpaceAccessRechargePeriod.MONTHS) access_recharge_budget_every_periods = db.Column(db.Integer, default=4) access_recharge_budget_get_cutoff = db.Column(db.Boolean, default=True) access_recharge_budget_cutoff_max = db.Column(db.Integer, default=15) access_expires_as_default = db.Column(db.Boolean, default=False) access_expires_default_days = db.Column(db.Integer, default=365) access_use_group_budget = db.Column(db.Boolean, default=False) last_access_at = db.Column(ArrowType, default=None) group_budget = db.Column(db.Integer, default=0) day_access_mask = db.Column(db.Integer, default=127) daily_access_start_time = db.Column(ArrowType, default=arrow.get('00:00', 'HH:mm')) daily_access_end_time = db.Column(ArrowType, default=arrow.get('23:59', 'HH:mm'))
class Product(db.Model): id = db.Column(db.Integer, primary_key=True) name = db.Column(db.String(50), nullable=False) price = db.Column(db.Integer, nullable=False) quantity = db.Column(db.Integer, nullable=False) description = db.Column(db.String(100), default="No description") image_url = db.Column(db.String(50), default="default.jpg") restaurant_id = db.Column(db.Integer, db.ForeignKey("vendor.id")) orders = db.relationship("Order", backref="products", lazy=True) category = db.relationship("Category", secondary="categories", lazy="subquery", backref=db.backref("items", lazy=True)) rating = db.relationship("Review", secondary="ratings", lazy="subquery", backref=db.backref("product", lazy=True))
class User(db.Model, UserMixin): id = db.Column(db.Integer, primary_key=True) email = db.Column(db.String(255), unique=True) password = db.Column(db.String(255)) active = db.Column(db.Boolean()) confirmed_at = db.Column(db.DateTime()) roles = db.relationship('Role', secondary=roles_users, backref=db.backref('users', lazy='dynamic'))
class SpaceAccessSpace(db.Model): __tablename__ = 'spaceaccess_spaces' id = db.Column(db.Integer, primary_key=True) name = db.Column(db.String(64), default="") description = db.Column(db.String(128), default="") entrance_nodes = db.relationship( "Node", backref=db.backref("spaceaccess_spaces", lazy=True), secondary=SpaceNodeMap.__tablename__, lazy='subquery', )
class Jrnl(db.Model): """ A tinyjrnl entry created by an end user """ id = db.Column(db.Integer, primary_key=True) created_at = db.Column(db.DateTime, nullable=False) entry = db.Column(db.Text) channel_id = db.Column(db.Integer, db.ForeignKey('channel.id')) account_id = db.Column(db.String(34), db.ForeignKey('user.account_id')) tags = db.relationship('Tag', secondary=jrnl_tags, backref=db.backref('jrnls', lazy='dynamic'))
class SpaceAccessProperties(db.Model): __tablename__ = 'spaceaccess_properties' id = db.Column(db.Integer, db.ForeignKey('users.id'), primary_key=True) access_budget = db.Column(db.Integer, default=0) access_need_budget = db.Column(db.Boolean, default=False) access_starts = db.Column(db.Boolean, default=False) access_expires = db.Column(db.Boolean, default=False) access_start_date = db.Column(ArrowType, default=arrow.utcnow) access_expire_date = db.Column(ArrowType, default=arrow.utcnow) access_last_update_date = db.Column(ArrowType, default=arrow.utcnow) last_access_at = db.Column(ArrowType, default=None) user = db.relationship("User", backref=db.backref("access", uselist=False, cascade="save-update, merge, delete, delete-orphan"))
class CTI(db.Model): __tablename__ = 'cti' id = db.Column(db.Integer, primary_key=True, autoincrement=True) name = db.Column(db.String(100)) timestamp = db.Column(db.DateTime, default=db.func.current_timestamp()) status = db.Column(db.Integer) events = db.relationship("Event", lazy=True) features = db.relationship("Feature", secondary=mtm_cti_feature, backref=db.backref('cti', lazy=True)) classifications = db.relationship("Classification") def __init__(self, name=None): self.name = name self.status = CTI_STATUS['NEW'] def get_status_name(self): for key in CTI_STATUS: if self.status == CTI_STATUS[key]: return key return None def get_top_classification(self): max_prob = 0 top_class = None for classification in self.classifications: if max_prob < classification.probability: max_prob = classification.probability top_class = classification return top_class def get_chart_data(self): targets = [] probs = [] for classification in self.classifications: targets.append(classification.actor.name) probs.append(round(classification.probability * 100, 1)) return json.dumps({"labels": targets, "data": probs}) def __repr__(self): return '<CTI {}>'.format(self.id)
class Message(db.Model): __tablename__ = 'messages' # nonvolatile data stored in the db id = db.Column(db.Integer, primary_key=True) recipient_email = db.Column(db.String, db.ForeignKey('users.email')) recipient = db.relationship("User", backref=db.backref("messages", uselist=True)) sender_name = db.Column(db.String(120), default="") subject = db.Column(db.String(120), default="") message_html = db.Column(db.UnicodeText(), default="") message_send_date = db.Column(ArrowType, default=arrow.utcnow) message_read = db.Column(db.Boolean, default=False) def __repr__(self): return '<Message from {} to {} with subject "{}" [{}] >'.format( self.sender_name, self.recipient_name, self.subject, self.message_send_date)
class Frog(db.Model): __tablename__ = 'frogs' id = db.Column(db.Integer, primary_key=True) name = db.Column(db.String(50), unique=False, nullable=False) food = db.Column(db.Integer, nullable=False, default=0) cleanliness = db.Column(db.Integer, nullable=False, default=0) money = db.Column(db.Integer, nullable=False, default=0) image_id = db.Column(db.Integer, db.ForeignKey('images.id'), nullable=False) owner_id = db.Column(db.Integer, db.ForeignKey('users.id')) last_request = db.Column(UtcDateTime(), default=utcnow(), nullable=False) image = db.relationship("Image", backref=db.backref("frog", uselist=False)) def __repr__(self): return f'<Frog {self.id}; {self.name}>'
class Actor(Model, db.Model): __tablename__ = 'actors' # id -> integer, primary key id = db.Column(db.Integer, primary_key = True) # name -> string, size 50, unique, not nullable name = db.Column(db.String(50), unique = True, nullable = False) # gender -> string, size 11 gender =db.Column(db.String(11)) # date_of_birth -> date date_of_birth = db.Column(db.DateTime, nullable=False, default=dt.utcnow) # Use `db.relationship` method to define the Actor's relationship with Movie. # Set `backref` as 'cast', uselist=True # Set `secondary` as 'association' movies = db.relationship("Movie", secondary = association,backref = db.backref("cast", uselist = True)) def __repr__(self): return '<Actor {}>'.format(self.name)
class Subscription(db.Model): id = db.Column(db.Integer, primary_key=True) name = db.Column(db.VARCHAR(255), unique=True) url = db.Column(db.VARCHAR(255)) last_link = db.Column(db.VARCHAR(255), nullable=True) subscribers = db.relationship('Subscriber', secondary=subscriptions, backref=db.backref('subscriptions', lazy='dynamic')) def __init__(self, name, url): self.name = name self.url = url @classmethod def get_by_name(cls, name): return cls.query.filter_by(name=name).first() def __str__(self): return self.name
class Movie(Model, db.Model): __tablename__ = 'movies' # id -> integer, primary key id = db.Column(db.Integer, primary_key=True) # name -> string, size 50, unique, not nullable name = db.Column(db.String(50), unique=True, nullable=False) # year -> integer year = db.Column(db.Integer) # genre -> string, size 20 genre = db.Column(db.String(20)) # Use `db.relationship` method to define the Movie's relationship with Actor. # Set `backref` as 'filmography', uselist=True # Set `secondary` as 'association' actors = db.relationship("Actor", secondary=association, backref=db.backref('filmography', uselist=True)) def __repr__(self): return '<Movie {}>'.format(self.name)
class Event(db.Model): __tablename__ = 'event_base' id = db.Column(db.Integer, primary_key=True, autoincrement=True) timestamp = db.Column(db.DateTime) source_module = db.Column(db.String(20)) event_type = db.Column(db.String(20)) __mapper_args__ = {'polymorphic_on': event_type} cti = db.relationship("CTI", uselist=False, lazy=True) cti_id = db.Column(db.Integer, db.ForeignKey('cti.id'), nullable=False) analysed_features = db.relationship('Feature', secondary=mtm_feature_event, backref=db.backref('events', lazy=True), lazy=True) def __init__(self, source_module, timestamp=db.func.current_timestamp()): self.timestamp = timestamp self.source_module = source_module def __repr__(self): return '<Event {}>'.format(self.id)
class Message(db.Model): __tablename__ = 'messages' id = db.Column(db.Integer, primary_key=True) m_title = db.Column(db.String(100), nullable=True) m_description = db.Column(db.String(200)) type_id = db.Column(db.Integer, db.ForeignKey('message_types.id'), nullable=False) m_type = db.relationship('MessageType') m_categories = db.relationship('Category', secondary=messages_categories, lazy='joined', backref=db.backref('messages', lazy=True)) is_video = db.Column(db.Boolean, default=True, nullable=False) m_thumbnail = db.Column(db.String(100)) m_link = db.Column(db.String(200)) m_duration = db.Column(db.String(50)) m_broadcast = db.Column(db.Boolean, default=False, nullable=False) created_at = db.Column(db.DateTime, server_default=db.func.now()) updated_at = db.Column(db.DateTime, server_default=db.func.now(), server_onupdate=db.func.now())
class Group(db.Model): __tablename__ = 'groups' id = db.Column(db.Integer, primary_key=True) group_name = db.Column(db.String(60), nullable=False) group_description = db.Column(db.String(200)) members = db.relationship('User', secondary=memberships, lazy='subquery', backref=db.backref('groups', lazy=True)) creator_id = db.Column(db.Integer, db.ForeignKey('users.id'), nullable=False, default=1) owner = db.relationship('User') created_at = db.Column(db.DateTime, server_default=db.func.now()) updated_at = db.Column(db.DateTime, server_default=db.func.now(), server_onupdate=db.func.now()) def __init__(self, group_name, group_description, creator): self.group_name = group_name self.group_description = group_description self.creator = creator
class Book(db.Model): __tablename__ = 'books' # primary key book_id = db.Column(db.Integer, primary_key=True) # foreign key author_id = db.Column(db.Integer, db.ForeignKey('author.author_id')) # relationships genres = db.relationship('Genre', secondary=genre_relations, backref=db.backref('books', lazy='joined'), lazy='dynamic') # user_books table # other columns title = db.Column(db.String(256), nullable=False) isbn = db.Column(db.String(256), nullable=False) publisher = db.Column(db.String(256), nullable=False) description = db.Column(db.String(1024)) cover_large = db.Column(db.String(256), nullable=False) cover_thumb = db.Column(db.String(256), nullable=False) slug = db.Column(db.String(256), nullable=False) last_updated = db.Column(db.Date) published = db.Column(db.Date) epub_url = db.Column(db.String(256), nullable=False) stream_url = db.Column(db.String(256), nullable=False) atom_entry_url = db.Column(db.String(256), nullable=False) def __init__(self, title, isbn, author, publisher, description, genres, cover_large, cover_thumb, epub_url, stream_url, atom_entry_url): self.title = title self.isbn = isbn self.author = author self.publisher = publisher self.description = description self.genres = genres self.cover_large = cover_large self.cover_thumb = cover_thumb self.slug = slugify(title) self.last_updated = date.today() self.published = date(2010, 10, 31) self.epub_url = epub_url self.stream_url = stream_url self.atom_entry_url = atom_entry_url @staticmethod def book_from_dict(**kwargs): return Book(kwargs.get('title', ""), kwargs.get('isbn', ""), kwargs.get('author', ""), kwargs.get('publisher', ""), kwargs.get('description', ""), kwargs.get('genres', ""), kwargs.get('cover_large', ""), kwargs.get('cover_thumb', ""), kwargs.get('epub_url', ""), kwargs.get('stream_url', ""), kwargs.get('atom_entry_url', "")) def __repr__(self): return '<title {}>'.format(self.title) def as_dict(self): return { 'title': self.title, 'isbn': self.isbn, 'author': self.author.as_dict(), 'publisher': self.publisher, 'description': self.description, 'genres': [g.as_dict() for g in self.genres], 'slug': self.slug }
class AppUser(db.Model): __tablename__ = 'app_users' # primary key user_id = db.Column(db.String(128), primary_key=True) # relationships author = db.relationship('Author', uselist=False, backref='app_user') # user_books table books = db.relationship('Book', secondary=user_books, backref=db.backref('app_users', lazy='joined'), lazy='dynamic') #other columns user_href = db.Column(db.String(1024), nullable=False) is_author = db.Column(db.Boolean, nullable=False) ios_token = db.Column(db.String(1024)) def __init__(self, storm_path_user_href): self.user_id = stormpathUserHash(storm_path_user_href) self.user_href = storm_path_user_href self.is_author = False def become_author(self, Author): self.author = Author self.is_author = True try: db.session.commit() except: # TODO flash error message db.session.rollback() def purchase_book(self, book): self.books.append(book) try: db.session.commit() except: # TODO flash error message db.session.rollback() def set_ios_token(self, ios_token): self.ios_token = ios_token try: db.session.commit() except: # TODO flash error message db.session.rollback() def __repr__(self): return '<user {}>'.format(self.user_id) def as_dict(self): return { 'user_id': self.user_id, 'user_href': self.user_href, 'is_author': self.is_author, 'author': "" if not self.is_author else self.author.as_dict() }
class NodeSettings(db.Model): __tablename__ = 'node_settings' # nonvolatile data stored in the db id = db.Column(db.Integer, primary_key=True) node_id = db.Column(db.Integer, db.ForeignKey('nodes.id')) node = db.relationship("Node", backref=db.backref("settings", uselist=True))
class Deployment(db.Model): """ Deployment Model for storing deployment related details """ __tablename__ = "deployments" query_class = queries.DeploymentQuery id = db.Column(db.Integer, primary_key=True, autoincrement=True) creator_id = db.Column(db.Integer, db.ForeignKey("users.id")) creator = db.relationship("User", backref=db.backref("deployments", uselist=False), foreign_keys=[creator_id]) name = db.Column(db.String(255), unique=False, nullable=False) status = db.Column(db.String(32), nullable=False, server_default='Stopped') pod = db.Column(db.String(64), nullable=True) workspace_id = db.Column(db.Integer, db.ForeignKey("workspaces.id"), nullable=True) workspace = db.relationship("Workspace", backref=db.backref("deployments"), foreign_keys=[workspace_id ]) # TODO: Test delete workspace_port_id = db.Column(db.Integer, db.ForeignKey("service_ports.id"), nullable=True) workspace_port = db.relationship("ServicePort", backref=db.backref("deployments"), foreign_keys=[workspace_port_id ]) # TODO: Test delete @property def ref(self): """ Generates the deployment ref :return: string """ return f"deployment-{self.id}" @property def service_ref(self): """ Generates the service ref :return: string """ return f"service-{self.id}" @property def serialize(self): """ Returns serializable object """ return { "id": self.id, "name": self.name, "status": self.status, "workspace": { "name": self.workspace and self.workspace.display_name, "url": f'http://192.168.39.189:{self.workspace_port.port}/{self.workspace_port.url_params or ""}' if self.workspace_port else None } } @property def kube_body(self): """ Build kubernetes deployment :return: client.V1Deployment """ return client.V1Deployment( metadata=client.V1ObjectMeta(name=self.ref), spec=client.V1DeploymentSpec( replicas=1, selector=client.V1LabelSelector( match_labels={'mintzone/ref': self.ref}), template=client.V1PodTemplateSpec( metadata=client.V1ObjectMeta( labels={"mintzone/ref": self.ref}), spec=client.V1PodSpec( containers=self.containers, volumes=[ client.V1Volume( name='data', empty_dir=client.V1EmptyDirVolumeSource(), ) ])))) @property def kube_service(self): """ Build kubernetes service :return: client.V1Service """ return client.V1Service( metadata=client.V1ObjectMeta(name=self.service_ref), spec=client.V1ServiceSpec(selector={"mintzone/ref": self.ref}, ports=self.kube_service_ports, external_i_ps=["192.168.39.189"])) @property def containers(self): """ Build kubernetes containers :return: list """ result = [] try: instance = getattr(containers, self.workspace.name)(self) result.append(instance.container) except AttributeError as ex: print( f'ERROR: [Deployment] Workspace "{self.workspace.name}" not found ({ex})' ) return result @property def kube_service_ports(self): """ Build kubernetes service ports :return: list """ if not self.workspace: return [] result = [] try: instance = getattr(containers, self.workspace.name)(self) if instance.service_port: result.append(instance.service_port) except AttributeError as ex: print( f'ERROR: [Deployment] Workspace "{self.workspace.name}" not found ({ex})' ) return result def start(self): # Assign port number self.workspace_port = ServicePort() db.session.commit() Apps.API.create_namespaced_deployment('default', self.kube_body) Core.API.create_namespaced_service('default', self.kube_service) def stop(self): Apps.API.delete_namespaced_deployment(self.ref, 'default') Core.API.delete_namespaced_service(self.service_ref, 'default') # Delete assigned ports db.session.delete(self.workspace_port) db.session.commit() def on_status_changed(self): channels.Deployment(self.id, private=True).trigger('status', self.status) switcher = { 'Running': self.on_running, 'Stopped': self.on_stopped, 'Creating': None, 'Created': self.on_created } if switcher.get(self.status): switcher.get(self.status)() def on_created(self): self.status = 'Running' db.session.commit() self.on_status_changed() def on_stopped(self): self.pod = None db.session.commit() def on_running(self): self.pod = operations.get_pod_name(self.ref) db.session.commit() operations.add_file(self.pod)