def run(self, *args, **kwargs):
Payment = apps.get_model(
app_label='payments',
model_name='Payment')
payment = Payment.objects.get(id=kwargs.get('payment_pk'))
try:
attachment = []
office_wrapper = PDFWrapper(payment.attached_file)
office_wrapper.set_filename(payment.attached_filename)
attachment = office_wrapper.serialize()
email_data = {
'concept': payment.concept,
'full_name': payment.full_name,
'from_email': settings.EMAIL_NOTIFICATIONS_FROM,
'recipients': [payment.email],
'bcc': [settings.EMAIL_FINANCE],
'attachments': attachment,
}
mail_handler.send_mail(
template='payment_received',
**email_data
)
except Exception as e:
logger.error(e)
self.retry(countdown=30, max_retries=3)
def run(self, pk, *args, **kwargs):
Event = apps.get_model('event', 'Event')
event = get_object_or_404(Event, pk=pk)
mail_kwargs = {
'workshop_name': event.title,
'created_by': event.created_by_full_name,
}
mail_handler.send_mail(
template='workshop_creation_reminder',
recipients=settings.EVENT_CREATION_WORKSHOP_REMINDER_RECIPIENTS,
**mail_kwargs)
def run(self, user_uuid, *args, **kwargs):
user_wrapper = UserWrapper(uuid=user_uuid)
mail_kwargs = {
'user_full_name': user_wrapper.get_full_name(),
'user_profile_url': user_wrapper.profile_url,
'comments': kwargs.get('comment', ''),
}
mail_handler.send_mail(
template='event_summit_notification',
recipients=[settings.EVENT_SUMMIT_DISTRIBUTION_LIST_EMAIL],
**mail_kwargs,
)
def run(self, *args, **kwargs):
Project = apps.get_model('project', 'Project')
project = Project.objects.get(pk=kwargs.get('project_id'))
user = get_user_model().objects.get(pk=kwargs.get('user_id'))
if settings.POPULATOR_MODE and not settings.TEST_MODE:
return
user_data = RoleChanged(project, user).get_data()
email_name = settings.PROJECT_EMAIL_ROLE_CHANGED
mail_handler.send_mail(
template=email_name,
recipients=[user_data.pop('email')],
**user_data)
def run(self, *args, **kwargs):
Team = apps.get_model('team', 'Team')
team = Team.objects.get(pk=kwargs.get('team_id'))
user = get_user_model().objects.get(pk=kwargs.get('user_id'))
if settings.POPULATOR_MODE and not settings.TEST_MODE:
return
user_data = UserAddedTeamChanged(team, user).get_data()
email_name = settings.PROJECT_EMAIL_MEMBER_ADDED_TEAM
mail_handler.send_mail(
template=email_name,
recipients=[user_data.pop('email')],
**user_data)
def run(self, *args, **kwargs):
Step = apps.get_model('project', 'Step')
step = Step.objects.get(pk=kwargs.get('step_id'))
if settings.POPULATOR_MODE and not settings.TEST_MODE:
return
for user in step.project.members:
user_data = StepDateChanged(step, user).get_data()
email_name = settings.PROJECT_EMAIL_START_CHANGED
mail_handler.send_mail(
template=email_name,
recipients=[user_data.pop('email')],
**user_data)
def run(self, *args, **kwargs):
Project = apps.get_model('project', 'Project')
project = Project.objects.get(pk=kwargs.get('project_id'))
if settings.POPULATOR_MODE and not settings.TEST_MODE:
return
for user in project.members:
user_data = LocationChanged(project, user).get_data()
email_name = settings.PROJECT_EMAIL_LOCATION_CHANGED
mail_handler.send_mail(
template=email_name,
recipients=[user_data.pop('email')],
**user_data)
def _send_members_email(self, user_from, users_created=[], message=None):
if settings.POPULATOR_MODE and not settings.TEST_MODE:
return
for user in self.members:
user_data = MemberLaunch(self, user).get_data()
if message is not None:
user_data['message'] = message
if user in users_created:
user_data['password'] = self.settings.launch[
'default_password']
email_name = settings.PROJECT_EMAIL_MEMBER_LAUNCH
mail_handler.send_mail(template=email_name,
recipients=[user_data.pop('email')],
**user_data)
def run(self, *args, **kwargs):
opportunity_pk = kwargs.get('pk')
user_pk = kwargs.get('user_pk')
comment = kwargs.get('comment')
email_name = settings.OPPORTUNITIES_MAIL_VIEW_CLOSED_MANUALLY
try:
opp = Opportunity.objects.get(pk=opportunity_pk)
except Opportunity.DoesNotExist:
logger.error('Opportunity does not exist')
raise Exception()
try:
user = User.objects.get(id=user_pk)
except User.DoesNotExist:
logger.error('User does not exist')
raise Exception()
user_wrapper = UserWrapper(user=user)
try:
data = ApplicantNotSelected(opp, user).get_data()
except Exception as err:
logger.error(
'Applicant not selected data exception: {}'.format(err))
raise Exception()
data['recipients'] = [user_wrapper.email]
if comment is not None:
data['comment'] = comment
status = mail_handler.send_mail(template=email_name, **data)
if not status:
logger.error('Error sending email to: {}'.format(data))
raise Exception()
def run(self, *args, **kwargs):
opportunity_pk = kwargs.get('pk')
comment = kwargs.get('comment')
email_name = settings.OPPORTUNITIES_MAIL_VIEW_OPPORTUNITY_REMOVED
try:
opp = Opportunity.objects.get(pk=opportunity_pk)
except Opportunity.DoesNotExist:
logger.error('Opportunity does not exist')
raise Exception()
recipients = self.get_recipients(opp)
try:
data = Remove(opp).get_data()
except Exception as err:
logger.error('Remove data exception: {}'.format(err))
raise Exception()
for recipient in recipients:
user_data = data.copy()
user_data['applicant_name'] = recipient.get_full_name()
user_data['recipients'] = [recipient.email]
user_data['comment'] = comment or ''
status = mail_handler.send_mail(
template=email_name,
**user_data)
if not status:
logger.error('Error sending email to: {}'.format(user_data))
try:
self.send_notification(recipient.user, opp)
except Exception as err:
logger.error('Send notification exception: {}'.format(err))
def send_email(self, user, conversations, period):
user_wrapper = UserWrapper(user=user)
data = {}
if period == DAILY:
data['subject_args'] = {'period': 'Daily'}
else:
data['subject_args'] = {'period': 'Weekly'}
data['total'] = sum(map(lambda x: x[1].count(), conversations))
data['name'] = user_wrapper.get_full_name()
data['conversations'] = []
for conversation, messages in conversations:
url, related_title = get_info_related(conversation, user)
data_conversation = {}
data_conversation['total'] = messages.count()
data_conversation['message'] = messages.first().message
data_conversation['url'] = url
title = CONVERSATION_TITLE.get(
conversation._type).format(related_title)
data_conversation['title'] = title
data['conversations'].append(data_conversation)
data['recipients'] = [user_wrapper.email]
status = mail_handler.send_mail(template=EMAIL_NAME, **data)
if not status:
logger.error('Error sending email to: {}'.format(data))
raise Exception('Error sending email to: {}'.format(data))
def run(self, *args, **kwargs):
opportunity_pk = kwargs.get('pk')
user_pk = kwargs.get('user_pk')
email_name = settings.OPPORTUNITIES_MAIL_VIEW_APPLICANT_NOT_SELECTED
try:
opp = Opportunity.objects.get(pk=opportunity_pk)
except Opportunity.DoesNotExist:
logger.error('Opportunity does not exist')
raise Exception()
try:
user = get_user_model().objects.get(pk=user_pk)
except get_user_model().DoesNotExist:
logger.error('Applicant does not exist')
raise Exception()
user_wrapper = UserWrapper(user=user)
try:
data = ApplicantNotSelected(opp, user).get_data()
except Exception as err:
logger.error(
'Applicant not selected data exception: {}'.format(err))
raise Exception()
data['recipients'] = [user_wrapper.email]
status = mail_handler.send_mail(template=email_name, **data)
if not status:
logger.error('Error sending email to: {}'.format(data))
raise Exception()
def run(self, *args, **kwargs):
survey_filled_pk = kwargs.get('pk')
email_name = settings.SURVEY_RESULT_FOR_USER
try:
survey_filled = SurveyFilled.objects.get(pk=survey_filled_pk)
except SurveyFilled.DoesNotExist:
logger.error('SurveyFilled does not exist')
raise Exception()
translation.activate(survey_filled.language)
results_data = ResultSerializer(survey_filled.results.all(), many=True).data
data = {
'name': survey_filled.name,
'organization': survey_filled.organization,
'total': survey_filled.total,
'survey_name': survey_filled.survey.name,
'public_url': '/',
'recipients': [survey_filled.email],
'results': results_data,
'lang': survey_filled.language,
}
logger.info(data)
status = mail_handler.send_mail(
template=email_name,
**data)
if not status:
logger.error('Error sending email to: {}'.format(data))
def run(self, pk, *args, **kwargs):
Event = apps.get_model('event', 'Event')
event = get_object_or_404(Event, pk=pk)
mail_kwargs = {
'event_title': event.title,
'event_type_name': event.type_event_name,
'event_date': datetime.strftime(event.start, '%d/%m/%Y'),
'event_status': event.get__status_display(),
'event_approved': event.is_approved,
'public_url': '{}{}'.format(
settings.EVENT_MANAGE_URL,
event.uuid,
),
'user_full_name': event.main_speaker_data.get('fullName'),
'user_profile_url': event.main_speaker_data.get('profileUrl'),
}
mail_handler.send_mail(
template='event_manager_notification',
recipients=self.get_manager_recipients(),
**mail_kwargs,
)
def run(self, *args, **kwargs):
Payment = apps.get_model(app_label='payments', model_name='Payment')
payment = Payment.objects.get(id=kwargs.get('payment_pk'))
if payment.is_pending:
try:
attachment = []
notification_url = '{}{}'.format(
settings.DOMAIN_NAME,
reverse('api:email-notify',
kwargs={'hash': payment._hash_code}))
if payment.attached_file:
office_wrapper = PDFWrapper(payment.attached_file)
office_wrapper.set_filename(payment.attached_filename)
attachment = office_wrapper.serialize()
email_data = {
'notify_webhook': notification_url,
'object_id': payment.pk,
'content_type_id':
ContentType.objects.get_for_model(payment).pk,
'concept': payment.concept,
'detail': payment.detail,
'full_name': payment.full_name,
'amount': payment.amount_str,
'currency': payment.get_currency_display(),
'public_url': payment.url,
'from_email': settings.EMAIL_NOTIFICATIONS_FROM,
'recipients': [payment.email],
'attachments': attachment,
}
mail_handler.send_mail(template='new_payment_created',
**email_data)
payment.attached_file.delete()
except Exception as e:
logger.error(e)
self.retry(countdown=30, max_retries=3)
def send_mail_to_requester(self, opportunity):
email_name = settings.OPPORTUNITIES_MAIL_VIEW_CLOSED_BY_POSITIONS
try:
data = OpportunityClosed(opportunity).get_data()
except Exception as err:
logger.error(
'Opportunity closed selected data exception: {}'.format(err))
raise Exception()
user_wrapper = UserWrapper(user=opportunity.created_by)
data['recipients'] = [user_wrapper.email]
status = mail_handler.send_mail(template=email_name, **data)
if not status:
logger.error('Error sending email to: {}'.format(data))
raise Exception()
def send_email(self, opportunity, applicant):
email_name = settings.OPPORTUNITIES_MAIL_VIEW_APPLICANT_SELECTED
user_wrapper = UserWrapper(user=applicant.user)
try:
data = ApplicantSelected(applicant).get_data()
except Exception as err:
logger.error('Applicant Selected data exception: {}'.format(err))
raise Exception()
data['recipients'] = [user_wrapper.email]
status = mail_handler.send_mail(template=email_name, **data)
if not status:
logger.error('Error sending email to: {}'.format(data))
raise Exception('Error sending email to: {}'.format(data))
def run(self, pk, *args, **kwargs):
Event = apps.get_model('event', 'Event')
event = get_object_or_404(Event, pk=pk)
mail_kwargs = {
'event_owner_short_name': event.main_speaker_data.get('shortName'),
'event_title': event.title,
'event_type_name': event.type_event_name,
'event_date': datetime.strftime(event.start, '%d/%m/%Y'),
'event_approved': event.is_approved,
'reviewer_user_name': self.get_manager_user().get('fullName'),
'comments': kwargs.get('comment', ''),
'public_url': '{}{}'.format(
settings.EVENT_DETAIL_URL,
event.uuid,
)
}
mail_handler.send_mail(
template='event_owner_notification',
recipients=[event.main_speaker_data.get('email')],
bcc=self.get_manager_recipients(),
**mail_kwargs,
)
def send_to_applicant(self, opportunity, applicant):
user_wrapper = UserWrapper(user=applicant.user)
try:
data = OpportunityFeedback(applicant).get_data()
except Exception as err:
logger.error('Opportunity Feedback data exception: {}'.format(err))
raise Exception()
data['recipients'] = [user_wrapper.email]
data['public_url'] = settings.OPPORTUNITIES_FEEDBACK_URL.format(
opportunity.pk)
status = mail_handler.send_mail(
template=MAIL_VIEW_APPLICANT_REQUESTED_FEEDBACK, **data)
if not status:
logger.error('Error sending email to: {}'.format(data))
raise Exception()
def _notify_by_email(self, recipient, opp):
if recipient.get('has_signed_marketplace_agreement', True):
user_data = Create(opp).get_data()
email_name = settings.OPPORTUNITIES_MAIL_VIEW_NEW_OPPORTUNITY
else:
user_data = CreateWithoutAgreementSigned(opp, recipient).get_data()
email_name = settings.OPPORTUNITIES_MAIL_VIEW_NEW_OPPORTUNITY_WITHOUT_AGREEMENT
status = mail_handler.send_mail(template=email_name,
recipients=[recipient.get('email')],
**user_data)
if not status:
logger.error(
'NewOpportunityTask - Error sending email to: {}'.format(
recipient.get('email')))
def send_mail_new_message(self, user_from, user_to, opportunity, message):
value = enabled_config_param(user_to, CONFIG_PARAM_NAME)
if not value:
return
data = self.get_data(opportunity, user_from)
user_wrapper = UserWrapper(user=user_to)
data['recipients'] = [user_wrapper.email]
user_is_manager = opportunity.group and user_to in opportunity.group.managers.all(
)
if opportunity.created_by == user_to or user_is_manager:
data['public_url'] = opportunity.admin_url_public
else:
data['public_url'] = settings.OPPORTUNITIES_CHAT_URL.format(
opportunity.pk)
data['message'] = message
status = mail_handler.send_mail(template=MAIL_CHAT_FIRST_MESSAGE,
**data)
if not status:
logger.error('Error sending email to {}: {}'.format(user_to, data))
raise Exception()
def send_summary(self, applicants):
recipients = ['*****@*****.**']
email_name = 'basic_email'
date = timezone.now().strftime('%Y-%m-%d_%H:%M:%S')
file = ['report-{}.csv'.format(date), self.get_file(applicants)]
kwargs = {
'mail_title': 'Opportunities report',
'mail_content': 'Date - {}'.format(date),
'attachments': [file],
'attachments_parsed': True,
}
status = mail_handler.send_mail(template=email_name,
recipients=recipients,
**kwargs)
if not status:
logger.error('Error sending email to finance')
raise Exception()
def run(self, *args, **kwargs):
opportunity_pk = kwargs.get('pk')
email_name = MAIL_VIEW_CLOSED_DEADLINE
try:
opp = Opportunity.objects.get(pk=opportunity_pk)
except Opportunity.DoesNotExist:
logger.error('Opportunity does not exist')
raise Exception()
user_wrapper = UserWrapper(user=opp.created_by)
try:
data = OpportunityClosed(opp).get_data()
except Exception as err:
logger.error('Requester deadline data exception: {}'.format(err))
raise Exception()
data['recipients'] = [user_wrapper.email]
data['public_url'] = settings.OPPORTUNITIES_PUBLIC_URL
status = mail_handler.send_mail(template=email_name, **data)
if not status:
logger.error('Error sending email to: {}'.format(data))
raise Exception()
def run(self, *args, **kwargs):
opportunity_pk = kwargs.get('pk')
applicant_pk = kwargs.get('applicant_pk')
email_name = settings.OPPORTUNITIES_MAIL_VIEW_RESPOND_APPLICANT
try:
opp = Opportunity.objects.get(pk=opportunity_pk)
opportunity_creator = UserWrapper(user=opp.created_by)
except Opportunity.DoesNotExist as err:
logger.error('Opportunity does not exist')
raise err
try:
applicant = opp.applicants_info.get(pk=applicant_pk)
except Applicant.DoesNotExist as err:
logger.error('Applicant does not exist')
raise err
try:
data = NewApplicant(applicant).get_data()
except Exception as err:
logger.error('New Applicant data exception: {}'.format(err))
raise err
data['recipients'] = [opportunity_creator.email]
status = mail_handler.send_mail(
template=email_name,
**data)
if not status:
logger.error('Error sending email to: {}'.format(data))
raise Exception('Error sending email to: {}'.format(data))
try:
self.send_notification(opportunity_creator, applicant)
except Exception as err:
logger.error('Send notification exception: {}'.format(err))
def send_reminder_requester(self, opportunity, days):
user_wrapper = UserWrapper(user=opportunity.created_by)
try:
data = OpportunityCloseReminder(opportunity).get_data()
except Exception as err:
logger.error(
'Applicant not selected data exception: {}'.format(err))
raise Exception()
duedate_timedelta = days
data['duedate_timedelta'] = duedate_timedelta
data['subject_args'] = {
'duedate_timedelta': days,
}
data['recipients'] = [user_wrapper.email]
if settings.TEST_MODE:
self.stdout.write('{}'.format(data))
if settings.POPULATOR_MODE:
return
status = mail_handler.send_mail(template=EMAIL_NAME, **data)
if not status:
logger.error('Error sending email to: {}'.format(data))
raise Exception()
def send_summary(self, total, roles, opportunities):
recipients = _get_recipients()
data_not_signed = self.get_data_not_signed(total, roles, opportunities)
data_signed = self.get_data_signed(total, roles, opportunities)
for recipient in recipients:
if recipient.get('has_signed_marketplace_agreement', True):
email_name = EMAIL_NAME_SIGNED
data = data_signed.copy()
else:
email_name = EMAIL_NAME_NOT_SIGNED
data = data_not_signed.copy()
data['name'] = recipient.get('short_name')
data['subject_args'] = {'total': str(total)}
status = mail_handler.send_mail(
template=email_name,
recipients=[recipient.get('email')],
**data)
if not status:
logger.error('Error sending email to: {}'.format(data))
raise Exception()
