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)
