def __init__(self, *args, **kwargs): """Initialize and maintain Engine""" # Since SQLAlchemyProvider can cater to multiple databases, it is important # that we know which database we are dealing with, to run database-specific # statements like `PRAGMA` for SQLite. if 'DATABASE' not in args[2]: logger.error( f'Missing `DATABASE` information in conn_info: {args[2]}') raise ConfigurationError( 'Missing `DATABASE` attribute in Connection info') super().__init__(*args, **kwargs) kwargs = self._get_database_specific_engine_args() self._engine = create_engine(make_url(self.conn_info['DATABASE_URI']), **kwargs) if self.conn_info['DATABASE'] == Database.POSTGRESQL.value: # Nest database tables under a schema, so that we have complete control # on creating/dropping db structures. We cannot control structures in the # the default `public` schema. # # Use `SCHEMA` value if specified as part of the conn info. Otherwise, construct # and use default schema name as `DB`_schema. schema = self.conn_info[ 'SCHEMA'] if 'SCHEMA' in self.conn_info else 'public' self._metadata = MetaData(bind=self._engine, schema=schema) else: self._metadata = MetaData(bind=self._engine) # A temporary cache of already constructed model classes self._model_classes = {}
def process_request(self, request_object): email = request_object.email account = Account.query.filter(email=email).first if account: token = str(uuid.uuid4()) token_ts = datetime.datetime.utcnow() + datetime.timedelta( hours=24) account.update({ "verification_token": token, "token_timestamp": token_ts }) # Send the password request email email_builder = perform_import(active_config.RESET_EMAIL_CALLBACK) if not email_builder: raise ConfigurationError( '`RESET_EMAIL_CALLBACK` config must be set to a ' 'valid function.') email_msg = email_builder(account.email, token) email_msg.send() return ResponseSuccess(Status.SUCCESS, {"message": "Success"}) else: return ResponseFailure.build_unprocessable_error( {'email': 'Account does not exist.'})
def _initialize_brokers(self): """Read config file and initialize brokers""" configured_brokers = self.config['BROKERS'] broker_objects = {} logger.debug("Initializing brokers...") if configured_brokers and isinstance(configured_brokers, dict): if 'default' not in configured_brokers: raise ConfigurationError("You must define a 'default' broker") for broker_name, conn_info in configured_brokers.items(): broker_full_path = conn_info['PROVIDER'] broker_module, broker_class = broker_full_path.rsplit( '.', maxsplit=1) broker_cls = getattr(importlib.import_module(broker_module), broker_class) broker_objects[broker_name] = broker_cls( broker_name, self, conn_info) self._brokers = broker_objects # Initialize subscribers for Brokers for _, subscriber_record in self.subscribers.items(): subscriber = subscriber_record.cls broker_name = subscriber.meta_.broker if broker_name not in self._brokers: raise ConfigurationError( f"Broker {broker_name} has not been configured.") self._brokers[broker_name].register(subscriber.meta_.domain_event, subscriber) # Initialize command handlers for Brokers for _, command_handler_record in self.command_handlers.items(): command_handler = command_handler_record.cls broker_name = command_handler.meta_.broker if broker_name not in self._brokers: raise ConfigurationError( f"Broker {broker_name} has not been configured.") self._brokers[broker_name].register( command_handler.meta_.command_cls, command_handler)
def generate_identity(cls): """Generate Unique Identifier, based on configured strategy""" if current_domain.config['IDENTITY_STRATEGY'] == IdentityStrategy.UUID: if current_domain.config['IDENTITY_TYPE'] == IdentityType.INTEGER: return uuid4().int elif current_domain.config['IDENTITY_TYPE'] == IdentityType.STRING: return str(uuid4()) elif current_domain.config['IDENTITY_TYPE'] == IdentityType.UUID: return uuid4() else: raise ConfigurationError( f'Unknown Identity Type {current_domain.config["IDENTITY_TYPE"]}' ) return None # Database will generate the identity
def build_field(self, field_obj): """ Map the Entity field to a Marshmallow field """ # Lookup the field mapping in the dictionary, default to String field e_field_type = type(field_obj) if e_field_type in self.field_mapping: field_opts = {} if e_field_type == field.List: field_opts['cls_or_instance'] = ma.fields.String return self.field_mapping[e_field_type](**field_opts) elif e_field_type == field.Auto: raise ConfigurationError( 'Fields of type `Auto` must be manually set in the serializer.' ) else: return ma.fields.String()
def _initialize_providers(self): """Read config file and initialize providers""" configured_providers = self.config['DATABASES'] provider_objects = {} if configured_providers and isinstance(configured_providers, dict): if 'default' not in configured_providers: raise ConfigurationError( "You must define a 'default' provider") for provider_name, conn_info in configured_providers.items(): provider_full_path = conn_info['PROVIDER'] provider_module, provider_class = provider_full_path.rsplit( '.', maxsplit=1) provider_cls = getattr( importlib.import_module(provider_module), provider_class) provider_objects[provider_name] = provider_cls( provider_name, self, conn_info) return provider_objects
def _get_identity_type(): """Retrieve the configured data type for AutoGenerated Identifiers If `current_domain` is not yet available, it simply means that Protean is still being loaded. Default to `Identity.STRING` """ try: if current_domain.config['IDENTITY_TYPE'] == IdentityType.INTEGER: return sa_types.Integer elif current_domain.config['IDENTITY_TYPE'] == IdentityType.STRING: return sa_types.String elif current_domain.config['IDENTITY_TYPE'] == IdentityType.UUID: return GUID else: raise ConfigurationError( f'Unknown Identity Type {current_domain.config["IDENTITY_TYPE"]}' ) except RuntimeError as exc: logger.error( f'RuntimeError while identifying data type for identities: {exc}') return sa_types.String
def __init__(self, *args, **kwargs): super().__init__(*args, **kwargs) # Updates the declared fields with the fields of the Entity class if not self.opts.entity_cls or not \ issubclass(self.opts.entity_cls, Entity): raise ConfigurationError( '`Meta.entity` option must be set and a subclass of `Entity`.') entity_fields = OrderedDict() for field_name, field_obj in \ self.opts.entity_cls.meta_.declared_fields.items(): if self.opts.fields and field_name not in self.opts.fields: continue elif self.opts.exclude and field_name in self.opts.exclude: continue elif isinstance(field_obj, field.Reference): continue elif field_name not in self.declared_fields: entity_fields[field_name] = self.build_field(field_obj) self.declared_fields.update(entity_fields)
def _initialize_email_providers(self): """Read config file and initialize email providers""" configured_email_providers = self.domain.config["EMAIL_PROVIDERS"] email_provider_objects = {} if configured_email_providers and isinstance( configured_email_providers, dict): if "default" not in configured_email_providers: raise ConfigurationError( "You must define a 'default' email provider") for provider_name, conn_info in configured_email_providers.items(): provider_full_path = conn_info["PROVIDER"] provider_module, provider_class = provider_full_path.rsplit( ".", maxsplit=1) provider_cls = getattr( importlib.import_module(provider_module), provider_class) email_provider_objects[provider_name] = provider_cls( provider_name, self, conn_info) self._email_providers = email_provider_objects
def get_serializer_cls(self): """ Get the serializer class from the settings""" if not active_config.ACCOUNT_SERIALIZER_CLS: raise ConfigurationError( '`ACCOUNT_SERIALIZER_CLS` has not been set in the config.') return perform_import(active_config.ACCOUNT_SERIALIZER_CLS)
def get_entity_cls(self): """ Get the schema class from the config """ if not active_config.ACCOUNT_ENTITY: raise ConfigurationError( '`ACCOUNT_ENTITY` has not been set in the config.') return perform_import(active_config.ACCOUNT_ENTITY)