def setup_api_test_data(db):
"""
Set up data for API v2.0 tests.
"""
print("Setting up data for API v2.0 tests on %s" % db.engine)
from flexmeasures.data.models.user import User, Role
from flexmeasures.data.models.assets import Asset
user_datastore = SQLAlchemySessionUserDatastore(db.session, User, Role)
test_supplier = user_datastore.find_user(email="*****@*****.**")
battery = Asset.query.filter(Asset.name == "Test battery").one_or_none()
battery.owner = test_supplier
test_prosumer = user_datastore.find_user(email="*****@*****.**")
admin_role = user_datastore.create_role(name="admin",
description="God powers")
user_datastore.add_role_to_user(test_prosumer, admin_role)
# an inactive user
user_datastore.create_user(
username="******",
email="*****@*****.**",
password=hash_password("testtest"),
active=False,
)
def setup_inactive_user(db, setup_accounts, setup_roles_users):
"""
Set up one inactive user.
"""
from flexmeasures.data.models.user import User, Role
user_datastore = SQLAlchemySessionUserDatastore(db.session, User, Role)
user_datastore.create_user(
username="******",
email="*****@*****.**",
password=hash_password("testtest"),
account_id=setup_accounts["Prosumer"].id,
active=False,
)
def setup_db():
if not os.path.exists('./aetel.db'):
print('Creating database...')
user_datastore = SQLAlchemySessionUserDatastore(db_session, User, Role)
init_db()
print('Creating admin role...')
admin_role = user_datastore.find_or_create_role(
name='admin', description='Administrator')
member_role = user_datastore.find_or_create_role(
name='member', description='Miembro Activo')
db_session.commit()
print('Adding admin to database...')
user_datastore.create_user(email='*****@*****.**',
password='******',
dni='00000001A',
year=99,
degree='AA',
school='00',
first_name='Michael Ignatius',
last_name='Thomas Malloc',
telegram="aetelbot",
roles=[admin_role, member_role])
db_session.commit()
user_datastore.create_user(email='*****@*****.**',
password='******',
dni='00000002A',
year=99,
degree='AA',
school='00',
first_name='kek',
last_name='kek',
telegram="kekkek",
roles=['member'])
db_session.commit()
setup_fake_data()
print('Database created.')
else:
print('Database already exists.')
def user(app, client):
"""
Fixture for an active logged-in user
"""
with app.app_context():
user_datastore = SQLAlchemySessionUserDatastore(db.session, User, Role)
user = user_datastore.create_user(
email="*****@*****.**", password=hash_password("testpassword"))
user_datastore.activate_user(user)
client.post("/web-ui/login",
data={
"email": "*****@*****.**",
"password": "******"
},
follow_redirects=True)
yield user
def setup_api_test_data(db, setup_accounts, setup_roles_users):
"""
Adding the task-runner
"""
print("Setting up data for API task runner tests on %s" % db.engine)
from flexmeasures.data.models.user import User, Role
from flexmeasures.data.models.task_runs import LatestTaskRun
# Create test role
user_datastore = SQLAlchemySessionUserDatastore(db.session, User, Role)
test_task_runner_role = user_datastore.create_role(
name="task-runner", description="A node running repeated tasks.")
# Create test user
test_task_runner = user_datastore.create_user(
username="******",
email="*****@*****.**",
password=hash_password("testtest"),
account_id=setup_accounts["Prosumer"].id,
)
user_datastore.add_role_to_user(test_task_runner, test_task_runner_role)
# More task stuff
older_task = LatestTaskRun(
name="task-A",
status=True,
datetime=datetime.utcnow().replace(tzinfo=pytz.utc) -
timedelta(days=1),
)
recent_task = LatestTaskRun(name="task-B", status=False)
db.session.add(older_task)
db.session.add(recent_task)
print("Done setting up data for API task runner tests")
with app.app_context():
user_datastore = SQLAlchemySessionUserDatastore(db.session, User, Role)
security = Security(app, user_datastore) # this sets some app.config
# Create any database tables that don't exist yet.
db.create_all()
# Create the Roles "admin" and "end-user" -- unless they already exist
user_datastore.find_or_create_role(name='admin', description='Administrator')
user_datastore.find_or_create_role(name='user', description='End user')
admin_email = os.environ['ADMIN_EMAIL']
# create admin user
if not user_datastore.get_user(admin_email):
user_datastore.create_user(
email=admin_email,
username='******',
password=os.environ['ADMIN_PASSWORD'],
active=True,
confirmed_at=datetime.now(),
)
# Commit any database changes; the User and Roles must exist before we can add a Role to the User
db.session.commit()
# Give users "user" role, and admin the "admin" role. (This will have no effect if the
# users already have these Roles.)
user_datastore.add_role_to_user(admin_email, 'admin')
# Again, commit any database changes.
db.session.commit()
Base.metadata.drop_all(bind=engine)
Base.metadata.create_all(bind=engine)
# end
# Setup Flask-Security
user_session_store = SQLAlchemySessionUserDatastore(session, User, Role)
security = Security(app, user_session_store)
# Add role
admin_role = Role(**{'name': 'admin', 'description': 'Admin role'})
session.add(admin_role)
session.commit()
# Create user
user_session_store.create_user(email='*****@*****.**',
password='******',
active=True,
roles=[Role.query.first()])
session.commit()
@app.route('/hello')
@auth_required('token')
def hello():
return jsonify({'hello': 'world'})
@app.route('/')
def home():
return render_template('index.html')
def create_user( # noqa: C901
password: str = None,
user_roles: Union[Dict[str, str], List[Dict[str, str]], str,
List[str]] = None,
check_email_deliverability: bool = True,
account_name: Optional[str] = None,
**kwargs,
) -> User:
"""
Convenience wrapper to create a new User object.
It hashes the password.
In addition to the user, this function can create
- new Role objects (if user roles do not already exist)
- an Account object (if it does not exist yet)
- a new DataSource object that corresponds to the user
Remember to commit the session after calling this function!
"""
# Check necessary input explicitly before anything happens
if password is None or password == "":
raise InvalidFlexMeasuresUser("No password provided.")
if "email" not in kwargs:
raise InvalidFlexMeasuresUser("No email address provided.")
email = kwargs.pop("email").strip()
try:
email_info = validate_email(email, check_deliverability=False)
# The mx check talks to the SMTP server. During testing, we skip it because it
# takes a bit of time and without internet connection it fails.
if check_email_deliverability and not current_app.testing:
try:
validate_email_deliverability(email_info.domain,
email_info["domain_i18n"])
except EmailUndeliverableError as eue:
raise InvalidFlexMeasuresUser(
"The email address %s does not seem to be deliverable: %s"
% (email, str(eue)))
except EmailNotValidError as enve:
raise InvalidFlexMeasuresUser("%s is not a valid email address: %s" %
(email, str(enve)))
if "username" not in kwargs:
username = email.split("@")[0]
else:
username = kwargs.pop("username").strip()
# Check integrity explicitly before anything happens
existing_user_by_email = User.query.filter_by(email=email).one_or_none()
if existing_user_by_email is not None:
raise InvalidFlexMeasuresUser("User with email %s already exists." %
email)
existing_user_by_username = User.query.filter_by(
username=username).one_or_none()
if existing_user_by_username is not None:
raise InvalidFlexMeasuresUser("User with username %s already exists." %
username)
# check if we can link/create an account
if account_name is None:
raise InvalidFlexMeasuresUser(
"Cannot create user without knowing the name of the account which this user is associated with."
)
account = db.session.query(Account).filter_by(
name=account_name).one_or_none()
if account is None:
print(f"Creating account {account_name} ...")
account = Account(name=account_name)
db.session.add(account)
user_datastore = SQLAlchemySessionUserDatastore(db.session, User, Role)
kwargs.update(password=hash_password(password),
email=email,
username=username)
user = user_datastore.create_user(**kwargs)
user.account = account
# add roles to user (creating new roles if necessary)
if user_roles:
if not isinstance(user_roles, list):
user_roles = [user_roles] # type: ignore
for user_role in user_roles:
if isinstance(user_role, dict):
role = user_datastore.find_role(user_role["name"])
else:
role = user_datastore.find_role(user_role)
if role is None:
if isinstance(user_role, dict):
role = user_datastore.create_role(**user_role)
else:
role = user_datastore.create_role(name=user_role)
user_datastore.add_role_to_user(user, role)
# create data source
db.session.add(DataSource(user=user))
return user
def setup_api_test_data(db):
"""
Set up data for API v1.1 tests.
"""
print("Setting up data for API v1.1 tests on %s" % db.engine)
from flexmeasures.data.models.user import User, Role
from flexmeasures.data.models.assets import Asset, AssetType
from flexmeasures.data.models.weather import WeatherSensor, WeatherSensorType
user_datastore = SQLAlchemySessionUserDatastore(db.session, User, Role)
# Create a user without proper registration as a data source
user = user_datastore.create_user(
username="******",
email="*****@*****.**",
password=hash_password("testtest"),
)
role = user_datastore.find_role("Prosumer")
user_datastore.add_role_to_user(user, role)
# Create a test user without a USEF role
create_user(
username="******",
email="*****@*****.**",
password=hash_password("testtest"),
)
# Create 3 test assets for the test_prosumer user
test_prosumer = user_datastore.find_user(email="*****@*****.**")
test_asset_type = AssetType(name="test-type")
db.session.add(test_asset_type)
asset_names = ["CS 1", "CS 2", "CS 3"]
assets: List[Asset] = []
for asset_name in asset_names:
asset = Asset(
name=asset_name,
asset_type_name="test-type",
event_resolution=timedelta(minutes=15),
capacity_in_mw=1,
latitude=100,
longitude=100,
unit="MW",
)
asset.owner = test_prosumer
assets.append(asset)
db.session.add(asset)
# Add power forecasts to the assets
cs_1 = Asset.query.filter(Asset.name == "CS 1").one_or_none()
cs_2 = Asset.query.filter(Asset.name == "CS 2").one_or_none()
cs_3 = Asset.query.filter(Asset.name == "CS 3").one_or_none()
data_source = DataSource.query.filter(
DataSource.user == test_prosumer).one_or_none()
power_forecasts = []
for i in range(6):
p_1 = Power(
datetime=isodate.parse_datetime("2015-01-01T00:00:00Z") +
timedelta(minutes=15 * i),
horizon=timedelta(hours=6),
value=(300 + i) * -1,
asset_id=cs_1.id,
data_source_id=data_source.id,
)
p_2 = Power(
datetime=isodate.parse_datetime("2015-01-01T00:00:00Z") +
timedelta(minutes=15 * i),
horizon=timedelta(hours=6),
value=(300 - i) * -1,
asset_id=cs_2.id,
data_source_id=data_source.id,
)
p_3 = Power(
datetime=isodate.parse_datetime("2015-01-01T00:00:00Z") +
timedelta(minutes=15 * i),
horizon=timedelta(hours=6),
value=(0 + i) * -1,
asset_id=cs_3.id,
data_source_id=data_source.id,
)
power_forecasts.append(p_1)
power_forecasts.append(p_2)
power_forecasts.append(p_3)
db.session.bulk_save_objects(power_forecasts)
# Create 2 weather sensors
test_sensor_type = WeatherSensorType(name="wind_speed")
db.session.add(test_sensor_type)
sensor = WeatherSensor(
name="wind_speed_sensor",
weather_sensor_type_name="wind_speed",
event_resolution=timedelta(minutes=5),
latitude=33.4843866,
longitude=126,
unit="m/s",
)
db.session.add(sensor)
test_sensor_type = WeatherSensorType(name="temperature")
db.session.add(test_sensor_type)
sensor = WeatherSensor(
name="temperature_sensor",
weather_sensor_type_name="temperature",
event_resolution=timedelta(minutes=5),
latitude=33.4843866,
longitude=126,
unit="°C",
)
db.session.add(sensor)
print("Done setting up data for API v1.1 tests")
def create_user( # noqa: C901
user_roles: Union[Dict[str, str], List[Dict[str, str]], str,
List[str]] = None,
check_deliverability: bool = True,
**kwargs) -> User:
"""
Convenience wrapper to create a new User object and new Role objects (if user roles do not already exist),
and new DataSource object that corresponds to the user.
Remember to commit the session after calling this function!
"""
# Check necessary input explicitly before anything happens
if "email" not in kwargs:
raise InvalidFlexMeasuresUser("No email address provided.")
email = kwargs.pop("email").strip()
try:
email_info = validate_email(email, check_deliverability=False)
# The mx check talks to the SMTP server. During testing, we skip it because it
# takes a bit of time and without internet connection it fails.
if check_deliverability and not current_app.testing:
try:
validate_email_deliverability(email_info.domain,
email_info["domain_i18n"])
except EmailUndeliverableError as eue:
raise InvalidFlexMeasuresUser(
"The email address %s does not seem to be deliverable: %s"
% (email, str(eue)))
except EmailNotValidError as enve:
raise InvalidFlexMeasuresUser("%s is not a valid email address: %s" %
(email, str(enve)))
if "username" not in kwargs:
username = email.split("@")[0]
else:
username = kwargs.pop("username").strip()
# Check integrity explicitly before anything happens
existing_user_by_email = User.query.filter_by(email=email).one_or_none()
if existing_user_by_email is not None:
raise InvalidFlexMeasuresUser("User with email %s already exists." %
email)
existing_user_by_username = User.query.filter_by(
username=username).one_or_none()
if existing_user_by_username is not None:
raise InvalidFlexMeasuresUser("User with username %s already exists." %
username)
user_datastore = SQLAlchemySessionUserDatastore(db.session, User, Role)
kwargs.update(email=email, username=username)
user = user_datastore.create_user(**kwargs)
if user.password is None:
set_random_password(user)
# add roles to user (creating new roles if necessary)
if user_roles:
if not isinstance(user_roles, list):
user_roles = [user_roles] # type: ignore
for user_role in user_roles:
if isinstance(user_role, dict):
role = user_datastore.find_role(user_role["name"])
else:
role = user_datastore.find_role(user_role)
if role is None:
if isinstance(user_role, dict):
role = user_datastore.create_role(**user_role)
else:
role = user_datastore.create_role(name=user_role)
user_datastore.add_role_to_user(user, role)
# create data source
db.session.add(DataSource(user=user))
return user
def setup_api_test_data(db, setup_accounts, setup_roles_users, add_market_prices):
"""
Set up data for API v1.1 tests.
"""
print("Setting up data for API v1.1 tests on %s" % db.engine)
from flexmeasures.data.models.user import User, Role
from flexmeasures.data.models.assets import Asset, AssetType
user_datastore = SQLAlchemySessionUserDatastore(db.session, User, Role)
# Create a user without proper registration as a data source
user_datastore.create_user(
username="******",
email="*****@*****.**",
password=hash_password("testtest"),
account_id=setup_accounts["Prosumer"].id,
)
# Create 3 test assets for the test_user
test_user = setup_roles_users["Test Prosumer User"]
test_asset_type = AssetType(name="test-type")
db.session.add(test_asset_type)
asset_names = ["CS 1", "CS 2", "CS 3"]
assets: List[Asset] = []
for asset_name in asset_names:
asset = Asset(
name=asset_name,
owner_id=test_user.id,
asset_type_name="test-type",
event_resolution=timedelta(minutes=15),
capacity_in_mw=1,
latitude=100,
longitude=100,
unit="MW",
)
assets.append(asset)
db.session.add(asset)
# Add power forecasts to the assets
cs_1 = Asset.query.filter(Asset.name == "CS 1").one_or_none()
cs_2 = Asset.query.filter(Asset.name == "CS 2").one_or_none()
cs_3 = Asset.query.filter(Asset.name == "CS 3").one_or_none()
data_source = DataSource.query.filter(DataSource.user == test_user).one_or_none()
cs1_beliefs = [
TimedBelief(
event_start=isodate.parse_datetime("2015-01-01T00:00:00Z")
+ timedelta(minutes=15 * i),
belief_horizon=timedelta(hours=6),
event_value=(300 + i) * -1,
sensor=cs_1.corresponding_sensor,
source=data_source,
)
for i in range(6)
]
cs2_beliefs = [
TimedBelief(
event_start=isodate.parse_datetime("2015-01-01T00:00:00Z")
+ timedelta(minutes=15 * i),
belief_horizon=timedelta(hours=6),
event_value=(300 - i) * -1,
sensor=cs_2.corresponding_sensor,
source=data_source,
)
for i in range(6)
]
cs3_beliefs = [
TimedBelief(
event_start=isodate.parse_datetime("2015-01-01T00:00:00Z")
+ timedelta(minutes=15 * i),
belief_horizon=timedelta(hours=6),
event_value=(0 + i) * -1,
sensor=cs_3.corresponding_sensor,
source=data_source,
)
for i in range(6)
]
db.session.add_all(cs1_beliefs + cs2_beliefs + cs3_beliefs)
add_legacy_weather_sensors(db)
print("Done setting up data for API v1.1 tests")
