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)
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)
