class Client(ff.AggregateRoot): id: str = ff.id_() name: str = ff.required(str) grant_type: str = ff.required(str, validators=[ ff.IsOneOf( (authorization_code, implicit, resource_owner_password_credentials, client_credentials)) ]) response_type: str = ff.optional( str, validators=[ff.IsOneOf(response_type_choices)]) scopes: str = ff.required(str) default_redirect_uri: str = ff.required(str) redirect_uris: List[str] = ff.list_() allowed_response_types: List[str] = ff.list_( validators=[ff.IsOneOf(('code', 'token'))]) def validate_redirect_uri(self, redirect_uri: str): return redirect_uri in self.redirect_uris def validate_response_type(self, response_type: str): return response_type in self.allowed_response_types def validate_scopes(self, scopes: List[str]): for scope in scopes: if scope not in self.scopes: return False return True
class Table: entity: sql.Entity = ff.required() relationships: List[sql.Relationship] = ff.required() name: str = None columns: List[Column] = ff.list_() constraints: List = ff.list_() _pks: List[str] = ff.list_() def __post_init__(self): self._initialize() def _initialize(self): self.name = inflection.tableize(self.entity.entity.__name__) for field_ in self.entity.fields: st = field_.sqlalchemy_type if st is not None: self._build_regular_column(field_, st) elif self._needs_relation_column(field_): self._build_relation_column(field_) self._build_pk() def _build_pk(self): self.constraints.append( PrimaryKeyConstraint(*self._pks, name=f'{self.name}_pk')) def _build_regular_column(self, field_: sql.EntityField, sqlalchemy_type: Type): args = [field_.name, sqlalchemy_type] kwargs = {} if field_.is_pk(): self._pks.append(field_.name) self.columns.append(Column(*args, **kwargs)) def _needs_relation_column(self, field_: sql.EntityField): r = self._find_relationship(field_) if r.type == sql.Relationship.ONE_TO_ONE and not r.needs_uselist: return False return not field_.is_list() and r.type != sql.Relationship.MANY_TO_MANY def _build_relation_column(self, field_: sql.EntityField): name = f'{field_.name}_id' setattr(self.entity.entity, name, None) relationship = self._find_relationship(field_) table_name = inflection.tableize(relationship.entity_b.entity.__name__) self.columns.append( Column( name, String(length=36), ForeignKey( f'{table_name}.{relationship.entity_b.primary_key_column.name}' ))) def _find_relationship(self, field_: sql.EntityField): for relationship in self.relationships: if relationship.field_a == field_: return relationship raise RuntimeError( f'Could not find relationship for field {field_.name}')
class Audience(ff.AggregateRoot): id: str = ff.id_() name: str = ff.required() tenant: domain.Tenant = ff.required() campaigns: List[domain.Campaign] = ff.list_() services: list = ff.list_(validators=ff.IsOneOf((MAILCHIMP, ))) meta: dict = ff.dict_() def get_campaign(self, id_: str) -> Optional[domain.Campaign]: for campaign in self.campaigns: if campaign.id == id_: return campaign
class Group(ff.AggregateRoot): id: str = ff.id_() name: str = ff.required(str) users: List[str] = ff.list_() roles: List[str] = ff.list_() def assign_user_to_group(self, user_id: str): if user_id not in self.users: self.users.append(user_id) return 'iam.GroupAssigned', {'user_id': user_id, 'group_id': self.id} def remove_user_from_group(self, user_id: str): if user_id in self.users: self.users.remove(user_id) return 'iam.GroupRemoved', {'user_id': user_id, 'group_id': self.id}
class JoinTable: relationship: sql.Relationship = ff.required() name: str = None columns: List[Column] = ff.list_() sql_table: Table = None def __post_init__(self): self._initialize() def _initialize(self): terms = [ inflection.tableize(self.relationship.entity_a.entity.__name__), inflection.tableize(self.relationship.entity_b.entity.__name__), ] terms.sort() self.name = f'{terms[0]}_{terms[1]}' self.columns.append( Column(self.relationship.entity_a.foreign_id_column_name, String(length=36), ForeignKey(self.relationship.entity_a.fk_column_string))) self.columns.append( Column(self.relationship.entity_b.foreign_id_column_name, String(length=36), ForeignKey(self.relationship.entity_b.fk_column_string))) def __eq__(self, other): if isinstance(other, str): return other == self.name return other.name == self.name def __hash__(self): return hash(self.name)
class Project(ff.AggregateRoot): id: str = ff.id_(is_uuid=False) services: List[Service] = ff.list_() def plan_deployment(self, deployment: ff.Deployment, config: ff.Configuration): project = config.all.get('project') aws = config.contexts.get('firefly_aws') try: api_gateway_resource = aws.get('api_gateways').get('default') except AttributeError: api_gateway_resource = None for s in deployment.services: id_ = f'{project}-{s.name}' service = self.get_service(id_) or Service(id=id_) function = service.get_lambda() for gateway in s.api_gateways: for endpoint in gateway.endpoints: print(endpoint.route) for topic in s.network_topology.topics: print(f'{topic.name}:') for sub in topic.subscribers: print(f' {sub.name}') def get_service(self, id_: str): for s in self.services: if s.id == id_: return s
class TodoList(ff.AggregateRoot, create_on='iam.UserCreated', delete_on='iam.UserDeleted'): id: str = ff.id_() user: User = ff.required() name: str = ff.optional() tasks: List[Task] = ff.list_() def __post_init__(self): if self.name is None: self.name = f"{self.user.name}'s TODO List" @ff.rest('/task', method='POST') def add_task(self, task: Task) -> ff.EventList: self.tasks.append(task) return 'TaskAdded', task def remove_task(self, task: Task): self.tasks.remove(task) def complete_task(self, task_id: str) -> ff.EventList: for task in self.tasks: if task_id == task.id: task.complete_task() return 'TaskCompleted', task raise Exception(f'Task {task_id} not found in TodoList {self}')
class Widget(ff.AggregateRoot): id: str = ff.pk() name: str = ff.required() addresses: List[Address] = ff.list_() category: Category = None part: Part = None priority: int = ff.optional() deleted: bool = ff.optional(default=False)
class Grant(ff.AggregateRoot): id: str = ff.id_() client_id: str = ff.required(str) user_id: str = ff.required(str) code: str = ff.required(str) redirect_uri: str = ff.required(str) scopes: List[str] = ff.list_() expires: datetime = ff.required(datetime) def validate_redirect_uri(self, redirect_uri: str): return self.redirect_uri == redirect_uri
class Stack(ff.Entity): id: str = ff.id_() resources: List[AWSObject] = ff.list_() parameters: List[BaseAWSObject] = ff.list_() def __post_init__(self): for t in ['resources', 'parameters']: converted = [] for resource in getattr(self, t): if isinstance(resource, dict) and 'module' in resource: module = importlib.import_module(resource['module']) type_ = module.get(resource['type']) converted.append(type_.from_dict(resource['data'])) setattr(self, t, converted) def to_dict(self): ret = { 'id': self.id, } for t in ['resources', 'parameters']: ret[t] = [{ 'module': r.__class__.__module__, 'type': r.__class__.__name__, 'data': r.to_dict(), } for r in getattr(self, t)] return ret def num_resources(self): return len(self.resources) + len(self.parameters) def has_resource(self, title: str): for resource in self.resources: if resource.title == title: return True return False def get_resource(self, title: str): for resource in self.resources: if resource.title == title: return resource
class Calendar(ff.AggregateRoot): id: str = ff.id_() events: List[cal.Event] = ff.list_() def add_event(self, event: cal.Event): self.events.append(event) self.dispatch('EventAdded', asdict(event)) def add_reminder(self, event_id: str, reminder: cal.Reminder): for event in self.events: if event.id == event_id: event.reminders.append(reminder) self.dispatch('ReminderAdded', asdict(reminder))
class Role(ff.AggregateRoot): id: str = ff.id_() name: str = ff.required(str) users: List[str] = ff.list_() def assign_role_to_user(self, user_id: str): if user_id not in self.users: self.users.append(user_id) return 'iam.RoleAssigned', {'user_id': user_id, 'role_id': self.id} def remove_role_from_user(self, user_id: str): if user_id in self.users: self.users.remove(user_id) return 'iam.RoleRemoved', {'user_id': user_id, 'role_id': self.id}
class Campaign(ff.Entity): id: str = ff.id_() name: str = ff.required() members: List[domain.AudienceMember] = ff.list_() def get_member_by_contact_id(self, contact_id: str): for member in self.members: if member.contact.id == contact_id: return member def add_contact(self, contact: domain.Contact, **kwargs): if self.get_member_by_contact_id(contact.id) is None: kwargs.update({'contact': contact}) self.members.append( domain.AudienceMember( **ff.build_argument_list(kwargs, domain.AudienceMember)))
class Address(ff.AggregateRoot): id: str = ff.pk() name: str = ff.required() widgets: List[Widget] = ff.list_()
class AudienceMember(ff.AggregateRoot): id: str = ff.id_() audience: str = ff.required() contact: str = ff.required() tags: List[str] = ff.list_() meta: dict = ff.dict_()
class Event(ff.Entity): id: str = ff.id_() name: str = ff.required() reminders: List[cal.Reminder] = ff.list_()
class Category(ff.Entity): id: str = ff.pk() name: str = ff.required() widgets: List[Widget] = ff.list_()
class Role(ff.AggregateRoot): id: str = ff.id_() name: str = ff.required(length=255, index=True) scopes: List[Scope] = ff.list_()
class Entity: entity: Type[E] = ff.required() fields: List[sql.EntityField] = ff.list_() def __post_init__(self): annotations_ = get_type_hints(self.entity) for field_ in fields(self.entity): self.fields.append( sql.EntityField(entity=self, field=field_, annotations=annotations_)) @property def type(self): return self.entity @property def primary_key_column(self): for field_ in self.fields: if field_.is_pk(): return field_ @property def table_name(self): return inflection.tableize(self.entity.__name__) @property def fk_column_string(self): return f'{self.table_name}.{self.primary_key_column.name}' @property def foreign_id_column_name(self): return f'{self.entity.__name__.lower()}_id' def get_field(self, name: str): for f in self.fields: if f.name == name: return f def get_relationship_fields(self) -> List[sql.EntityField]: ret = [] for field_ in self.fields: if field_.sqlalchemy_type is None: ret.append(field_) return ret def add_id_column(self, field_: sql.EntityField, foreign_entity: sql.Entity): name = f'{field_.name}_id' setattr(self.entity, name, None) def __eq__(self, other): try: if issubclass(other, ff.Entity): return self.entity == other except TypeError: pass try: if isinstance(other, sql.Entity): return self.entity == other.entity except TypeError: pass return False
class User(ff.AggregateRoot): id: str = ff.id_() name: str = ff.required() email: str = ff.required(index=True) roles: List[Role] = ff.list_() special_role: Role = ff.optional()
class Widget(ff.AggregateRoot): stuff: List[BaseClass] = ff.list_()
class ConditionSet(ff.ValueObject): all: bool = ff.optional(default=True) conditions: List[Condition] = ff.list_() sub_conditions: List[ConditionSet] = ff.list_()
class Rule(ff.ValueObject): conditions: ConditionSet = ff.required() commands: List[Command] = ff.list_()
class Mappings(ff.AggregateRoot): relationships: List[sql.Relationship] = ff.list_() tables: List[sql.Table] = ff.list_() join_tables: Dict[str, sql.JoinTable] = ff.dict_() entities: List[sql.Entity] = ff.list_() def initialize(self, entities: List[Type[E]]): for entity in entities: self.entities.append(sql.Entity(entity)) for entity in self.entities: relationships = [] for field_ in entity.get_relationship_fields(): relationships.append(self._create_relationship(entity, field_)) self.tables.append(sql.Table(entity=entity, relationships=relationships)) self.relationships.extend(relationships) for r in self.relationships: if r.type == sql.Relationship.MANY_TO_MANY: jt = sql.JoinTable(r) if jt not in self.join_tables: r.join_table = jt self.join_tables[jt.name] = jt else: r.join_table = self.join_tables[jt.name] def add_mappings(self, metadata): for table in self.join_tables.values(): table.sql_table = Table(table.name, metadata, *table.columns) setattr(self, table.name, table.sql_table) for table in self.tables: sql_table = Table(table.name, metadata, *table.columns, *table.constraints) props = {} for r in table.relationships: if r.type == sql.Relationship.MANY_TO_MANY: props[r.field_a.name] = relationship( r.entity_b.entity, secondary=r.join_table.sql_table, back_populates=r.field_b.name, cascade='all' ) else: args = [r.entity_b.entity] kwargs = {'cascade': 'all'} if r.field_b is not None: kwargs['back_populates'] = r.field_b.name if r.type == sql.Relationship.ONE_TO_ONE: kwargs['uselist'] = False props[r.field_a.name] = relationship(*args, **kwargs) mapper(table.entity.entity, sql_table, properties=props, primary_key=sql_table.primary_key) def _create_relationship(self, entity: sql.Entity, field_: sql.EntityField): entity_b = None for e in self.entities: if e == field_.type(): entity_b = e break if entity_b is None: raise RuntimeError(f'Entity "{field_.type().__name__}" in relationship is unmapped.') return sql.Relationship( entity_a=entity, field_a=field_, entity_b=entity_b )