def refresh_token(subject, session):
"""
:param str subject:
:param sqlalchemy.orm.Session session:
"""
__log_extra = {
'subject': subject,
'pipeline': 'refresh_token',
'task': 'refresh_token',
}
try:
user = UserQuery(session) \
.is_active() \
.has_sub(subject) \
.one()
except orm.exc.NoResultFound:
logger.info('Could not refresh token: User not found',
extra=__log_extra)
return
except Exception as e:
raise
token = backend.refresh_token(user.refresh_token)
user.access_token = token['access_token']
user.refresh_token = token['refresh_token']
user.token_expire = datetime \
.fromtimestamp(token['expires_at']) \
.replace(tzinfo=timezone.utc)
def create_forecast(self, request, user, session):
"""
:param SubmitForecastRequest request:
:param origin.auth.User user:
:param sqlalchemy.orm.Session session:
:rtype: (Forecast, origin.auth.User)
"""
recipient = UserQuery(session) \
.is_active() \
.has_sub(request.account) \
.one()
forecast = Forecast(
public_id=uuid4(),
user_id=user.id,
recipient_id=recipient.id,
begin=request.begin,
end=request.begin + (request.resolution * len(request.forecast)),
resolution=request.resolution.total_seconds(),
sector=request.sector,
reference=request.reference,
forecast=request.forecast,
)
session.add(forecast)
session.flush()
return forecast, recipient
def send_key_to_datahub_service(task, subject, gsrn, session):
"""
:param celery.Task task:
:param str subject:
:param str gsrn:
:param sqlalchemy.orm.Session session:
"""
__log_extra = {
'subject': subject,
'gsrn': gsrn,
'pipeline': 'import_meteringpoints',
'task': 'send_key_to_datahub_service',
}
# Get User from DB
try:
user = UserQuery(session) \
.is_active() \
.has_sub(subject) \
.one()
except orm.exc.NoResultFound:
raise
except Exception as e:
logger.exception('Failed to load User from database, retrying...',
extra=__log_extra)
raise task.retry(exc=e)
# Get MeteringPoint from DB
try:
meteringpoint = MeteringPointQuery(session) \
.has_gsrn(gsrn) \
.one()
except orm.exc.NoResultFound:
raise
except Exception as e:
logger.exception(
'Failed to load MeteringPoint from database, retrying...',
extra=__log_extra)
raise task.retry(exc=e)
# Send key to DataHubService
try:
datahub_service.set_key(
token=user.access_token,
gsrn=meteringpoint.gsrn,
key=meteringpoint.extended_key,
)
except DataHubServiceConnectionError as e:
logger.exception(
f'Failed to establish connection to DataHubService, retrying...',
extra=__log_extra)
raise task.retry(exc=e)
except DataHubServiceError as e:
if e.status_code == 400:
raise
else:
logger.exception('Failed to import MeteringPoints, retrying...',
extra=__log_extra)
raise task.retry(exc=e)
def start_import_meteringpoints(session):
"""
Imports (or updates) MeteringPoints for all users.
:param sqlalchemy.orm.Session session:
"""
for user in UserQuery(session).is_active().all():
start_import_meteringpoints_for(user.sub)
def get_user(self, sub, session):
"""
:param str sub:
:param sqlalchemy.orm.Session session:
:rtype: User
"""
return UserQuery(session) \
.is_active() \
.has_sub(sub) \
.one_or_none()
def get_soon_to_expire_tokens(session):
"""
:param sqlalchemy.orm.Session session:
"""
users = UserQuery(session) \
.is_active() \
.should_refresh_token()
tasks = [refresh_token.si(subject=user.sub) for user in users]
group(*tasks).apply_async()
def trigger_ggo_received_webhooks_for(self, subject, session):
user = UserQuery(session) \
.has_sub(subject) \
.one()
ggos = GgoQuery(session) \
.belongs_to(user) \
.is_tradable()
for ggo in ggos:
start_invoke_on_ggo_received_tasks(
subject=user.sub,
ggo_id=ggo.id,
session=session,
)
def import_meteringpoints_and_insert_to_db(task, subject, session):
"""
:param celery.Task task:
:param str subject:
:param sqlalchemy.orm.Session session:
"""
__log_extra = {
'subject': subject,
'pipeline': 'import_meteringpoints',
'task': 'import_meteringpoints_and_insert_to_db',
}
# Get User from DB
try:
user = UserQuery(session) \
.is_active() \
.has_sub(subject) \
.one()
except orm.exc.NoResultFound:
raise
except Exception as e:
logger.exception('Failed to load User from database, retrying...',
extra=__log_extra)
raise task.retry(exc=e)
# Import MeteringPoints from DataHubService
try:
response = datahub_service.get_meteringpoints(user.access_token)
except DataHubServiceConnectionError as e:
logger.exception(
f'Failed to establish connection to DataHubService, retrying...',
extra=__log_extra)
raise task.retry(exc=e)
except DataHubServiceError as e:
if e.status_code == 400:
raise
else:
logger.exception('Failed to import MeteringPoints, retrying...',
extra=__log_extra)
raise task.retry(exc=e)
# Save imported MeteringPoints to database
try:
meteringpoints = save_imported_meteringpoints(user, response)
except Exception as e:
logger.exception(
'Failed to save imported Meteringpoints to database, retrying...',
extra=__log_extra)
raise task.retry(exc=e)
logger.info(
f'Imported {len(meteringpoints)} new MeteringPoints from DataHubService',
extra=__log_extra)
# Send MeteringPoint key to DataHubService for each imported MeteringPoint
tasks = []
for meteringpoint in meteringpoints:
logger.info(f'Imported meteringpoint with GSRN: {meteringpoint.gsrn}',
extra={
'gsrn': meteringpoint.gsrn,
'subject': user.sub,
'pipeline': 'import_meteringpoints',
'task': 'import_meteringpoints_and_insert_to_db',
})
tasks.append(
send_key_to_datahub_service.s(
subject=subject,
gsrn=meteringpoint.gsrn,
))
group(*tasks).apply_async()
#
# html = HTML('template.html', url_fetcher=url_fetcher)
# html.write_pdf('asd.pdf')
from datetime import datetime, timezone, timedelta
from io import BytesIO
from origin.db import make_session
from origin.common import DateTimeRange
from origin.auth import UserQuery, MeteringPointQuery
from origin.eco import EcoDeclarationBuilder, EcoDeclarationPdf
# f = BytesIO()
session = make_session()
user = UserQuery(session).one()
meteringpoints = MeteringPointQuery(session).is_consumption().all()
begin_range = DateTimeRange(
begin=datetime(2019, 9, 18, 0, 0, tzinfo=timezone(timedelta(hours=2))),
end=datetime(2019, 9, 18, 23, 59, tzinfo=timezone(timedelta(hours=2))),
)
individual, general = EcoDeclarationBuilder().build_eco_declaration(
user=user,
meteringpoints=meteringpoints,
begin_range=begin_range,
session=session,
)
pdf = EcoDeclarationPdf()
pdf.render(individual, general, open('asd2.pdf', 'wb'))