class WorkFlowInstanceDetail(db.Model):
# Fields
id = db.Column(db.Integer, primary_key=True)
work_flow_instance_id = db.Column(db.Integer,
db.ForeignKey('work_flow_instance.id'))
work_flow_instance = db.relationship('WorkFlowInstance', backref='details')
work_flow_state_id = db.Column(db.Integer,
db.ForeignKey('work_flow_state.id'))
work_flow_state = db.relationship('WorkFlowState', backref='instances')
# Build generic relationship to target model object
ref_model = db.Column(db.String(255))
ref_id = db.Column(db.Integer)
ref_object = generic_relationship(ref_model, ref_id)
is_current_state = db.Column(db.Boolean, default=False)
active = db.Column(db.Integer, default=True)
created_at = db.Column(db.DateTime, default=datetime.datetime.now)
updated_at = db.Column(db.DateTime,
default=datetime.datetime.now,
onupdate=datetime.datetime.now)
def __repr__(self):
return '<WorkFlowInstance id = %s, ref_model = %s, ref_id = %s>' % (
self.id, self.ref_model, self.ref_id)
class Favorite(TimestampMixin, db.Model):
id = primary_key("Favorite")
org_id = Column(key_type("Organization"), db.ForeignKey("organizations.id"))
object_type = Column(db.Unicode(255))
object_id = Column(key_type("Favorite"))
object = generic_relationship(object_type, object_id)
user_id = Column(key_type("User"), db.ForeignKey("users.id"))
user = db.relationship(User, backref="favorites")
__tablename__ = "favorites"
__table_args__ = (
UniqueConstraint("object_type", "object_id", "user_id", name="unique_favorite"),
)
@classmethod
def is_favorite(cls, user, object):
return cls.query.filter(cls.object == object, cls.user_id == user).count() > 0
@classmethod
def are_favorites(cls, user, objects):
objects = list(objects)
if not objects:
return []
object_type = str(objects[0].__class__.__name__)
return [
fav.object_id
for fav in cls.query.filter(
cls.object_id.in_([o.id for o in objects]),
cls.object_type == object_type,
cls.user_id == user,
)
]
class Favorite(TimestampMixin, db.Model):
id = Column(db.Integer, primary_key=True)
org_id = Column(db.Integer, db.ForeignKey("organizations.id"))
object_type = Column(db.Unicode(255))
object_id = Column(db.Integer)
object = generic_relationship(object_type, object_id)
user_id = Column(db.Integer, db.ForeignKey("users.id"))
user = db.relationship(User, backref='favorites')
__tablename__ = "favorites"
__table_args__ = (UniqueConstraint("object_type",
"object_id",
"user_id",
name="unique_favorite"), )
@classmethod
def is_favorite(cls, user, object):
return cls.query.filter(cls.object == object, cls.user_id
== user).count() > 0
@classmethod
def are_favorites(cls, user, objects):
objects = list(objects)
if not objects:
return []
object_type = text_type(objects[0].__class__.__name__)
return map(
lambda fav: fav.object_id,
cls.query.filter(cls.object_id.in_(map(lambda o: o.id, objects)),
cls.object_type == object_type,
cls.user_id == user))
class User(Base):
__tablename__ = 'auth_user'
print_filter = ('password', 'object_type', 'object_id')
to_json_filter = ('password', 'object_type', 'object_id')
id = db.Column(db.Integer, primary_key=True)
email = db.Column(db.String(30), unique=True)
firstname = db.Column(db.String(30))
lastname = db.Column(db.String(30))
password = db.Column(db.String(120))
phone_number = db.Column(db.String(10), nullable=True)
# This is used to discriminate between the linked tables.
object_type = db.Column(db.Unicode(255))
# This is used to point to the primary key of the linked row.
object_id = db.Column(db.Integer)
organization = generic_relationship(object_type, object_id)
def __init__(self, email=None, password=None, **kwargs):
super(User, self).__init__(email=email, password=password, **kwargs)
if email:
self.email = email.lower()
if password:
self.set_password(password)
def set_password(self, password):
self.password = generate_password_hash(password)
def check_password(self, password):
return check_password_hash(self.password, password)
def get_id(self):
"""Return the email address to satisfy Flask-Login's requirements."""
return self.email
class Organization(Base):
__tablename__ = "orga_organization"
to_json_filter = (
"object_type",
"object_id",
"availabilities",
"address_id",
)
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(30), nullable=False)
type = db.Column(ChoiceType(OrganizationType, impl=db.Integer()),
nullable=False,
default=OrganizationType.finess_et)
reg_code = db.Column(db.String, db.ForeignKey("orga_region.code"))
address_id = db.Column(db.Integer, db.ForeignKey("orga_address.id"))
address = db.relationship(Address, back_populates="organization")
# This is used to discriminate between the linked tables.
object_type = db.Column(db.Unicode(255))
# This is used to point to the primary key of the linked row.
object_id = db.Column(db.Integer)
data = generic_relationship(object_type, object_id)
class Event(self.Base):
__tablename__ = 'event'
id = sa.Column(sa.Integer, primary_key=True)
object_type = sa.Column(sa.Unicode(255))
object_id = sa.Column(sa.Integer, nullable=False)
object = generic_relationship(object_type, object_id)
class Log(TorModel):
__tablename__ = 'logs'
### others ###
### END_OTHERS ###
# acl[*] # default
object_id = Column(UUIDType(binary=False))
# acl[*] # default
object_type = Column(String(50))
# acl[*] # default
object = generic_relationship(object_type, object_id)
# acl[*] # default
message_type = Column(MESSAGE_TYPE_ENUM, default=Constants.MESSAGE_TYPE_INFO, nullable=False)
# acl[*] # default
message = Column(String)
def delete_related_obj(self):
pass
# auto generate
@classmethod
def acl(cls):
return {
'object': ['admin', 'client'],
'created_at': ['admin', 'client'],
'object_type': ['admin', 'client'],
'updated_at': ['admin', 'client'],
'object_id': ['admin', 'client'],
'message': ['admin', 'client'],
'message_type': ['admin', 'client'],
'id': ['admin', 'client'],
}
@classmethod
def user_acl(cls):
return {
'admin': ['object_id', 'object_type', 'object', 'message_type', 'message', 'id', 'created_at', 'updated_at'],
'client': ['object_id', 'object_type', 'object', 'message_type', 'message', 'id', 'created_at', 'updated_at'],
}
@classmethod
def dft_view(cls):
return {
'object': 'object',
'created_at': 'created_at',
'object_type': 'object_type',
'updated_at': 'updated_at',
'object_id': 'object_id',
'message': 'message',
'message_type': 'message_type',
'id': 'id',
}
class Event(Base):
__tablename__ = 'event'
id = sa.Column(sa.Integer, primary_key=True)
transaction_id = sa.Column(sa.Integer)
object_type = sa.Column(sa.Unicode(255))
object_id = sa.Column(sa.Integer, nullable=False)
object = generic_relationship(object_type, object_id)
@hybrid_property
def object_version_type(self):
return self.object_type + 'History'
@object_version_type.expression
def object_version_type(cls):
return sa.func.concat(cls.object_type, 'History')
object_version = generic_relationship(object_version_type,
(object_id, transaction_id))
class Documents(db.Model):
__tablename__ = 'documents'
__table_args__ = {'extend_existing': True}
doc_id = db.Column(db.Integer, primary_key=True)
marksheet_10th = db.Column(db.String)
marksheet_12th = db.Column(db.String)
marksheet_bsc = db.Column(db.String)
marksheet_msc = db.Column(db.String)
object_type = db.Column(db.Unicode(255))
object_id = db.Column(db.Integer)
object = generic_relationship(object_type, object_id)
class AuditEvent(BaseModel):
who_id = db.Column(UUID(), db.ForeignKey('user.id', ondelete='CASCADE'))
who = relationship("User")
section = db.Column(db.String(255))
action = db.Column(db.String(255))
object_type = db.Column(db.Unicode(255))
# This is used to point to the primary key of the linked row.
object_id = db.Column(UUID)
# A pointer to a row in the database somewhere.
object = generic_relationship(object_type, object_id)
class Notebook(BaseModel):
__tablename__ = 'notebooks'
__repr_attrs__ = ['title']
__repr_max_length__ = 45
# Custom relationships that Automap can't handle
creator_id = sa.Column(sa.Integer, sa.ForeignKey('users.id'))
creator = sa.orm.relationship('User', foreign_keys=[creator_id])
updater_id = sa.Column(sa.Integer, sa.ForeignKey('users.id'))
updater = sa.orm.relationship('User', foreign_keys=[updater_id])
owner_id = sa.Column(sa.Integer)
owner_type = sa.Column(sa.String)
owner = sa_utils.generic_relationship(owner_type, owner_id)
class NotificationContent(db.Model, Timestamp):
__tablename__ = 'notification_content'
id = db.Column(db.Integer, primary_key=True)
type = db.Column(db.String, nullable=False)
target_type = db.Column(db.Unicode(255))
target_id = db.Column(db.Integer)
target = generic_relationship(target_type, target_id)
# For storing state of the action
target_action = db.Column(db.String)
class UserMapping(db.Model):
__tablename__ = 'user_mappings'
id = db.Column(db.Integer, primary_key=True)
password = db.Column(db.String)
user_id = db.Column(db.Integer, db.ForeignKey('users.id'))
user = db.relationship('User', foreign_keys=[user_id])
entity_type = db.Column(db.String(255))
entity_id = db.Column(db.Integer)
entity = generic_relationship(entity_type, entity_id)
__table_args__ = (db.UniqueConstraint(user_id, entity_type),)
def __str__(self):
return 'UserID: {}, UserType: {}'.format(
self.parent_id, self.object_type)
class Vote(db.Model):
id = db.Column(db.Integer, primary_key=True)
author_id = db.Column(db.Integer, db.ForeignKey("user.id"))
vote = db.Column(db.Boolean)
# This is used to discriminate between the linked tables.
target_type = db.Column(db.Unicode(255))
# This is used to point to the primary key of the linked row.
target_id = db.Column(db.Integer, nullable=False)
target = generic_relationship(target_type, target_id)
author = db.relationship("User")
def __init__(self, author="", vote="", target=""):
self.author = author
self.vote = vote
self.target = target
class Organisation(db.Model, BaseModel):
__tablename__ = 'orga_organization'
id = db.Column(db.Integer, primary_key=True)
vid = db.Column(db.Integer, unique=True)
name = db.Column(db.String(30))
role = db.Column(db.Integer, db.ForeignKey("orga_reference.id"))
role_obj = db.relationship(Reference, foreign_keys=[role])
status = db.Column(db.Integer, db.ForeignKey("orga_reference.id"))
status_obj = db.relationship(Reference, foreign_keys=[status])
availability = db.Column(db.Integer, db.ForeignKey("orga_reference.id"))
availability_obj = db.relationship(Reference, foreign_keys=[availability])
address_id = db.Column(db.Integer, db.ForeignKey('orga_address.id'))
address = db.relationship(Address, back_populates="organization")
# This is used to discriminate between the linked tables.
object_type = db.Column(db.Unicode(255))
# This is used to point to the primary key of the linked row.
object_id = db.Column(db.Integer)
data = generic_relationship(object_type, object_id)
users = db.relationship("User", back_populates="organization")
@property
def json(self):
return {
"id": self.id,
"vid": self.vid,
"role": self.role_obj.code,
'status': self.status_obj.code,
'availability': self.availability_obj.code,
"address": self.address.json,
"data": self.data.json
}
class Activity(manager.declarative_base, ActivityBase):
__tablename__ = 'activity'
manager = self
transaction_id = sa.Column(sa.BigInteger,
index=True,
nullable=False)
data = sa.Column(JSONType)
object_type = sa.Column(sa.String(255))
object_id = sa.Column(postgresql.UUID(as_uuid=True))
object_tx_id = sa.Column(sa.BigInteger)
target_type = sa.Column(sa.String(255))
target_id = sa.Column(postgresql.UUID(as_uuid=True))
target_tx_id = sa.Column(sa.BigInteger)
def _calculate_tx_id(self, obj):
session = sa.orm.object_session(self)
if obj:
object_version = version_obj(session, obj)
if object_version:
return object_version.transaction_id
version_cls = version_class(obj.__class__)
return session.query(
sa.func.max(version_cls.transaction_id)).filter(
version_cls.id == obj.id).scalar()
def calculate_object_tx_id(self):
self.object_tx_id = self._calculate_tx_id(self.object)
def calculate_target_tx_id(self):
self.target_tx_id = self._calculate_tx_id(self.target)
object = generic_relationship(object_type, object_id)
@hybrid_property
def object_version_type(self):
return self.object_type + 'Version'
@object_version_type.expression
def object_version_type(cls):
return sa.func.concat(cls.object_type, 'Version')
object_version = generic_relationship(object_version_type,
(object_id, object_tx_id))
target = generic_relationship(target_type, target_id)
@hybrid_property
def target_version_type(self):
return self.target_type + 'Version'
@target_version_type.expression
def target_version_type(cls):
return sa.func.concat(cls.target_type, 'Version')
target_version = generic_relationship(target_version_type,
(target_id, target_tx_id))
class AuditEvent(db.Model):
__tablename__ = 'audit_events'
id = db.Column(db.Integer, primary_key=True)
type = db.Column(db.String, index=True, nullable=False)
created_at = db.Column(db.DateTime, index=True, nullable=False, default=datetime.utcnow)
user = db.Column(db.String)
data = db.Column(JSON)
object_type = db.Column(db.String)
object_id = db.Column(db.BigInteger)
object = generic_relationship(
object_type, object_id
)
acknowledged = db.Column(
db.Boolean,
index=True,
unique=False,
nullable=False)
acknowledged_by = db.Column(db.String)
acknowledged_at = db.Column(
db.DateTime,
nullable=True)
def __init__(self, audit_type, user, data, db_object):
self.type = audit_type.value
self.data = data
self.object = db_object
self.user = user
self.acknowledged = False
class query_class(BaseQuery):
def last_for_object(self, object, types=None):
events = self.filter(AuditEvent.object == object)
if types is not None:
events = events.filter(AuditEvent.type.in_(types))
return events.order_by(desc(AuditEvent.created_at)).first()
def serialize(self, include_user=False):
"""
:return: dictionary representation of an audit event
"""
data = {
'id': self.id,
'type': self.type,
'acknowledged': self.acknowledged,
'user': self.user,
'data': self.data,
'createdAt': self.created_at.strftime(DATETIME_FORMAT),
'links': filter_null_value_fields({
"self": url_for(".list_audits"),
"oldArchivedService": ArchivedService.link_object(
self.data.get('oldArchivedServiceId')
),
"newArchivedService": ArchivedService.link_object(
self.data.get('newArchivedServiceId')
)
})
}
if self.acknowledged:
data.update({
'acknowledgedAt':
self.acknowledged_at.strftime(DATETIME_FORMAT),
'acknowledgedBy':
self.acknowledged_by,
})
if include_user:
user = User.query.filter(
User.email_address == self.user
).first()
if user:
data['userName'] = user.name
return data
class FilterSet(Model, AuditMixinNullable):
__tablename__ = "filter_sets"
id = Column(Integer, primary_key=True)
name = Column(String(500), nullable=False, unique=True)
description = Column(Text, nullable=True)
json_metadata = Column(Text, nullable=False)
dashboard_id = Column(Integer, ForeignKey("dashboards.id"))
dashboard = relationship("Dashboard", back_populates="_filter_sets")
owner_id = Column(Integer, nullable=False)
owner_type = Column(String(255), nullable=False)
owner_object = generic_relationship(owner_type, owner_id)
def __repr__(self) -> str:
return f"FilterSet<{self.name or self.id}>"
@property
def url(self) -> str:
return f"/api/filtersets/{self.id}/"
@property
def sqla_metadata(self) -> None:
# pylint: disable=no-member
meta = MetaData(bind=self.get_sqla_engine())
meta.reflect()
@property
def changed_by_name(self) -> str:
if not self.changed_by:
return ""
return str(self.changed_by)
@property
def changed_by_url(self) -> str:
if not self.changed_by:
return ""
return f"/superset/profile/{self.changed_by.username}"
def to_dict(self) -> Dict[str, Any]:
return {
"id": self.id,
"name": self.name,
"description": self.description,
"params": self.params,
"dashboard_id": self.dashboard_id,
"owner_type": self.owner_type,
"owner_id": self.owner_id,
}
@classmethod
def get(cls, _id: int) -> FilterSet:
session = db.session()
qry = session.query(FilterSet).filter(_id)
return qry.one_or_none()
@classmethod
def get_by_name(cls, name: str) -> FilterSet:
session = db.session()
qry = session.query(FilterSet).filter(FilterSet.name == name)
return qry.one_or_none()
@classmethod
def get_by_dashboard_id(cls, dashboard_id: int) -> FilterSet:
session = db.session()
qry = session.query(FilterSet).filter(
FilterSet.dashboard_id == dashboard_id)
return qry.all()
@property
def params(self) -> Dict[str, Any]:
if self.json_metadata:
return json.loads(self.json_metadata)
return {}
class GroupAdmin(db.Model):
"""Represent an administrator of a group."""
__tablename__ = 'groupADMIN'
__table_args__ = (db.UniqueConstraint('group_id', 'admin_type',
'admin_id'), db.Model.__table_args__)
id = db.Column(db.Integer(15, unsigned=True),
nullable=False,
primary_key=True,
autoincrement=True)
"""GroupAdmin identifier."""
group_id = db.Column(db.Integer(15, unsigned=True),
db.ForeignKey(Group.id),
nullable=False,
primary_key=True)
"""Group for membership."""
admin_type = db.Column(db.Unicode(255))
"""Generic relationship to an object."""
admin_id = db.Column(db.Integer)
"""Generic relationship to an object."""
#
# Relations
#
group = db.relationship(Group,
backref=db.backref('admins',
cascade="all, delete-orphan"))
"""Group relationship."""
admin = generic_relationship(admin_type, admin_id)
"""Generic relationship to administrator of group."""
@classmethod
def create(cls, group, admin):
"""Create a new group admin.
:param group: Group object.
:param admin: Admin object.
:returns: Newly created GroupAdmin object.
:raises: IntegrityError
"""
try:
obj = cls(
group=group,
admin=admin,
)
db.session.add(obj)
db.session.commit()
return obj
except IntegrityError:
db.session.rollback()
raise
@classmethod
def get(cls, group, admin):
"""Get specific GroupAdmin object."""
try:
ga = cls.query.filter_by(
group=group,
admin_id=admin.get_id(),
admin_type=resolve_admin_type(admin)).one()
return ga
except Exception:
return None
@classmethod
def delete(cls, group, admin):
"""Delete admin from group.
:param group: Group object.
:param admin: Admin object.
"""
try:
obj = cls.query.filter(cls.admin == admin,
cls.group == group).one()
db.session.delete(obj)
db.session.commit()
except Exception:
db.session.rollback()
raise
@classmethod
def query_by_group(cls, group):
"""Get all admins for a specific group."""
return cls.query.filter_by(group=group)
@classmethod
def query_by_admin(cls, admin):
"""Get all groups for for a specific admin."""
return cls.query.filter_by(admin_type=resolve_admin_type(admin),
admin_id=admin.get_id())
@classmethod
def query_admins_by_group_ids(cls, groups_ids=None):
"""Get count of admins per group."""
assert groups_ids is None or isinstance(groups_ids, list)
query = db.session.query(Group.id, func.count(
GroupAdmin.id)).join(GroupAdmin).group_by(Group.id)
if groups_ids:
query = query.filter(Group.id.in_(groups_ids))
return query
def object(cls):
return generic_relationship('object_type', 'object_id')
def object(cls):
return generic_relationship('object_type', 'object_id')
class Message(db.Model, BaseModel):
__tablename__ = "messages"
title = db.Column(
db.String(255),
nullable=False,
index=True
)
content = db.Column(
db.Text(),
nullable=False,
index=True
)
channel = db.Column(
db.String(255)
)
time_sent = db.Column(
db.TIMESTAMP
)
message_author_id = db.Column(
db.String,
db.ForeignKey("users.id")
)
author = db.relationship(
"User",
backref="createdMessages",
uselist=False,
foreign_keys=[message_author_id]
)
company_id = db.Column(
db.String,
db.ForeignKey("companies.id")
)
contact_id = db.Column(
db.String,
db.ForeignKey("contacts.id")
)
user_id = db.Column(
db.String,
db.ForeignKey("users.id")
)
deal_id = db.Column(
db.String,
db.ForeignKey("deals.id")
)
task_id = db.Column(
db.String,
db.ForeignKey("tasks.id")
)
organization_id = db.Column(
db.String,
db.ForeignKey("organizations.id")
)
project_id = db.Column(
db.String,
db.ForeignKey("projects.id")
)
sprint_id = db.Column(
db.String,
db.ForeignKey("sprints.id")
)
event_id = db.Column(
db.String,
db.ForeignKey("events.id")
)
links = db.relationship(
"Link",
backref="message"
)
state = db.Column(
db.Enum(MessageState),
default=MessageState.TOSEND,
index=True
)
parent_id = db.Column(
db.String(5),
db.ForeignKey('messages.id')
)
author_original_type = db.Column(
db.Unicode(255)
)
author_original_id = db.Column(
db.Integer,
)
author_original = generic_relationship(
author_original_type,
author_original_id
)
author_last_id = db.Column(
db.Integer,
)
author_last = generic_relationship(
author_original_type,
author_original_id
)
@property
def parent(self):
if self.parent_id:
return self.__class__.query.filter_by(id=self.parent_id).first()
replies = db.relationship(
"Message",
uselist=True,
)
# ',' separated string of emails
# Is used to force sending emails to certain destination
# If not set, `notification_emails` is used instead to calculate
# ALl email addresses
forced_destinations = db.Column(
db.String,
)
@property
def notification_emails(self):
"""
:return: list of all emails to send notifications to
:rtype: list
"""
if self.forced_destinations:
return [d.strip() for d in self.forced_destinations.split(',') if d]
obj = None
if self.user:
obj = self.user
elif self.contact:
obj = self.contact
elif self.company:
obj = self.company
elif self.organization:
obj = self.organization
elif self.deal: # contact emails or company emails
obj = self.deal
elif self.task: # assignee + one of these if found (contact, users, deal, company, organization, event, sprint)
obj = self.task
elif self.project: # promoter + guardian + contacts + one of (tasks, sprints)
obj = self.project
elif self.event: # All contacts emails + All tasks emails
obj = self.event
elif self.sprint: # contacts + owner + tasks
obj = self.sprint
if not obj:
return []
return list(set(obj.notification_emails))
def __str__(self):
return self.title
def transaction_object(self):
return generic_relationship(
"content_object_type", "content_object_id")
