def empty_session(): engine = create_engine(TEST_DATABASE_URI_IN_MEMORY) metadata.create_all(engine) for table in reversed(metadata.sorted_tables): engine.execute(table.delete()) map_model_to_tables() session_factory = sessionmaker(bind=engine) yield session_factory() metadata.drop_all(engine) clear_mappers()
def session_factory(): clear_mappers() engine = create_engine(TEST_DATABASE_URI_IN_MEMORY) metadata.create_all(engine) for table in reversed(metadata.sorted_tables): engine.execute(table.delete()) map_model_to_tables() session_factory = sessionmaker(bind=engine) database_repository.populate(engine, TEST_DATA_PATH_DATABASE) yield session_factory metadata.drop_all(engine) clear_mappers()
def database_engine(): engine = create_engine(TEST_DATABASE_URI_FILE) clear_mappers() metadata.create_all(engine) # Conditionally create database tables. for table in reversed( metadata.sorted_tables): # Remove any data from the tables. engine.execute(table.delete()) map_model_to_tables() database_repository.populate(engine, TEST_DATA_PATH_DATABASE) yield engine metadata.drop_all(engine) clear_mappers()
def database_engine(): engine = create_engine(TEST_DATABASE_URI_FILE) clear_mappers() metadata.create_all(engine) # Conditionally create database tables. for table in reversed( metadata.sorted_tables): # Remove any data from the tables. engine.execute(table.delete()) map_model_to_tables() session_factory = sessionmaker(bind=engine) database_repository.populate(session_factory, TEST_DATA_PATH_DATABASE, "Data1000Movies.csv") database_repository.populate_user_comment(engine, TEST_DATA_PATH_DATABASE) yield engine metadata.drop_all(engine) clear_mappers()
def create_app(test_config=None): app = Flask(__name__) app.config.from_object('config.Config') data_path = "/Users/vivian/Desktop/yyou211_235_A3/movie_web_app/adapters/data" if test_config is not None: # Load test configuration, and override any configuration settings. app.config.from_mapping(test_config) data_path = app.config['TEST_DATA_PATH'] if app.config['REPOSITORY'] == 'memory': # Create the MemoryRepository instance for a memory-based repository. repo.repo_instance = memory_repository.MemoryRepository() memory_repository.populate(data_path, repo.repo_instance) elif app.config['REPOSITORY'] == 'database': # Configure database. database_uri = app.config['SQLALCHEMY_DATABASE_URI'] database_echo = app.config['SQLALCHEMY_ECHO'] database_engine = create_engine( database_uri, connect_args={"check_same_thread": False}, poolclass=NullPool, echo=database_echo) if app.config['TESTING'] == 'True' or len( database_engine.table_names()) == 0: print("REPOPULATING DATABASE") # For testing, or first-time use of the web application, reinitialise the database. clear_mappers() metadata.create_all( database_engine) # Conditionally create database tables. for table in reversed(metadata.sorted_tables ): # Remove any data from the tables. database_engine.execute(table.delete()) # Generate mappings that map domain model classes to the database tables. map_model_to_tables() session_factory = sessionmaker(autocommit=False, autoflush=True, bind=database_engine) database_repository.populate(session_factory, data_path, "Data1000Movies.csv") database_repository.populate_user_comment(database_engine, data_path) else: # Solely generate mappings that map domain model classes to the database tables. map_model_to_tables() # Create the database session factory using sessionmaker (this has to be done once, in a global manner) session_factory = sessionmaker(autocommit=False, autoflush=True, bind=database_engine) # Create the SQLAlchemy DatabaseRepository instance for an sqlite3-based repository. repo.repo_instance = database_repository.SqlAlchemyRepository( session_factory) # Build the application - these steps require an application context. with app.app_context(): # Register blueprints. from .home import home app.register_blueprint(home.home_blueprint) from .movie import movie app.register_blueprint(movie.movie_blueprint) from .authentication import authentication app.register_blueprint(authentication.authentication_blueprint) from .utilities import utilities app.register_blueprint(utilities.utilities_blueprint) # Register a callback the makes sure that database sessions are associated with http requests # We reset the session inside the database repository before a new flask request is generated @app.before_request def before_flask_http_request_function(): if isinstance(repo.repo_instance, database_repository.SqlAlchemyRepository): repo.repo_instance.reset_session() # Register a tear-down method that will be called after each request has been processed. @app.teardown_appcontext def shutdown_session(exception=None): if isinstance(repo.repo_instance, database_repository.SqlAlchemyRepository): repo.repo_instance.close_session() return app
def create_app(test_config=None): # Create the Flask app object. app = Flask(__name__) # Configure the app from configuration-file settings. app.config.from_object('config.Config') data_path = "movie_web_app/datafilereaders" if test_config is not None: # Load test configuration, and overrride any configuration settings. app.config.from_mapping(test_config) data_path = app.config['TEST_DATA_PATH'] if app.config['REPOSITORY'] == 'memory': # Create the MemoryRepository instance for a memory-based repository. repo.repo_instance = Movie_repo.MovieRepo() Movie_repo.populate(data_path, repo.repo_instance) elif app.config['REPOSITORY'] == 'database': # Configure database. database_uri = app.config['SQLALCHEMY_DATABASE_URI'] # We create a comparatively simple SQLite database, which is based on a single file (see .env for URI). # For example the file database could be located locally and relative to the application in covid-19.db, # leading to a URI of "sqlite:///covid-19.db". # Note that create_engine does not establish any actual DB connection directly! database_echo = app.config['SQLALCHEMY_ECHO'] database_engine = create_engine( database_uri, connect_args={"check_same_thread": False}, poolclass=NullPool, echo=database_echo) if app.config['TESTING'] == 'True' or len( database_engine.table_names()) == 0: print("REPOPULATING DATABASE") # For testing, or first-time use of the web application, reinitialise the database. clear_mappers() metadata.create_all( database_engine) # Conditionally create database tables. for table in reversed(metadata.sorted_tables ): # Remove any data from the tables. database_engine.execute(table.delete()) # Generate mappings that map domain model classes to the database tables. map_model_to_tables() datafile = 'Data1000Movies.csv' session_factory = sessionmaker(autocommit=False, autoflush=True, bind=database_engine) database_repository.populate(database_engine, session_factory, data_path, datafile) else: # Solely generate mappings that map domain model classes to the database tables. map_model_to_tables() # Create the database session factory using sessionmaker (this has to be done once, in a global manner) session_factory = sessionmaker(autocommit=False, autoflush=True, bind=database_engine) # Create the SQLAlchemy DatabaseRepository instance for an sqlite3-based repository. repo.repo_instance = database_repository.SqlAlchemyRepository( session_factory) with app.app_context(): # Register blueprints. from .home import home app.register_blueprint(home.home_blueprint) from .movie import movie_page app.register_blueprint(movie_page.movies_blueprint) from .authentication import authentication app.register_blueprint(authentication.authentication_blueprint) from .utilities import utilities app.register_blueprint(utilities.utilities_blueprint) # Register a callback the makes sure that database sessions are associated with http requests # We reset the session inside the database repository before a new flask request is generated @app.before_request def before_flask_http_request_function(): if isinstance(repo.repo_instance, database_repository.SqlAlchemyRepository): repo.repo_instance.reset_session() # Register a tear-down method that will be called after each request has been processed. @app.teardown_appcontext def shutdown_session(exception=None): if isinstance(repo.repo_instance, database_repository.SqlAlchemyRepository): repo.repo_instance.close_session() return app
def create_app(test_config=None): app = Flask(__name__) app.config.from_object('config.Config') data_path = os.path.join('movie_web_app', 'adapters', 'data') if test_config is not None: # Load test configuration, and override any configuration settings. app.config.from_mapping(test_config) data_path = app.config['TEST_DATA_PATH'] if app.config['REPOSITORY'] == 'memory': # Create the MemoryRepository instance for a memory-based repository. repo.repo_instance = MemoryRepository( "movie_web_app/adapters/Data1000Movies.csv") elif app.config['REPOSITORY'] == 'database': # Configure database. database_uri = app.config['SQLALCHEMY_DATABASE_URI'] # We create a comparatively simple SQLite database, which is based on a single file (see .env for URI). # For example the file database could be located locally and relative to the application in covid-19.db, # leading to a URI of "sqlite:///covid-19.db". # Note that create_engine does not establish any actual DB connection directly! database_echo = app.config['SQLALCHEMY_ECHO'] database_engine = create_engine( database_uri, connect_args={"check_same_thread": False}, poolclass=NullPool, echo=database_echo) if app.config['TESTING'] == 'True' or len( database_engine.table_names()) == 0: print("REPOPULATING DATABASE") # For testing, or first-time use of the web application, reinitialise the database. clear_mappers() metadata.create_all( database_engine) # Conditionally create database tables. for table in reversed(metadata.sorted_tables ): # Remove any data from the tables. database_engine.execute(table.delete()) # Generate mappings that map domain model classes to the database tables. map_model_to_tables() database_repository.populate( database_engine, data_path, "movie_web_app/adapters/Data1000Movies.csv") else: # Solely generate mappings that map domain model classes to the database tables. map_model_to_tables() # Create the database session factory using sessionmaker (this has to be done once, in a global manner) session_factory = sessionmaker(autocommit=False, autoflush=True, bind=database_engine) # Create the SQLAlchemy DatabaseRepository instance for an sqlite3-based repository. repo.repo_instance = database_repository.SqlAlchemyRepository( session_factory) with app.app_context(): from .movie_blueprint import movie app.register_blueprint(movie.movie_blueprint) from .authentication import authentication app.register_blueprint(authentication.authentication_blueprint) return app
def create_app(test_config=None): app = Flask(__name__) # Create the MemoryRepository implementation for a memory-based repository. repo.repo_instance = MemoryRepository() # Configure the app from configuration-file settings app.config.from_object('config.Config') data_path = os.path.join(os.path.join(os.sep,'Users', 'user','Movie_Web_Application_sqlitedb','movie_web_app', 'adapters', 'datafiles'), 'Data1000Movies.csv') if test_config is not None: app.config.from_mapping(test_config) data_path = app.config['TEST_DATA_PATH'] if app.config['REPOSITORY'] == 'memory': repo.repo_instance = MemoryRepository() read_csv_file(data_path,repo.repo_instance) elif app.config['REPOSITORY'] == 'database': # Configure database. database_uri = app.config['SQLALCHEMY_DATABASE_URI'] database_echo = app.config['SQLALCHEMY_ECHO'] database_engine = create_engine(database_uri, connect_args={"check_same_thread": False}, poolclass=NullPool, echo=database_echo) if app.config['TESTING'] == True or len(database_engine.table_names()) == 0: print("REPOPULATING DATABASE") clear_mappers() metadata.create_all(database_engine) for table in reversed(metadata.sorted_tables): database_engine.execute(table.delete()) map_model_to_tables() database_repository.populate(database_engine, data_path) else: map_model_to_tables() session_factory = sessionmaker(autocommit=False, autoflush=True, bind=database_engine) repo.repo_instance = database_repository.SqlAlchemyRepository(session_factory) with app.app_context(): # Register blueprints. from .home import home app.register_blueprint(home.home_blueprint) from .search import search app.register_blueprint(search.search_blueprint) from .movies import movies app.register_blueprint(movies.movies_blueprint) from .authentication import authentication app.register_blueprint(authentication.authentication_blueprint) @app.before_request def before_flask_http_request_function(): if isinstance(repo.repo_instance, database_repository.SqlAlchemyRepository): repo.repo_instance.reset_session() @app.teardown_appcontext def shutdown_session(exception=None): if isinstance(repo.repo_instance, database_repository.SqlAlchemyRepository): repo.repo_instance.close_session() return app