def send_change_email_notification(request_serialized):
request = core_utils.deserialize_instance(request_serialized)
link = core_utils.format_homeport_link('user_email_change/{code}/',
code=request.uuid.hex)
context = {'request': request, 'link': link}
core_utils.broadcast_mail('structure', 'change_email_request', context,
[request.email])
def send_invitation_requested(invitation_uuid, sender):
"""
Invitation request is sent to staff users so that they can approve or reject invitation.
"""
invitation = models.Invitation.objects.get(uuid=invitation_uuid)
base_context = utils.get_invitation_context(invitation, sender)
staff_users = core_models.User.objects.filter(
is_staff=True, is_active=True
).exclude(email='')
for user in staff_users:
token = utils.get_invitation_token(invitation, user)
approve_link = format_homeport_link('invitation_approve/{token}/', token=token)
reject_link = format_homeport_link('invitation_reject/{token}/', token=token)
context = dict(
approve_link=approve_link, reject_link=reject_link, **base_context
)
broadcast_mail('users', 'invitation_requested', context, [user.email])
def _send_email(
issue,
html_template,
text_template,
subject_template,
receiver=None,
extra_context=None,
):
if not settings.WALDUR_SUPPORT['ENABLED']:
return
if settings.SUPPRESS_NOTIFICATION_EMAILS:
message = (
'Issue notifications are suppressed. '
'Please set SUPPRESS_NOTIFICATION_EMAILS to False to send notifications.'
)
logger.info(message)
return
if not receiver:
receiver = issue.caller
context = {
'issue_url':
core_utils.format_homeport_link('support/issue/{uuid}/',
uuid=issue.uuid),
'site_name':
settings.WALDUR_CORE['SITE_NAME'],
'issue':
issue,
}
if extra_context:
context.update(extra_context)
html_message = html_template.render(Context(context))
text_message = text_template.render(Context(context, autoescape=False))
subject = subject_template.render(Context(context,
autoescape=False)).strip()
logger.debug('About to send an issue update notification to %s' %
receiver.email)
try:
send_mail(
subject,
text_message,
settings.DEFAULT_FROM_EMAIL,
[receiver.email],
html_message=html_message,
)
except SMTPException as e:
message = (
'Failed to notify a user about an issue update. Issue uuid: %s. Error: %s'
% (issue.uuid.hex, e.message))
logger.warning(message)
def send_activation_email(user_uuid):
user = get_user_model().objects.get(uuid=user_uuid, is_active=False)
token = default_token_generator.make_token(user)
url = format_homeport_link(
'activate/{user_uuid}/{token}/', user_uuid=user_uuid, token=token
)
context = {'activation_url': url}
logger.debug('About to send an activation email to %s' % user.email)
broadcast_mail('waldur_auth_social', 'activation_email', context, [user.email])
def test_usages_notification_message(self):
tasks.send_notifications_about_usages()
self.assertEqual(len(mail.outbox), 1)
self.assertEqual(mail.outbox[0].to, [self.fixture.owner.email])
self.assertEqual(mail.outbox[0].subject,
'Reminder about missing usage reports.')
self.assertTrue('My resource' in mail.outbox[0].body)
public_resources_url = format_homeport_link(
'organizations/{organization_uuid}/marketplace-public-resources/',
organization_uuid=self.fixture.customer.uuid,
)
self.assertTrue(public_resources_url in mail.outbox[0].body)
def test_add_backlink_to_order_item_details_into_created_service_desk_ticket(
self):
order_item = self.submit_order_item()
self.assertTrue(
marketplace_models.Resource.objects.filter(
name='item_name').exists())
issue = get_order_item_issue(order_item)
order_item_url = core_utils.format_homeport_link(
'projects/{project_uuid}/marketplace-order-item-details/{order_item_uuid}/',
order_item_uuid=order_item.uuid.hex,
project_uuid=order_item.order.project.uuid,
)
self.assertTrue(order_item_url in issue.description)
def notify_about_stale_resource():
if not settings.WALDUR_MARKETPLACE['ENABLE_STALE_RESOURCE_NOTIFICATIONS']:
return
today = datetime.datetime.today()
prev_1 = today - relativedelta(months=1)
prev_2 = today - relativedelta(months=2)
items = invoices_models.InvoiceItem.objects.filter(
Q(
invoice__month=today.month,
invoice__year=today.year,
)
| Q(invoice__month=prev_1.month, invoice__year=prev_1.year)
| Q(invoice__month=prev_2.month, invoice__year=prev_2.year))
actual_resources_ids = []
for item in items:
if item.price:
actual_resources_ids.append(item.resource.id)
resources = (models.Resource.objects.exclude(
id__in=actual_resources_ids).exclude(
Q(state=models.Resource.States.TERMINATED)
| Q(state=models.Resource.States.TERMINATING)
| Q(state=models.Resource.States.CREATING)).exclude(
offering__billable=False))
user_resources = collections.defaultdict(list)
for resource in resources:
owners = resource.project.customer.get_owners().exclude(email='')
resource_url = core_utils.format_homeport_link(
'/projects/{project_uuid}/marketplace-project-resource-details/{resource_uuid}/',
project_uuid=resource.project.uuid.hex,
resource_uuid=resource.uuid.hex,
)
for user in owners:
user_resources[user.email].append({
'resource': resource,
'resource_url': resource_url
})
for key, value in user_resources.items():
core_utils.broadcast_mail(
'marketplace',
'notification_about_stale_resources',
{'resources': value},
[key],
)
def test_send_change_email_notification_task(self, mock_mail):
self.client.post(self.url, self.valid_payload)
self.assertTrue(self.user.changeemailrequest)
request_serialized = core_utils.serialize_instance(
self.user.changeemailrequest)
tasks.send_change_email_notification(request_serialized)
link = format_homeport_link('user_email_change/{code}/',
code=self.user.changeemailrequest.uuid.hex)
context = {'request': self.user.changeemailrequest, 'link': link}
mock_mail.assert_called_once_with(
'structure',
'change_email_request',
context,
[self.user.changeemailrequest.email],
)
def notify_order_approvers(uuid):
order = models.Order.objects.get(uuid=uuid)
users = order.get_approvers()
emails = [u.email for u in users if u.email]
link = core_utils.format_homeport_link(
'projects/{project_uuid}/marketplace-order-list/',
project_uuid=order.project.uuid,
)
context = {
'order_url': link,
'order': order,
'site_name': settings.WALDUR_CORE['SITE_NAME'],
}
core_utils.broadcast_mail('marketplace', 'notification_approval', context,
emails)
def notify_about_resource_termination(resource_uuid,
user_uuid,
is_staff_action=None):
resource = models.Resource.objects.get(uuid=resource_uuid)
user = User.objects.get(uuid=user_uuid)
admin_emails = set(
resource.project.get_users(
structure_models.ProjectRole.ADMINISTRATOR).exclude(
email='').values_list('email', flat=True))
manager_emails = set(
resource.project.get_users(
structure_models.ProjectRole.MANAGER).exclude(
email='').values_list('email', flat=True))
emails = admin_emails | manager_emails
resource_url = core_utils.format_homeport_link(
'/projects/{project_uuid}/marketplace-project-resource-details/{resource_uuid}/',
project_uuid=resource.project.uuid.hex,
resource_uuid=resource.uuid.hex,
)
context = {
'resource': resource,
'user': user,
'resource_url': resource_url
}
if is_staff_action:
core_utils.broadcast_mail(
'marketplace',
'marketplace_resource_terminatate_scheduled_staff',
context,
emails,
)
else:
core_utils.broadcast_mail(
'marketplace', 'marketplace_resource_terminatate_scheduled',
context, emails)
def get_invitation_link(uuid):
return core_utils.format_homeport_link('invitation/{uuid}/', uuid=uuid)
def get_public_resources_url(customer):
return core_utils.format_homeport_link(
'organizations/{organization_uuid}/marketplace-public-resources/',
organization_uuid=customer.uuid,
)
def logout_completed():
return HttpResponseRedirect(format_homeport_link('logout_completed/'))
def logout_failed(message):
url_template = format_homeport_link('logout_failed/')
return redirect_with(url_template, message=message)
def login_completed(token, method='default'):
url = format_homeport_link('login_completed/{token}/{method}/',
token=token,
method=method)
return HttpResponseRedirect(url)
def get_datacite_url(self):
return core_utils.format_homeport_link(
'marketplace-public-offering/{offering_uuid}/',
offering_uuid=self.uuid.hex)
def get_request_link(resource: marketplace_models.Resource):
return format_homeport_link(
'projects/{project_uuid}/support/{request_uuid}/',
project_uuid=resource.project.uuid,
request_uuid=resource.uuid,
)
def get_feedback_link(token, evaluation=''):
return format_homeport_link(
'support/feedback/?token={token}&evaluation={evaluation}',
token=token,
evaluation=evaluation,
)
def get_order_item_url(order_item):
return core_utils.format_homeport_link(
'projects/{project_uuid}/marketplace-order-item-details/{order_item_uuid}/',
order_item_uuid=order_item.uuid.hex,
project_uuid=order_item.order.project.uuid,
)
