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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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']