def send_change_email_notification(request_serialized):
request = core_utils.deserialize_instance(request_serialized)
link = settings.WALDUR_CORE['EMAIL_CHANGE_URL'].format(
code=request.uuid.hex)
context = {'request': request, 'link': link}
core_utils.broadcast_mail('structure', 'change_email_request', context,
[request.email])
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 get_or_create_user(invitation_uuid, sender):
invitation = models.Invitation.objects.get(uuid=invitation_uuid)
user, created = utils.get_or_create_user(invitation)
username = generate_safe_username(user.username)
password = pwgen()
try:
profile, created = utils.get_or_create_profile(user, username,
password)
except (freeipa_exceptions.FreeIPAError, requests.RequestException) as e:
logger.exception(
'Unable to create FreeIPA profile for user with ID: %s', user.id)
invitation.error_message = str(e)
invitation.save(update_fields=['error_message'])
raise
if created:
sender = invitation.created_by.full_name or invitation.created_by.username
context = utils.get_invitation_context(invitation, sender)
context['username'] = username
context['password'] = password
context['link'] = invitation.link_template.format(uuid=invitation_uuid)
broadcast_mail('users', 'invitation_approved', context,
[invitation.email])
else:
send_invitation_created(invitation_uuid, sender)
def send_invitation_rejected(invitation_uuid, sender):
"""
Invitation notification is sent to the user which has created invitation.
"""
invitation = models.Invitation.objects.get(uuid=invitation_uuid)
context = utils.get_invitation_context(invitation, sender)
broadcast_mail('users', 'invitation_rejected', context,
[invitation.created_by.email])
def send_mail_for_submitted_flow(flow_id):
flow = models.FlowTracker.objects.get(id=flow_id)
recipient_list = [
user.email
for user in flow.resource_create_request.offering.customer.get_owners()
]
broadcast_mail(
'marketplace_flows', 'flow_submitted', {'flow': flow}, recipient_list
)
def send_notifications_about_usages():
for warning in utils.get_info_about_missing_usage_reports():
customer = warning['customer']
emails = [owner.email for owner in customer.get_owners()]
warning['public_resources_url'] = utils.get_public_resources_url(
customer)
if customer.serviceprovider.enable_notifications and emails:
core_utils.broadcast_mail('marketplace', 'notification_usages',
warning, emails)
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_template = settings.WALDUR_AUTH_SOCIAL['USER_ACTIVATION_URL_TEMPLATE']
url = url_template.format(token=token, user_uuid=user_uuid)
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 send_invoice_notification(invoice_uuid):
""" Sends email notification with invoice link to customer owners """
invoice = models.Invoice.objects.get(uuid=invoice_uuid)
link_template = settings.WALDUR_INVOICES['INVOICE_LINK_TEMPLATE']
if not link_template:
logger.error(
'INVOICE_LINK_TEMPLATE is not set. '
'Sending of invoice notification is not available.'
)
return
if '{uuid}' not in link_template:
logger.error(
'INVOICE_LINK_TEMPLATE must include \'{uuid}\' parameter. '
'Sending of invoice notification is not available.'
)
return
context = {
'month': invoice.month,
'year': invoice.year,
'customer': invoice.customer.name,
'link': link_template.format(uuid=invoice_uuid),
}
emails = [owner.email for owner in invoice.customer.get_owners()]
filename = None
attachment = None
content_type = None
if invoice._file:
filename = '%s_%s_%s.pdf' % (
settings.WALDUR_CORE['SITE_NAME'].replace(' ', '_'),
invoice.year,
invoice.month,
)
attachment = base64.b64decode(invoice._file)
content_type = 'application/pdf'
logger.debug(
'About to send invoice {invoice} notification to {emails}'.format(
invoice=invoice, emails=emails
)
)
core_utils.broadcast_mail(
'invoices',
'notification',
context,
emails,
filename=filename,
attachment=attachment,
content_type=content_type,
)
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 notify_create_user(id, password, url):
user = models.RancherUser.objects.get(id=id)
email = user.user.email
context = {
'rancher_url': url,
'user': user,
'password': password,
}
core_utils.broadcast_mail('rancher', 'notification_create_user', context,
[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_template = settings.WALDUR_MARKETPLACE['ORDER_LINK_TEMPLATE']
context = {
'order_url': link_template.format(project_uuid=order.project.uuid),
'order': order,
'site_name': settings.WALDUR_CORE['SITE_NAME'],
}
core_utils.broadcast_mail('marketplace', 'notification_approval', context, emails)
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 send_notifications_about_upcoming_ends():
upcoming_ends = utils.get_upcoming_ends_of_fixed_payment_profiles()
for profile in upcoming_ends:
context = {
'organization_name': profile.organization.name,
'end': utils.get_end_date_for_profile(profile),
'contract_number': profile.attributes.get('contract_number', ''),
}
emails = [owner.email for owner in profile.organization.get_owners()]
core_utils.broadcast_mail(
'invoices',
'upcoming_ends_notification',
context,
emails,
)
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 send_invitation_created(invitation_uuid, sender):
"""
Invitation notification is sent to the user so that he can accept it and receive permissions.
"""
invitation = models.Invitation.objects.get(uuid=invitation_uuid)
context = utils.get_invitation_context(invitation, sender)
context['link'] = invitation.link_template.format(uuid=invitation_uuid)
logger.debug(
'About to send invitation to {email} to join {name} {type} as {role}'.
format(email=invitation.email, **context))
try:
broadcast_mail('users', 'invitation_created', context,
[invitation.email])
except SMTPException as e:
invitation.error_message = str(e)
invitation.save(update_fields=['error_message'])
raise
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_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 = settings.WALDUR_CORE['INVITATION_APPROVE_URL'].format(
token=token)
reject_link = settings.WALDUR_CORE['INVITATION_REJECT_URL'].format(
token=token)
context = dict(approve_link=approve_link,
reject_link=reject_link,
**base_context)
broadcast_mail('users', 'invitation_requested', context, [user.email])
def send_request_mail(event_type, request, users, extra_context=None):
"""
Shorthand to send email notification about expert request event.
"""
recipient_list = list(users.exclude(email='').values_list('email', flat=True))
context = dict(
request=request,
customer_name=request.project.customer.name,
project_name=request.project.name,
currency_name=settings.WALDUR_EXPERTS['CURRENCY_NAME'],
site_name=settings.WALDUR_CORE['SITE_NAME'],
)
if extra_context:
context.update(extra_context)
logger.debug('About to send expert request {request_name} to {recipient_list}.'.format(
request_name=request.name,
recipient_list=', '.join(recipient_list)
))
broadcast_mail('experts', event_type, context, recipient_list)
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 send_mail_for_rejected_flow(flow_id):
flow = models.FlowTracker.objects.get(id=flow_id)
broadcast_mail(
'marketplace_flows', 'flow_rejected', {'flow': flow}, [flow.requested_by.email]
)
def notify_about_resource_change(event_type, context, resource_uuid):
resource = models.Resource.objects.get(uuid=resource_uuid)
project = structure_models.Project.all_objects.get(id=resource.project_id)
emails = project.get_users().values_list('email', flat=True)
core_utils.broadcast_mail('marketplace', event_type, context, emails)
def send_notifications_about_upcoming_bookings():
for info in utils.get_info_about_upcoming_bookings():
emails = [info['user'].email]
core_utils.broadcast_mail('booking', 'notification', info, emails)
