class Route(entity.Entity, db.Model):
attributes = ['name', 'url', 'method', 'sysadmin', 'bypass']
attributes += entity.Entity.attributes
name = db.Column(db.String(100), nullable=False)
url = db.Column(db.String(80), nullable=False)
method = db.Column(db.String(10), nullable=False)
bypass = db.Column(db.Boolean(), nullable=False)
sysadmin = db.Column(db.Boolean(), nullable=False)
__table_args__ = (UniqueConstraint('url', 'method', name='route_uk'), )
def __init__(self,
id,
name,
url,
method,
bypass=False,
sysadmin=False,
active=True,
created_at=None,
created_by=None,
updated_at=None,
updated_by=None):
super().__init__(id, active, created_at, created_by, updated_at,
updated_by)
self.name = name
self.url = url
self.method = method
self.bypass = bypass
self.sysadmin = sysadmin
class File(entity.Entity, db.Model):
# This is required because Oracle dont accept FILE for table name
__tablename__ = 'file_infosys'
attributes = ['domain_id', 'name']
attributes += entity.Entity.attributes
domain_id = db.Column(db.CHAR(32),
db.ForeignKey("domain.id"),
nullable=True)
name = db.Column(db.String(255), nullable=True)
def __init__(self,
id,
domain_id,
name,
active=True,
created_at=None,
created_by=None,
updated_at=None,
updated_by=None):
super().__init__(id, active, created_at, created_by, updated_at,
updated_by)
self.domain_id = domain_id
self.name = name
class Capability(entity.Entity, db.Model):
attributes = ['route_id', 'application_id']
attributes += entity.Entity.attributes
route_id = db.Column(
db.CHAR(32), db.ForeignKey("route.id"), nullable=False)
route = orm.relationship('Route', backref=orm.backref('capabilities'))
application_id = db.Column(
db.CHAR(32), db.ForeignKey("application.id"), nullable=False)
application = orm.relationship('Application', backref=orm.backref(
'capabilities'))
__table_args__ = (
UniqueConstraint('route_id', 'application_id', name='capability_uk'),)
def __init__(self, id, route_id, application_id,
active=True, created_at=None, created_by=None,
updated_at=None, updated_by=None, tag=None):
super().__init__(id, active, created_at, created_by,
updated_at, updated_by, tag)
self.route_id = route_id
self.application_id = application_id
@classmethod
def collection(cls):
return 'capabilities'
class Policy(entity.Entity, db.Model):
attributes = ['capability_id', 'role_id']
attributes += entity.Entity.attributes
capability_id = db.Column(db.CHAR(32),
db.ForeignKey("capability.id"),
nullable=False)
role_id = db.Column(db.CHAR(32), db.ForeignKey("role.id"), nullable=False)
def __init__(self,
id,
capability_id,
role_id,
active=True,
created_at=None,
created_by=None,
updated_at=None,
updated_by=None):
super().__init__(id, active, created_at, created_by, updated_at,
updated_by)
self.capability_id = capability_id
self.role_id = role_id
@classmethod
def collection(cls):
return 'policies'
class Role(entity.Entity, db.Model):
attributes = ['domain_id', 'name']
attributes += entity.Entity.attributes
domain_id = db.Column(db.CHAR(32),
db.ForeignKey("domain.id"),
nullable=False)
name = db.Column(db.String(80), nullable=False)
__table_args__ = (UniqueConstraint('domain_id',
'name',
name='role_name_uk'), )
def __init__(self,
id,
domain_id,
name,
active=True,
created_at=None,
created_by=None,
updated_at=None,
updated_by=None):
super().__init__(id, active, created_at, created_by, updated_at,
updated_by)
self.domain_id = domain_id
self.name = name
class File(entity.Entity, db.Model):
# TODO(fdoliveira) Check in another databases
# This is required because Oracle dont accept FILE for table name
__tablename__ = 'file_infosys'
attributes = ['domain_id', 'name']
attributes += entity.Entity.attributes
domain_id = db.Column(
db.CHAR(32), db.ForeignKey("domain.id"), nullable=True)
name = db.Column(db.String(255), nullable=True)
def __init__(self, id, domain_id, name,
active=True, created_at=None, created_by=None,
updated_at=None, updated_by=None, tag=None):
super().__init__(id, active, created_at, created_by,
updated_at, updated_by, tag)
self.domain_id = domain_id
self.name = name
@property
def extension(self):
name = self.name.split('.')
return name[-1]
@property
def filename(self):
return '{}.{}'.format(self.id, self.extension)
class Image(File, db.Model):
MAX_ALLOWED_SIZE = (6000, 6000)
attributes = []
attributes += File.attributes
id = db.Column(db.ForeignKey('file_infosys.id'), primary_key=True)
type_image = db.Column(db.String(100), nullable=False)
__mapper_args__ = {'polymorphic_identity': 'image'}
def __init__(self,
id,
domain_id,
name,
type_image='',
active=True,
created_at=None,
created_by=None,
updated_at=None,
updated_by=None,
tag=None):
super().__init__(id, domain_id, name, active, created_at, created_by,
updated_at, updated_by, tag)
self.type_image = type_image
@classmethod
def collection(cls):
return 'images'
def filename_with_quality(self, quality: QualityImage):
if quality is None:
return '{}.{}'.format(self.id, 'jpg')
else:
return '{}.{}.{}'.format(self.id, quality.value, 'jpg')
class Share(entity.Entity, db.Model):
attributes = ['capability_id', 'domain_id']
attributes += entity.Entity.attributes
capability_id = db.Column(db.CHAR(32),
db.ForeignKey("capability.id"),
nullable=False)
domain_id = db.Column(db.CHAR(32),
db.ForeignKey("domain.id"),
nullable=False)
__table_args__ = (UniqueConstraint('capability_id',
'domain_id',
name='share_uk'), )
def __init__(self,
id,
capability_id,
domain_id,
active=True,
created_at=None,
created_by=None,
updated_at=None,
updated_by=None):
super().__init__(id, active, created_at, created_by, updated_at,
updated_by)
self.capability_id = capability_id
self.domain_id = domain_id
class Notification(entity.Entity, db.Model):
attributes = ['user_id', 'date', 'subject', 'body', 'read_date']
attributes += entity.Entity.attributes
user_id = db.Column(db.CHAR(32), db.ForeignKey("user.id"), nullable=False)
date = db.Column(db.Date, nullable=False)
subject = db.Column(db.String(50), nullable=False)
body = db.Column(db.String(250), nullable=False)
read_date = db.Column(db.Date, nullable=True)
def __init__(self,
id,
user_id,
date,
subject,
body,
active=True,
read_date=None,
created_at=None,
created_by=None,
updated_at=None,
updated_by=None,
tag=None):
super().__init__(id, active, created_at, created_by, updated_at,
updated_by, tag)
self.user_id = user_id
self.date = datetime.strptime(date, entity.DATETIME_FMT)
self.subject = subject
self.body = body
if (read_date is not None):
self.read_date = datetime.strptime(read_date, entity.DATETIME_FMT)
class NotificationTag(resource.Tag, db.Model):
attributes = ['label']
notification_id = db.Column(db.CHAR(32),
db.ForeignKey("notification.id"),
nullable=False)
def __init__(self, id, label, notification_id):
super().__init__(id, label)
self.notification_id = notification_id
class DomainSequence(entity.Entity, db.Model):
attributes = ['domain_id', 'name', 'value']
attributes += entity.Entity.attributes
domain_id = db.Column(db.CHAR(32),
db.ForeignKey('domain.id'),
nullable=False)
name = db.Column(db.String(100), nullable=False)
value = db.Column(db.Numeric(10), default=0, nullable=False)
__table_args__ = (UniqueConstraint(
'name', 'domain_id', name='domain_sequence_name_domain_id_uk'), )
def __init__(self,
id,
domain_id,
name,
value,
active=True,
created_at=None,
created_by=None,
updated_at=None,
updated_by=None,
tag=None):
super().__init__(id, active, created_at, created_by, updated_at,
updated_by, tag)
self.domain_id = domain_id
self.name = name
self.value = value
@classmethod
def individual(cls):
return 'domain_sequence'
def is_stable(self):
domain_id_stable = self.domain_id is not None
name_stable = self.name is not None
value_stable = self.value is not None and self.value >= 0
return domain_id_stable and name_stable and value_stable
class Application(entity.Entity, db.Model):
DEFAULT = "default"
attributes = ['name', 'description']
attributes += entity.Entity.attributes
pagination_column = 'name'
name = db.Column(db.String(30), nullable=False)
description = db.Column(db.String(1000), nullable=False)
__table_args__ = (UniqueConstraint('name', name='application_name_uk'),)
def __init__(self, id, name, description,
active=True, created_at=None, created_by=None,
updated_at=None, updated_by=None, tag=None):
super().__init__(id, active, created_at, created_by,
updated_at, updated_by, tag)
self.name = name
self.description = description
class TimelineEventUser(entity.Entity, db.Model):
attributes = ['id', 'user_id']
timeline_event_id = db.Column(
db.CHAR(32), db.ForeignKey("timeline_event.id"), nullable=False)
user_id = db.Column(
db.CHAR(32), db.ForeignKey("user.id"), nullable=False)
user = orm.relationship(
'User', backref=orm.backref('timeline_event_user'))
def __init__(self, id, timeline_event_id, user_id,
active=True, created_at=None,
created_by=None, updated_at=None, updated_by=None, tag=None):
super().__init__(id, active, created_at, created_by,
updated_at, updated_by, tag)
self.timeline_event_id = timeline_event_id
self.user_id = user_id
def is_stable(self):
if self.user_id is not None and self.timeline_event_id is not None:
return True
return False
class Notification(entity.Entity, db.Model):
attributes = ['user_id', 'date', 'subject', 'body', 'read_date']
attributes += entity.Entity.attributes
user_id = db.Column(db.CHAR(32), db.ForeignKey("user.id"), nullable=False)
date = db.Column(db.Date, nullable=False)
subject = db.Column(db.String(50), nullable=False)
body = db.Column(db.String(250), nullable=False)
read_date = db.Column(db.Date, nullable=True)
tags = orm.relationship("NotificationTag",
backref=orm.backref('notification'),
cascade='delete,delete-orphan,save-update')
def __init__(self,
id,
user_id,
date,
subject,
body,
active=True,
read_date=None,
created_at=None,
created_by=None,
updated_at=None,
updated_by=None):
super().__init__(id, active, created_at, created_by, updated_at,
updated_by)
self.user_id = user_id
self.date = datetime.strptime(date, entity.DATETIME_FMT)
self.subject = subject
self.body = body
if (read_date is not None):
self.read_date = datetime.strptime(read_date, entity.DATETIME_FMT)
@classmethod
def embedded(cls):
return ['tags']
class Tag(entity.Entity, db.Model):
attributes = ['domain_id', 'name', 'color', 'description']
attributes += entity.Entity.attributes
domain_id = db.Column(
db.CHAR(32), db.ForeignKey('domain.id'), nullable=False)
name = db.Column(db.String(60), nullable=False)
color = db.Column(db.CHAR(7), nullable=False)
description = db.Column(db.String(1024), nullable=False)
__table_args__ = (
UniqueConstraint('domain_id', 'name', name='tag_domain_id_name_uk'),)
def __init__(self, id, domain_id, name, color, description,
active=True, created_at=None, created_by=None,
updated_at=None, updated_by=None, tag=None):
super().__init__(id, active, created_at, created_by,
updated_at, updated_by, tag)
self.domain_id = domain_id
self.name = name
self.color = color
self.description = description
class Grant(entity.Entity, db.Model):
attributes = ['user_id', 'role_id']
attributes += entity.Entity.attributes
user_id = db.Column(db.CHAR(32), db.ForeignKey("user.id"), nullable=False)
user = orm.relationship("User", backref=orm.backref('grants'))
role_id = db.Column(db.CHAR(32), db.ForeignKey("role.id"), nullable=False)
role = orm.relationship("Role", backref=orm.backref('grants'))
def __init__(self,
id,
user_id,
role_id,
active=True,
created_at=None,
created_by=None,
updated_at=None,
updated_by=None):
super().__init__(id, active, created_at, created_by, updated_at,
updated_by)
self.user_id = user_id
self.role_id = role_id
class DomainContact(entity.Entity, db.Model):
attributes = ['contact', 'tag']
domain_id = db.Column(db.CHAR(32),
db.ForeignKey("domain.id"),
nullable=False)
contact = db.Column(db.String(100), nullable=False)
def __init__(self,
id,
domain_id,
contact,
active=True,
created_at=None,
created_by=None,
updated_at=None,
updated_by=None,
tag=None):
super().__init__(id, active, created_at, created_by, updated_at,
updated_by, tag)
self.domain_id = domain_id
self.contact = contact
class Domain(entity.Entity, db.Model):
attributes = ['name', 'parent_id']
attributes += entity.Entity.attributes
name = db.Column(db.String(60), nullable=False, unique=True)
parent_id = db.Column(db.CHAR(32),
db.ForeignKey("domain.id"),
nullable=True)
def __init__(self,
id,
name,
parent_id=None,
active=True,
created_at=None,
created_by=None,
updated_at=None,
updated_by=None):
super().__init__(id, active, created_at, created_by, updated_at,
updated_by)
self.name = name
self.parent_id = parent_id
class User(entity.Entity, db.Model):
attributes = ['domain_id', 'name', 'email']
attributes += entity.Entity.attributes
domain_id = db.Column(db.CHAR(32),
db.ForeignKey('domain.id'),
nullable=False)
domain = orm.relationship('Domain', backref=orm.backref('users'))
name = db.Column(db.String(80), nullable=False)
email = db.Column(db.String(80), nullable=False)
password = db.Column(db.String(64), nullable=False)
__table_args__ = (UniqueConstraint('name',
'domain_id',
name='user_name_domain_id_uk'), )
__table_args__ = (UniqueConstraint('email',
'domain_id',
name='user_email_domain_id_uk'), )
def __init__(self,
id,
domain_id,
name,
email,
password=uuid.uuid4().hex,
active=True,
created_at=None,
created_by=None,
updated_at=None,
updated_by=None):
super().__init__(id, active, created_at, created_by, updated_at,
updated_by)
self.domain_id = domain_id
self.name = name
self.email = email
self.password = password
class TimelineEvent(entity.Entity, db.Model):
LIMIT_SEARCH = 30
attributes = ['domain_id', 'event_at', 'event_by', 'lat', 'lon',
'description', 'entity', 'entity_id']
attributes += entity.Entity.attributes
domain_id = db.Column(
db.CHAR(32), db.ForeignKey('domain.id'), nullable=False)
event_at = db.Column(db.DateTime, nullable=False, unique=False)
event_by = db.Column(db.CHAR(32), nullable=False, unique=False)
lat = db.Column(db.Numeric(14, 8), nullable=False, unique=False)
lon = db.Column(db.Numeric(14, 8), nullable=False, unique=False)
description = db.Column(db.String(500), nullable=False, unique=False)
entity = db.Column(db.String(100), nullable=True, unique=False)
entity_id = db.Column(db.CHAR(32), nullable=True, unique=False)
users = orm.relationship(
"TimelineEventUser", backref=orm.backref('timeline_event_user'),
cascade='delete,delete-orphan,save-update')
__tablename__ = 'timeline_event'
def __init__(self, id, domain_id, event_at, event_by, lat, lon,
description, entity=None, entity_id=None,
active=True, created_at=None, created_by=None,
updated_at=None, updated_by=None, tag=None):
super().__init__(id, active, created_at, created_by,
updated_at, updated_by, tag)
self.id = id
self.domain_id = domain_id
self.event_at = event_at
self.event_by = event_by
self.lat = lat
self.lon = lon
self.description = description
self.entity = entity
self.entity_id = entity_id,
@classmethod
def individual(cls):
return 'timeline_event'
@classmethod
def embedded(cls):
return ['users']
class Capability(entity.Entity, db.Model):
attributes = ['route_id', 'domain_id']
attributes += entity.Entity.attributes
route_id = db.Column(
db.CHAR(32), db.ForeignKey("route.id"), nullable=False)
domain_id = db.Column(
db.CHAR(32), db.ForeignKey("domain.id"), nullable=False)
__table_args__ = (
UniqueConstraint('route_id', 'domain_id', name='capability_uk'),)
def __init__(self, id, route_id, domain_id, active=True,
created_at=None, created_by=None,
updated_at=None, updated_by=None):
super().__init__(id, active, created_at, created_by,
updated_at, updated_by)
self.route_id = route_id
self.domain_id = domain_id
@classmethod
def collection(cls):
return 'capabilities'
class Tag(entity.Entity):
attributes = ['label']
attributes += entity.Entity.attributes
label = db.Column(db.String(50), nullable=False)
def __init__(self,
id,
label,
active=True,
created_at=None,
created_by=None,
updated_at=None,
updated_by=None):
super().__init__(id, active, created_at, created_by, updated_at,
updated_by)
self.label = label
class Token(entity.Entity, db.Model):
attributes = ['user_id']
attributes += entity.Entity.attributes
user_id = db.Column(db.CHAR(32), db.ForeignKey("user.id"), nullable=False)
def __init__(self,
id,
user_id,
active=True,
created_at=datetime.now(),
created_by=user_id,
updated_at=None,
updated_by=None):
super().__init__(id, active, created_at, created_by, updated_at,
updated_by)
self.user_id = user_id
class Role(entity.Entity, db.Model):
USER = '******'
SYSADMIN = 'Sysadmin'
ADMIN = 'Admin'
attributes = ['name']
attributes += entity.Entity.attributes
name = db.Column(db.String(80), nullable=False)
__table_args__ = (
UniqueConstraint('name', name='role_name_uk'),)
def __init__(self, id, name,
active=True, created_at=None, created_by=None,
updated_at=None, updated_by=None, tag=None):
super().__init__(id, active, created_at, created_by,
updated_at, updated_by, tag)
self.name = name
class DomainAddress(entity.Entity, db.Model):
attributes = [
'postal_code', 'address_line_1', 'address_line_2', 'city',
'state_province', 'country', 'tag'
]
domain_id = db.Column(db.CHAR(32),
db.ForeignKey('domain.id'),
nullable=False)
postal_code = db.Column(db.String(30), nullable=False)
address_line_1 = db.Column(db.String(255), nullable=False)
address_line_2 = db.Column(db.String(255), nullable=True)
city = db.Column(db.String(100), nullable=False)
state_province = db.Column(db.String(60), nullable=False)
country = db.Column(db.String(60), nullable=False)
def __init__(self,
id,
domain_id,
postal_code,
address_line_1,
city,
state_province,
country,
address_line_2=None,
active=True,
created_at=None,
created_by=None,
updated_at=None,
updated_by=None,
tag=None):
super().__init__(id, active, created_at, created_by, updated_at,
updated_by, tag)
self.domain_id = domain_id
self.postal_code = postal_code
self.address_line_1 = address_line_1
self.address_line_2 = address_line_2
self.city = city
self.state_province = state_province
self.country = country
class User(entity.Entity, db.Model):
SYSADMIN_USERNAME = '******'
attributes = ['domain_id', 'name', 'email', 'nickname', 'photo_id']
attributes += entity.Entity.attributes
domain_id = db.Column(db.CHAR(32),
db.ForeignKey('domain.id'),
nullable=False)
domain = orm.relationship('Domain', backref=orm.backref('users'))
name = db.Column(db.String(80), nullable=False)
nickname = db.Column(db.String(80), nullable=True)
email = db.Column(db.String(80), nullable=False)
password = db.Column(db.String(64),
nullable=False,
default=uuid.uuid4().hex)
photo_id = db.Column(db.CHAR(32), db.ForeignKey('image.id'), nullable=True)
__table_args__ = (
UniqueConstraint('name', 'domain_id', name='user_name_domain_id_uk'),
UniqueConstraint('email', 'domain_id', name='user_email_domain_id_uk'),
)
def __init__(self,
id,
domain_id,
name,
email,
nickname=None,
photo_id=None,
active=True,
created_at=None,
created_by=None,
updated_at=None,
updated_by=None,
tag=None):
super().__init__(id, active, created_at, created_by, updated_at,
updated_by, tag)
self.domain_id = domain_id
self.name = name
self.email = email
# self.password = password
self.nickname = nickname
self.photo_id = photo_id
class Entity(object):
attributes = [
'id', 'active', 'created_at', 'created_by', 'updated_at', 'updated_by',
'tag'
]
pagination_column = 'id desc'
id = db.Column(db.CHAR(32), primary_key=True, autoincrement=False)
active = db.Column(db.Boolean())
created_at = db.Column(db.DateTime)
created_by = db.Column(db.CHAR(32))
updated_at = db.Column(db.DateTime)
updated_by = db.Column(db.CHAR(32))
tag = db.Column(db.String(1000))
def __init__(self,
id,
active=True,
created_at=None,
created_by=None,
updated_at=None,
updated_by=None,
tag=None):
self.id = id
self.active = active
self.created_at = created_at
self.created_by = created_by
self.updated_at = updated_at
self.updated_by = updated_by
self.tag = tag
@classmethod
def embedded(cls):
return []
@classmethod
def individual(cls):
return cls.__name__.lower()
@classmethod
def collection(cls):
return cls.individual() + 's'
def is_stable(self):
return True
def allDateFmtFromAllTypes(self, dateOrDateTime):
dateTime = None
if dateOrDateTime is not None:
if type(dateOrDateTime) is str:
try:
if len(dateOrDateTime.strip()) == 10:
dateTime = datetime.strptime(dateOrDateTime, DATE_FMT)
elif len(dateOrDateTime.strip()) == 24:
dateTime = datetime.strptime(dateOrDateTime,
DATETIME_FMT)
except Exception:
pass
else:
if type(dateOrDateTime) is datetime:
dateTime = dateOrDateTime
return dateTime
def convert_numeric(self, value):
if str(value).find('.') > -1:
return float(value.real)
else:
return int(value)
def to_dict(self, include_dict=None, stringify=True):
d = {}
include_dict = include_dict or {}
for attr in self.__class__.attributes:
if attr not in include_dict:
value = getattr(self, attr)
if value is not None:
if isinstance(value, Enum):
d[attr] = value.name
elif isinstance(value, Decimal):
d[attr] = self.convert_numeric(value)
elif isinstance(value, Entity):
include_dict.update({attr: {}})
else:
d[attr] = value
# TODO(fdoliveira) Why change format of date and datetime?
# if stringify and isinstance(value, datetime):
# d[attr] = value.strftime(DATETIME_FMT)
# elif stringify and isinstance(value, date):
# d[attr] = value.strftime(DATETIME_FMT)
# else:
# Only embedded that are not in include will be updated
# include_dict.update({attr: {} for attr in self.embedded()})
for attr in self.embedded():
if attr not in include_dict:
include_dict.update({attr: {}})
if include_dict:
for key, value in include_dict.items():
if not isinstance(value, dict):
# it's a filter
if getattr(self, key) != value:
raise AssertionError()
continue
thing = getattr(self, key)
if isinstance(thing, list):
values = []
empty = True
for part in thing:
try:
values.append(part.to_dict(value))
empty = False
except AssertionError:
# filter mismatch, ignore the expansion
pass
if values and empty:
# filter mismatch, no entity matched the filter,
# re-raise and ignore current entity
raise AssertionError()
d[key] = [part.to_dict(value) for part in thing]
else:
try:
if thing is not None:
d[key] = thing.to_dict(value)
except AssertionError:
# filter mismatch, re-raise to ignore current entity
raise
return d
def get_last_user_id_who_modified(self):
if self.updated_by is not None:
return self.updated_by
else:
return self.created_by
class Domain(entity.Entity, db.Model):
DEFAULT = 'default'
attributes = [
'name', 'display_name', 'parent_id', 'application_id', 'logo_id',
'doc', 'description', 'settings'
]
attributes += entity.Entity.attributes
application_id = db.Column(db.CHAR(32),
db.ForeignKey("application.id"),
nullable=False)
application = orm.relationship('Application',
backref=orm.backref('domains'))
name = db.Column(db.String(60), nullable=False, unique=True)
display_name = db.Column(db.String(100), nullable=False)
doc = db.Column(db.String(60), nullable=True)
description = db.Column(db.String(1000), nullable=True)
logo_id = db.Column(db.CHAR(32), db.ForeignKey('image.id'), nullable=True)
parent_id = db.Column(db.CHAR(32),
db.ForeignKey("domain.id"),
nullable=True)
addresses = orm.relationship('DomainAddress',
backref=orm.backref('domain_addresses'),
cascade='delete,delete-orphan,save-update')
contacts = orm.relationship('DomainContact',
backref=orm.backref('domain_contacts'),
cascade='delete,delete-orphan,save-update')
_settings = db.Column('settings', db.Text, nullable=False, default='{}')
__tablename__ = 'domain'
def __init__(self,
id,
application_id,
name,
display_name=None,
doc=None,
description=None,
logo_id=None,
parent_id=None,
active=True,
created_at=None,
created_by=None,
updated_at=None,
updated_by=None,
tag=None):
super().__init__(id, active, created_at, created_by, updated_at,
updated_by, tag)
self.application_id = application_id
self.name = name
if display_name is None:
self.display_name = name
else:
self.display_name = display_name
self.doc = doc
self.description = description
self.logo_id = logo_id
self.parent_id = parent_id
def _has_setting(self, key: str) -> bool:
return self.settings.get(key) is not None
def remove_setting(self, key: str):
if not self._has_setting(key):
raise exception.BadRequest(f"Erro! Setting {key} not exists")
settings = self.settings
value = settings.pop(key)
self._save_settings(settings)
return value
def update_setting(self, key: str, value: Any):
settings = self.settings
settings[key] = value
self._save_settings(settings)
return value
@property
def settings(self):
try:
settings_str = '{}' if self._settings is None else self._settings
return json.loads(settings_str)
except Exception:
return {}
def _save_settings(self, settings: dict):
self._settings = json.dumps(settings, default=str)
@classmethod
def embedded(cls):
return ['addresses', 'contacts']
class Entity(object):
attributes = [
'id', 'active', 'created_at', 'created_by', 'updated_at', 'updated_by'
]
id = db.Column(db.CHAR(32), primary_key=True)
active = db.Column(db.Boolean())
created_at = db.Column(db.DateTime)
created_by = db.Column(db.CHAR(32))
updated_at = db.Column(db.DateTime)
updated_by = db.Column(db.CHAR(32))
def __init__(self,
id,
active=True,
created_at=None,
created_by=None,
updated_at=None,
updated_by=None):
self.id = id
self.active = active
self.created_at = created_at
self.created_by = created_by
self.updated_at = updated_at
self.updated_by = updated_by
@classmethod
def embedded(cls):
return []
@classmethod
def individual(cls):
return cls.__name__.lower()
@classmethod
def collection(cls):
return cls.individual() + 's'
def is_stable(self):
return True
def to_dict(self, include_dict=None, stringify=True):
d = {}
for attr in self.__class__.attributes:
value = getattr(self, attr)
d[attr] = value
# TODO(fdoliveira) Why change format of date and datetime?
# if stringify and isinstance(value, datetime):
# d[attr] = value.strftime(DATETIME_FMT)
# elif stringify and isinstance(value, date):
# d[attr] = value.strftime(DATETIME_FMT)
# else:
include_dict = include_dict or {}
include_dict.update({attr: {} for attr in self.embedded()})
if include_dict:
for key, value in include_dict.items():
if not isinstance(value, dict):
# it's a filter
if getattr(self, key) != value:
raise AssertionError()
continue
thing = getattr(self, key)
if isinstance(thing, list):
values = []
empty = True
for part in thing:
try:
values.append(part.to_dict(value))
empty = False
except AssertionError:
# filter mismatch, ignore the expansion
pass
if values and empty:
# filter mismatch, no entity matched the filter,
# re-raise and ignore current entity
raise AssertionError()
d[key] = [part.to_dict(value) for part in thing]
else:
try:
d[key] = thing.to_dict(value)
except AssertionError:
# filter mismatch, re-raise to ignore current entity
raise
return d
