def form_valid(self, form): try: user = self.get_user(form.cleaned_data) payload = self.handle_valid(form, user) except GpgError as e: form.add_error(e.field, e.message) return self.form_invalid(form) except User.DoesNotExist: form.add_error(None, self.user_not_found_error) return self.form_invalid(form) except UserNotFound as e: if e.args and e.args[0]: form.add_error(None, e.args[0].encode('utf-8')) else: form.add_error(None, self.user_not_found_error) return self.form_invalid(form) # log user address: address = Address.objects.get_or_create( address=self.request.META['REMOTE_ADDR'])[0] UserAddresses.objects.create(address=address, user=user, purpose=self.purpose) # Send confirmation email to the user key, kwargs = confirm(self.request, user, purpose=self.purpose, payload=payload) if settings.BROKER_URL is None: key.send(**kwargs) else: send_email.delay(key_id=key.pk, **kwargs) return super(ConfirmationView, self).form_valid(form)
def claim_notification(sender, **kwargs): claim = kwargs['claim'] request = kwargs['request'] creation = kwargs['creation'] score = claim.score theme = _('New claim') if creation else _('Delete claim') subject = '%(prefix)s%(monitoring)s - %(org)s: %(code)s - %(theme)s' % { 'prefix': config_value('EmailServer', 'EMAIL_SUBJECT_PREFIX'), 'monitoring': score.task.organization.monitoring, 'org': score.task.organization.name.split(':')[0], 'code': score.parameter.code, 'theme': theme, } url = '%s://%s%s' % (request.is_secure() and 'https' or 'http', request.get_host(), reverse('exmo2010:score_view', args=[score.pk])) c = {'score': score, 'claim': claim, 'url': url, 'creation': creation, 'current_user': request.user.userprofile.legal_name, } recipients = list(get_experts().values_list('email', flat=True)) if score.task.user.email and score.task.user.email not in recipients: recipients.append(score.task.user.email) for r in recipients: send_email.delay(r, subject, 'score_claim', context=c)
def form_valid(self, form): try: user = self.get_user(form.cleaned_data) payload = self.handle_valid(form, user) except GpgError as e: form.add_error(e.field, e.message) return self.form_invalid(form) except User.DoesNotExist: form.add_error(None, self.user_not_found_error) return self.form_invalid(form) except UserNotFound as e: if e.args and e.args[0]: form.add_error(None, e.args[0].encode('utf-8')) else: form.add_error(None, self.user_not_found_error) return self.form_invalid(form) # log user address: address = Address.objects.get_or_create(address=self.request.META['REMOTE_ADDR'])[0] UserAddresses.objects.create(address=address, user=user, purpose=self.purpose) # Send confirmation email to the user key, kwargs = confirm(self.request, user, purpose=self.purpose, payload=payload) if settings.BROKER_URL is None: key.send(**kwargs) else: send_email.delay(key_id=key.pk, **kwargs) return super(ConfirmationView, self).form_valid(form)
def handle(self, *args, **options): DAY = 1 day_order = datetime.now() + timedelta(days=DAY) is_day_order_exist_in_disabled_date = (DisableDateOrder.objects.filter( disabled_date=day_order).exists()) if is_day_order_exist_in_disabled_date: # Если завтрашнее число, в списке выключенных дат, то # Заказ, за это число не отрпавляется, даже если он существует return orders = Order.objects.filter(order_date=day_order).values( 'office__place__username', 'office__name', 'office__place__email', ).annotate(first_course=Sum('first_course'), second_course=Sum('second_course'), salad=Sum('salad')) # todo: Order by для верности for order in orders: order = dict(order) order['date'] = day_order.strftime(u'%Y-%m-%d') send_email.delay(order['office__place__email'], self.text.format(**order), u'Примите заказ') # Дважды отправить заказ не получится DisableDateOrder(disabled_date=day_order).save()
def _send_email(research, remind_scientist): notification = { 'subject': remind_scientist.message, 'recipient_list': [sr.scientist.email for sr in list(research.scientistresearch_set.all())], 'html_content': remind_scientist.message } send_email.delay(notification)
def send_digest(timestamp=datetime.now()): """ Send digest. """ users = User.objects.filter(userprofile__notification_type=UserProfile.NOTIFICATION_DIGEST, is_active=True, email__isnull=False)\ .exclude(email__exact='') current_site = Site.objects.get_current() expert = config_value('GlobalParameters', 'EXPERT') subject = _("%(prefix)s Email digest") % { 'prefix': config_value('EmailServer', 'EMAIL_SUBJECT_PREFIX'), } for user in users: profile = user.userprofile last_date = profile.digest_date_journal if not last_date: last_date = datetime.now() - timedelta(days=profile.notification_interval) interval = profile.notification_interval if timestamp - last_date < timedelta(hours=interval): continue if profile.is_expertA or profile.is_manager_expertB: score_pk = Score.objects.all() elif profile.is_expertB: score_pk = Score.objects.filter(task__user=user) elif profile.is_organization: score_pk = Score.objects.filter(task__organization__in=profile.organization.all()) else: score_pk = Score.objects.none() comments = Comment.objects.filter( content_type__model='score', object_pk__in=score_pk.values_list('id', flat=True), ).order_by('submit_date') if last_date: comments = comments.filter(submit_date__gte=last_date) if not user.userprofile.notification_self: comments = comments.exclude(user=user) if not comments: continue context = { 'comments': comments, 'expert': expert, 'from': last_date, 'site': current_site, 'till': timestamp, 'user': user, } send_email.delay(user.email, subject, 'digest', context=context) profile.digest_date_journal = datetime.now() profile.save()
def form_valid(self, form): send = "submit_and_send" in self.request.POST result = super(ParameterManagerView, self).form_valid(form) if send: c = {} param_pk = self.kwargs["pk"] parameter = form.cleaned_data['name'] subject = _('%(prefix)sParameter has been changed: %(parameter)s') % { 'prefix': config_value('EmailServer', 'EMAIL_SUBJECT_PREFIX'), 'parameter': parameter, } parameter = Parameter.objects.get(pk=param_pk) orgs = Organization.objects.filter(monitoring=parameter.monitoring).exclude(pk__in=parameter.exclude.all()) rcpts = User.objects.filter( Q(groups__name=UserProfile.expertA_group) | Q(task__organization__in=orgs), is_active=True, ).exclude(email__exact='').values_list('email', flat=True) rcpts = list(set(rcpts)) c['monitoring'] = form.cleaned_data['monitoring'] old_features = [] new_features = [] features = ['code', 'name', 'description', 'weight'] for field in features: old_features.append((field, form.initial.get(field, form.fields[field].initial))) new_features.append((field, form.cleaned_data.get(field, None))) c['old_features'] = old_features c['new_features'] = new_features old_criteria = [] new_criteria = [] criteria = ['accessible', 'hypertext', 'npa', 'topical', 'document', 'image', 'complete'] for field in criteria: item_was = form.initial.get(field, form.fields[field].initial) item_now = form.cleaned_data.get(field, None) if item_was: old_criteria.append(field) if item_now: new_criteria.append(field) c['old_criteria'] = old_criteria c['new_criteria'] = new_criteria old_excluded_org_pk = form.initial.get('exclude', form.fields['exclude'].initial) c['old_excluded_org'] = Organization.objects.filter(pk__in=old_excluded_org_pk) c['new_excluded_org'] = form.cleaned_data.get('exclude', None) for rcpt in rcpts: send_email.delay(rcpt, subject, 'parameter_email', context=c) return result
def send_forgot_password_email(to_email): forgot_link = generate_forgot_link(to_email) subject = '[Sixcent English App] Forgot password' context = {'forgot_link': forgot_link} body_html = render_to_string('emails/forgot_password.html', context) send_email.delay( subject=subject, body_html=body_html, from_email=settings.EMAIL_NO_REPLY, recipient_list=[to_email] )
def send_register_confirm_email(to_email): confirm_link = generate_confirm_link(to_email) subject = '[Sixcent English App] Register Confirmation' context = {'confirm_link': confirm_link} body_html = render_to_string('emails/register_confirm.html', context) send_email.delay( subject=subject, body_html=body_html, from_email=settings.EMAIL_NO_REPLY, recipient_list=[to_email] )
def _send_email(research, remind_participant, event): recipient_list = [] for pr in list(research.participantresearch_set.filter(confirmed=True)): participant_event = ParticipantResearchEvent.objects.filter(research_event=event, participant=pr.participant) if participant_event: recipient_list.append(participant_event[0].participant.email) notification = { 'subject': remind_participant.message, 'recipient_list': recipient_list, 'html_content': remind_participant.message } send_email.delay(notification)
def post_message_handle(sender, instance, created, **kwargs): """ Define a signal, when the message is successfully saved after the judge whether to send email @param sender: Message object @param instance: Message instance @param created: True is save otherwise is update @param kwargs: @return: """ if created and instance.send_email: notification = { 'subject': instance.subject, 'recipient_list': [instance.recipient.email], 'html_content': instance.content } send_email.delay(notification)
def check_feedback_promise(): for research in Research.objects.filter(is_publish=True, is_feedback_promise=True, feedback_status__lt=FEEDBACK_STATUS_PUNISHMENT): if now() >= research.feedback_promise_time: if not research.is_feedback: research.feedback_status = FEEDBACK_STATUS_PUNISHMENT research.save() #TODO:Over time there is no feedback elif now() + datetime.timedelta(seconds=86400) >= research.feedback_promise_time: if research.feedback_status == FEEDBACK_STATUS_PENDING and not research.is_feedback: notification = { 'subject': 'Study of feedback reminder', 'recipient_list': [sr.scientist.email for sr in list(research.scientistresearch_set.all())], 'html_content': 'You have a study[%s] about to reach the promised time feedback, please timely feedback' % research.name } send_email.delay(notification) research.feedback_status = FEEDBACK_STATUS_SEND_REMIND research.save()
def _send_email_about_cookies(request, subj): from core.tasks import send_email req = [] req.append('Method: %s;' % request.method) req.append('GET: %s;' % request.GET) req.append('POST: %s;' % request.POST) req.append('COOKIES: %s;' % request.COOKIES) req.append('META:') meta = '%s' % request.META req.extend(meta[1:-1].split(', ')) try: send_email.delay(settings.COOKIES_ERROR_REPORT, subj, 'cookies_fail', context={'subject': subj, 'request': req}) except: pass
def _send_mails(rcpts, subject, context, comments, is_experts=False): """ Sending comments notification mails. """ expert = _(config_value('GlobalParameters', 'EXPERT')) for comment in comments: if not comment.user_is_expert(): legal_user_name = comment.user_legal_name() else: legal_user_name = comment.user_legal_name() if is_experts else expert setattr(comment, 'legal_user_name', legal_user_name) context['comments'] = comments for rcpt in rcpts: email = ''.join(rcpt['email'].split()) send_email.delay(email, subject, 'score_comment', context=context)
def done(self, form_list, **kwargs): request = self.request task_id = self.get_cleaned_data_for_step(self.steps.first)['task_id'] task = Task.objects.get(pk=task_id) organization = task.organization organization_name = organization.name monitoring_name = organization.monitoring.name subject = ' '.join([_('Ordering openness certificate for'), organization_name]) rcpt = config_value('EmailServer', 'EMAIL_FOR_CERTIFICATE_NOTIFICATION_ORDER') current_site = Site.objects.get_current() protocol = request.is_secure() and 'https' or 'http' monitoring_url = '%s://%s%s' % ( protocol, current_site.domain, reverse('exmo2010:tasks_by_monitoring', args=[organization.monitoring.pk]) ) organization_url = '%s://%s%s' % ( protocol, current_site.domain, reverse('exmo2010:tasks_by_monitoring_and_organization', args=[organization.monitoring.pk, organization.pk]) ) context = { 'email': request.user.email, 'monitoring_name': monitoring_name, 'monitoring_url': monitoring_url, 'organization_name': organization_name, 'organization_url': organization_url, 'subject': subject, 'user_name': request.user.profile.legal_name, } context.update(self.storage.extra_data['email_context']) send_email.delay(rcpt, subject, 'certificate_order_email', context=context) messages.success(request, _("You ordered an openness certificate. Certificate " "will be prepared and sent within 5 working days.")) return HttpResponseRedirect(reverse('exmo2010:index'))
def form_valid(self, form): slot = form.cleaned_data.get('audition_slot') secret = self.kwargs.get('secret') auditioner = Auditioner.objects.get(secret=secret) slot.auditioner = auditioner slot.save() send_email.delay( template_name='audition_confirm', subject='Talent Show Audition Confirmation', from_email=settings.HARVARD_TALENT_EMAIL, recipients=[slot.auditioner.email], context={'slot': slot} ) reminder_form = AuditionReminderForm(instance=auditioner) if not auditioner.phone: reminder_form.fields.pop('reminder_text') return render(self.request, 'talentshow/sign-up-success.html', {'slot': slot, 'auditioner': auditioner, 'reminder_form': reminder_form})
def send_email_template(subject, template, recipients, sender, context=None, cc=None, html=True, silent=False): """ Return task to send an email using the template provided """ body = render_to_string(template, context=context) args = (subject, body, sender, recipients) kwargs = { "cc": cc, "fail_silently": silent, "html": html } return send_email.delay(*args, **kwargs)
def send_email_template(subject, template, recipients, sender, context=None, cc=None, html=True, silent=False): """ Return task to send an email using the template provided """ body = render_to_string(template, context=context) args = (subject, body, sender, recipients) kwargs = {"cc": cc, "fail_silently": silent, "html": html} return send_email.delay(*args, **kwargs)
def submit_order(request): post = request.POST if request.user.username != post.get('user', -1): return send_login(request) orders = {} for key in post.keys(): value = post.get(key) option = re.compile( '((?P<option_menu>[a-z]{5,6})_)?(?P<date>\d{4}-\d{2}-\d{2})') result = option.match(key) # собираем данные перед сабминитом if result: option_menu = result.group('option_menu') or 'place' # todo : ОПРЕДЕЛИТСЯ СО СТРАНДАРТОМ # где то предаю , где то не передаю option_menu = option_menu.replace('group', 'place') date = result.group('date') if option_menu == 'count': if orders.get(date, None): orders[date].update({ 'first': value or 0, 'second': value or 0, 'salad': value or 0, }) else: if option_menu is 'place': orders[date] = {option_menu: value or 0} continue orders[date] = { 'first': value or 0, 'second': value or 0, 'salad': value or 0, } continue if orders.get(date, None): orders[date].update({option_menu: value or 0}) else: orders[date] = {option_menu: value or 0} list_to_save_orders = [] disabled_dates = map( lambda x: x.isoformat(), list( DisableDateOrder.objects.filter( disabled_date__in=orders.keys()).values_list('disabled_date', flat=True))) message = '' for order in orders: if order in disabled_dates: # FIXME: выполняется в цикле message = { 'success': u'lunches successfully ordered, \n\n\n\nbut' u' some of dates are ignored {} ' u' any order changes '.format(disabled_dates) } continue if orders.get(order, {}).get('place', None): # если задано место, даже без обеда # то сохраняем заказ # Нужно для отмены заказа Order.objects.filter( customer=request.user, order_date=order, ).delete() options_to_save = { 'customer': request.user, 'user_modifier': request.user, 'order_date': order, 'office': Office.objects_active_offices.get( name=orders.get(order, {}).get('place')), 'first_course': orders.get(order, {}).get('first'), 'second_course': orders.get(order, {}).get('second'), 'salad': orders.get(order, {}).get('salad'), } list_to_save_orders.append(Order(**options_to_save)) message = message or {'success': u'lunches successfully ordered'} try: # fixme: list_to_save = [] ? Order.objects.bulk_create(list_to_save_orders) except Exception as err: message = {'error': 'unsuccessfully', 'details': err} # TODO : logger else: user = BaseRBPIUser.objects_active_users.get(username=request.user) send_email.delay(user.email, 'Your order received successfully', 'Order changes') return HttpResponse(json.dumps(message), content_type="application/json")
def organization_list(request, monitoring_id): name_filter = invite_filter = None alert = request.GET.get('alert', False) if request.method == "GET": name_filter = request.GET.get('name_filter', False) invite_filter = request.GET.get('invite_filter', False) monitoring = get_object_or_404(Monitoring, pk=monitoring_id) if not request.user.has_perm('exmo2010.view_monitoring', monitoring): return HttpResponseForbidden(_('Forbidden')) title = _('Organizations for monitoring %s') % monitoring orgs = Organization.objects.filter(monitoring=monitoring) sent = orgs.exclude(inv_status='NTS') initial = {'monitoring': monitoring} org_type = 'all' if request.method == "POST" and "submit_invite" in request.POST: inv_form = InviteOrgsForm(request.POST) comment = inv_form.data['comment'] inv_status = inv_form.data['inv_status'] if inv_form.is_valid(): inv_form.save() if inv_status != 'ALL': orgs = orgs.filter(inv_status=inv_status) for org in orgs: subject = _('Email Subject') message = comment.replace('%code%', org.inv_code) context = { 'subject': subject, 'message': message } if org.email: emails = filter(None, org.email.split(', ')) else: continue task_id = send_email.delay(emails, subject, 'organizations/invitation_email', context=context, mdn=True) task = EmailTasks() task.task_id = task_id task.organization = org task.save() redirect = reverse('exmo2010:organization_list', args=[monitoring_id])+"?alert=success" return HttpResponseRedirect(redirect) else: initial.update({'comment': comment, 'inv_status': inv_status}) alert = 'fail' inv_form = InviteOrgsForm(initial=initial) if request.user.has_perm('exmo2010.admin_monitoring', monitoring): queryset = Organization.objects.filter(monitoring=monitoring).extra( select={ 'task__count': 'SELECT count(*) FROM %s WHERE organization_id = %s.id' % ( Task._meta.db_table, Organization._meta.db_table, ), } ) headers = ( (_('organization'), 'name', None, None, None), (_('email'), 'email', None, None, None), (_('phone'), 'phone', None, None, None), (_('invitation code'), 'inv_code', None, None, None), (_('tasks'), 'task__count', None, None, None), (_('invitation'), 'inv_status', None, None, None), ) else: org_list = [] for task in Task.objects.filter(organization__monitoring=monitoring).select_related(): if request.user.has_perm('exmo2010.view_task', task): org_list.append(task.organization.pk) org_list = list(set(org_list)) if not org_list: return HttpResponseForbidden(_('Forbidden')) queryset = Organization.objects.filter(pk__in=org_list) headers = ( (_('organization'), 'name', None, None, None), (_('email'), 'email', None, None, None), (_('phone'), 'phone', None, None, None), (_('invitation code'), 'inv_code', None, None, None), (_('invitation'), 'inv_status', None, None, None), ) if not sent: headers_list = list(headers) headers_list.pop() headers = tuple(headers_list) if name_filter: queryset = queryset.filter(name__icontains=name_filter) if invite_filter and invite_filter != 'ALL': queryset = queryset.filter(inv_status=invite_filter) crumbs = ['Home', 'Monitoring'] breadcrumbs(request, crumbs) if request.expert: current_title = _('Monitoring cycle') else: current_title = _('Rating') if monitoring.status == 5 else _('Tasks') initial = {'monitoring': monitoring} form = OrganizationForm(initial=initial) if request.method == "POST" and "submit_add" in request.POST: form = OrganizationForm(request.POST) if form.is_valid(): form.save() else: org_type = 'add' inv_history = InviteOrgs.objects.filter(monitoring=monitoring) date_filter_history = None invite_filter_history = None if request.method == "GET": date_filter_history = request.GET.get('date_filter_history', False) invite_filter_history = request.GET.get('invite_filter_history', False) if date_filter_history: start_datetime = datetime.strptime("%s 00:00:00" % date_filter_history, '%d.%m.%Y %H:%M:%S') finish_datetime = datetime.strptime("%s 23:59:59" % date_filter_history, '%d.%m.%Y %H:%M:%S') inv_history = inv_history.filter(timestamp__gt=start_datetime, timestamp__lt=finish_datetime) if invite_filter_history and invite_filter_history != 'ALL': inv_history = inv_history.filter(inv_status=invite_filter_history) return table( request, headers, queryset=queryset, paginate_by=100, extra_context={ 'current_title': current_title, 'title': title, 'sent': sent, 'inv_form': inv_form, 'alert': alert, 'org_type': org_type, 'inv_status': INV_STATUS, 'monitoring': monitoring, 'invcodeform': SettingsInvCodeForm(), 'form': form, 'inv_history': inv_history, 'date_filter_history': date_filter_history, 'invite_filter_history': invite_filter_history, }, )
def _confirm(self, request, user, purpose, payload=None): key, kwargs = confirm(request, user, purpose=purpose, payload=payload) if settings.BROKER_URL is None: key.send(**kwargs) else: send_email.delay(key_id=key.pk, **kwargs)