def form_valid(self, form):
self.form = form
user = self.user
badge = form.actual_badge()
if badge.can_award(user):
badge.possibly_award(user=self.user)
messages.success(
self.request,
'%s badge awarded to %s' % (badge.name, user_display(user)))
else:
messages.warning(
self.request, '%s badge couldn\'t be awarded to %s' %
(badge.name, user_display(user)))
return super(AwardBadgeView, self).form_valid(form)
def form_valid(self, form):
assignee = form.cleaned_data.get('assigned_to')
tasks = form.cleaned_data['tasks']
count = 0
for task in tasks:
if task.is_open:
if form.unassign or (assignee
and task.can_assign_to(assignee)):
if task.assigned_to != assignee:
task.assign_to(assignee, self.request.user)
task.updated_by_user = self.request.user
task.save()
count += 1
if count > 0:
plural = 's' if count > 1 else ''
if form.unassign:
messages.success(self.request,
"Unassigned {} task{}".format(count, plural))
elif assignee:
messages.success(
self.request,
"Assigned {} task{} to {}".format(count, plural,
user_display(assignee)))
return redirect(self.get_redirect_url())
def create_task(self, user):
""" Create a new task for this annotation.
"""
from .tasks import Task
if self.in_reply_to:
raise Exception("Cannot create tasks for reply annotations.")
if not self.task:
task = Task()
task.country = self.document.work.country
task.locality = self.document.work.locality
task.work = self.document.work
task.document = self.document
task.anchor_id = self.anchor_id
task.created_by_user = user
task.updated_by_user = user
anchor = self.resolve_anchor()
ref = anchor.toc_entry.title if anchor.toc_entry else self.anchor_id
# TODO: strip markdown?
task.title = '"%s": %s' % (ref, self.text)
if len(task.title) > 255:
task.title = task.title[:250] + "..."
task.description = '%s commented on "%s":\n\n%s' % (user_display(
self.created_by_user), ref, self.text)
task.save()
self.task = task
self.save()
self.task.refresh_from_db()
return self.task
def new_spark_job(request):
identifier = u'{}-telemetry-scheduled-task'.format(user_display(request.user))
next_identifier = next_field_value(SparkJob, 'identifier', identifier)
initial = {
'identifier': next_identifier,
'size': 1,
'interval_in_hours': SparkJob.INTERVAL_WEEKLY,
'job_timeout': 24,
'start_date': timezone.now(),
}
form = NewSparkJobForm(request.user, initial=initial)
if request.method == 'POST':
form = NewSparkJobForm(
request.user,
data=request.POST,
files=request.FILES,
initial=initial,
)
if form.is_valid():
# this will also magically create the spark job for us
spark_job = form.save()
return redirect(spark_job)
context = {
'form': form,
}
return render(request, 'atmo/spark-job-new.html', context)
def test_workflow_list_get(self):
# set dates to test reverse chron ordering
self.workflow1.creation_date = "2010-10-20 1:23Z"
self.workflow1.save()
self.workflow2 = Workflow.objects.create(
name='Workflow 2',
owner=self.user,
creation_date='2015-09-18 2:34Z')
request = self._build_get('/api/workflows/', user=self.user)
response = render_workflows(request)
self.assertIs(response.status_code, status.HTTP_200_OK)
workflows = response.context_data['initState']['workflows']
# should not pick up other user's workflows, even public ones
self.assertEqual(
len(workflows['owned']) + len(workflows['shared']) +
len(workflows['templates']), 2)
self.assertEqual(workflows['owned'][0]['name'], 'Workflow 2')
self.assertEqual(workflows['owned'][0]['id'], self.workflow2.id)
self.assertEqual(workflows['owned'][0]['public'],
self.workflow1.public)
self.assertEqual(workflows['owned'][0]['read_only'],
False) # user is owner
self.assertEqual(workflows['owned'][0]['is_owner'],
True) # user is owner
self.assertIsNotNone(workflows['owned'][0]['last_update'])
self.assertEqual(workflows['owned'][0]['owner_name'],
user_display(self.workflow2.owner))
self.assertEqual(workflows['owned'][1]['name'], 'Workflow 1')
self.assertEqual(workflows['owned'][1]['id'], self.workflow1.id)
def new_spark_job(request):
identifier = u'{}-telemetry-scheduled-task'.format(user_display(request.user))
next_identifier = next_field_value(SparkJob, 'identifier', identifier)
initial = {
'identifier': next_identifier,
'size': 1,
'interval_in_hours': SparkJob.INTERVAL_WEEKLY,
'job_timeout': 24,
'start_date': timezone.now(),
}
form = NewSparkJobForm(request.user, initial=initial)
if request.method == 'POST':
form = NewSparkJobForm(
request.user,
data=request.POST,
files=request.FILES,
initial=initial,
)
if form.is_valid():
# this will also magically create the spark job for us
spark_job = form.save()
return redirect(spark_job)
context = {
'form': form,
}
return render(request, 'atmo/spark-job-new.html', context)
def reminder_level():
# get all user without level
# user_list = CustomUser.objects.filter(level=None)
user_list = CustomUser.objects.all()
site = Site.objects.get_current()
url = 'https://{domain}{path}'.format(domain=site.domain,
path=reverse('level'))
for user in user_list:
html_message = loader.render_to_string(
'account/email/level_reminder.html', {
'level_url': url,
'current_site': site,
'user': user
})
try:
user_email = EmailAddress.objects.filter(user=user).filter(
primary=True).get().email
logger.info(msg='sending mail to {}'.format(user_email))
print('sending mail to {}'.format(user_email))
send_mail(
'[Agapeer] Merging starts tomorrow',
"Hello {0}, \n You're on your way to something great! Follow the link or click the button below and enroll. \n {1}"
.format(user_display(user), url),
'*****@*****.**', [user_email],
fail_silently=False,
html_message=html_message)
except EmailAddress.DoesNotExist:
continue
def form_valid(self, form):
"""Create and log in the user signing up
Took this from allauth because extensibility is for chumps.
"""
self.object = form.save(request=self.request)
signals.user_signed_up.send(sender=self.object.__class__,
request=self.request,
user=self.object)
# not is_active: social users are redirected to a template
# local users are stopped due to form validation checking is_active
assert self.object.is_active
if (settings.ACCOUNT_EMAIL_VERIFICATION
and not EmailAddress.objects.filter(user=self.object,
verified=True).exists()):
send_email_confirmation(self.object, self.request)
# HACK: This may not be nice. The proper Django way is to use an
# authentication backend, but I fail to see any added benefit
# whereas I do see the downsides (having to bother the integrator
# to set up authentication backends in settings.py
if not hasattr(self.object, 'backend'):
self.object.backend = "django.contrib.auth.backends.ModelBackend"
signals.user_logged_in.send(sender=self.object.__class__,
request=self.request,
user=self.object)
login(self.request, self.object)
msg = _('Successfully signed in as {0}.'.format(user_display(self.object)))
messages.success(self.request, msg)
return HttpResponseRedirect(self.get_success_url())
def email_output_delta(output_delta: OutputDelta, updated_at: datetime.datetime):
domain = Site.objects.get_current().domain
workflow_url = f"https://${domain}/workflows/{output_delta.workflow_id}/"
ctx = {
"i18n": {"locale_id": output_delta.locale_id},
"user_name": user_display(output_delta.user),
"module_name": output_delta.module_name,
"workflow_name": output_delta.workflow_name,
"workflow_url": workflow_url,
"date": updated_at,
}
subject = render_to_string("new_data_version_subject.txt", ctx)
subject = "".join(subject.splitlines())
message = render_to_string("new_data_version.txt", ctx)
mail = EmailMultiAlternatives(
subject=subject,
body=message,
from_email=settings.DEFAULT_FROM_EMAIL,
to=[output_delta.user.email],
)
mail.attach_alternative(message, "text/html")
try:
mail.send()
except smtplib.SMTPServerDisconnected:
logger.error("Failed to send email notification")
def test_workflow_init_state(self):
# checks to make sure the right initial data is embedded in the HTML (username etc.)
with patch.dict(
'os.environ', {
'CJW_INTERCOM_APP_ID': 'myIntercomId',
'CJW_GOOGLE_ANALYTICS': 'myGaId'
}):
# create an Edit Cells module so we can check that its ID is returned correctly
edit_cells_module_id = add_new_module_version(
'Edit Cells', id_name='editcells').module_id
load_update_table_module_ids.cache_clear()
response = self.client.get(
'/workflows/%d/' %
self.workflow1.id) # need trailing slash or 301
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertContains(response, '"loggedInUser"')
self.assertContains(response, user_display(self.user))
self.assertContains(response, self.user.email)
self.assertContains(response,
'"editcells": ' + str(edit_cells_module_id))
self.assertContains(response, '"workflow"')
self.assertContains(response, '"modules"')
self.assertNotContains(response, '"reorder-column"')
self.assertContains(response, 'myIntercomId')
self.assertContains(response, 'myGaId')
def get_owner_name(self, obj):
if obj.example:
return 'Workbench'
else:
# Different from WorkflowSerializer because WorkflowSerializer
# takes an extra context['request'] argument, and we don't.
return user_display(obj.owner)
def test_workflow_list_get(self):
# set dates to test reverse chron ordering
self.workflow1.creation_date = "2010-10-20 1:23Z"
self.workflow1.save()
self.workflow2.creation_date = "2015-09-18 2:34Z"
self.workflow2.save()
request = self._build_get('/api/workflows/', user=self.user)
response = workflow_list(request)
self.assertIs(response.status_code, status.HTTP_200_OK)
self.assertEqual(
len(response.data),
2) # should not pick up other user's workflows, even public ones
self.assertEqual(response.data[0]['name'], 'Workflow 2')
self.assertEqual(response.data[0]['id'], self.workflow2.id)
self.assertEqual(response.data[0]['public'], self.workflow1.public)
self.assertEqual(
response.data[0]['read_only'],
False) # if we can list it, it's ours and we can edit it
self.assertIsNotNone(response.data[0]['last_update'])
self.assertEqual(response.data[0]['owner_name'],
user_display(self.workflow2.owner))
self.assertEqual(response.data[1]['name'], 'Workflow 1')
self.assertEqual(response.data[1]['id'], self.workflow1.id)
def new_cluster(request):
initial = {
'identifier':
u'{}-telemetry-analysis'.format(user_display(request.user)),
'size': 1,
}
form = NewClusterForm(
request.user,
initial=initial,
)
if request.method == 'POST':
form = NewClusterForm(
request.user,
data=request.POST,
files=request.FILES,
initial=initial,
)
if form.is_valid():
cluster = form.save(
) # this will also magically spawn the cluster for us
return redirect(cluster)
context = {
'form': form,
}
return render(request, 'atmo/cluster-new.html', context)
def test_index_get(self):
# set dates to test reverse chron ordering
self.workflow1.creation_date = "2010-10-20 1:23Z"
self.workflow1.save()
self.workflow2 = Workflow.create_and_init(
name="Workflow 2",
owner=self.user,
creation_date="2015-09-18 2:34Z")
self.client.force_login(self.user)
response = self.client.get("/workflows/")
self.assertEqual(response.status_code, status.HTTP_200_OK)
workflows = response.context_data["initState"]["workflows"]
# should not pick up other user's workflows, even public ones
self.assertEqual(
len(workflows["owned"]) + len(workflows["shared"]) +
len(workflows["templates"]),
2,
)
self.assertEqual(workflows["owned"][0]["name"], "Workflow 2")
self.assertEqual(workflows["owned"][0]["id"], self.workflow2.id)
self.assertEqual(workflows["owned"][0]["public"],
self.workflow1.public)
self.assertEqual(workflows["owned"][0]["read_only"],
False) # user is owner
self.assertEqual(workflows["owned"][0]["is_owner"],
True) # user is owner
self.assertIsNotNone(workflows["owned"][0]["last_update"])
self.assertEqual(workflows["owned"][0]["owner_name"],
user_display(self.workflow2.owner))
self.assertEqual(workflows["owned"][1]["name"], "Workflow 1")
self.assertEqual(workflows["owned"][1]["id"], self.workflow1.id)
def render(self, context):
user = self.user_var.resolve(context)
display = user_display(user)
if self.as_var:
context[self.as_var] = display
return ""
return display
def decorate_submission_message(cls, tasks, view):
for task in tasks:
submission_message = 'Are you sure you want to submit this task for review?'
if task.assigned_to and not task.assigned_to == view.request.user:
submission_message = 'Are you sure you want to submit this task for review on behalf of {}?' \
.format(user_display(task.assigned_to))
task.submission_message = submission_message
return tasks
def render(self, context):
user = self.user_var.resolve(context)
display = user_display(user)
if self.as_var:
context[self.as_var] = display
return ""
return display
def jsonize_user(user: User, user_profile: Optional["UserProfile"]) -> Dict[str, Any]:
return {
"display_name": user_display(user),
"email": user.email,
"is_staff": user.is_staff,
"stripeCustomerId": (
None if user_profile is None else user_profile.stripe_customer_id
),
"limits": (
UserLimits() if user_profile is None else user_profile.effective_limits
)._asdict(),
}
def jsonize_user(user: User) -> Dict[str, Any]:
return {
"username":
user.username,
"display_name":
user_display(user),
"stripeCustomerId":
user.user_profile.stripe_customer_id,
"subscriptions": [
jsonize_subscription(sub)
for sub in user.subscriptions.select_related(
"price", "price__product").all()
],
}
def test_workflow_init_state(self):
# checks to make sure the right initial data is embedded in the HTML (username etc.)
response = self.client.get('/workflows/%d/' % self.workflow1.id) # need trailing slash or 301
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertContains(response, '"loggedInUser"')
self.assertContains(response, user_display(self.user))
self.assertContains(response, self.user.email)
self.assertContains(response, '"workflow"')
self.assertContains(response, '"modules"')
self.assertContains(response, 'myIntercomId')
self.assertContains(response, 'myGaId')
self.assertContains(response, 'myHeapId')
def user_profile(user):
""" Formatted link to a user's profile, using their display name.
"""
if not user:
return ''
username = user_display(user)
profile_url = settings.INDIGO_USER_PROFILE_URL
if profile_url:
url = reverse('indigo_social:user_profile', kwargs={'username': user.username})
html = format_html('<a href="{}">{}</a>', url, username)
else:
html = username
return html
def jsonize_user(user: User) -> Dict[str, Any]:
if user.is_anonymous:
return None
stripe_customer_id = user.user_profile.stripe_customer_id
subscribed_stripe_product_ids = list(
user.subscriptions.select_related("price__product").values_list(
"price__product__stripe_product_id", flat=True))
return {
"username": user.username,
"display_name": user_display(user),
"subscribedStripeProductIds": subscribed_stripe_product_ids,
"stripeCustomerId": stripe_customer_id,
}
def user_display_tag(user):
"""
Example usage::
{% user_display user %}
or if you need to use in a {% blocktrans %}::
{% user_display user as user_display %}
{% blocktrans %}
{{ user_display }} has sent you a gift.
{% endblocktrans %}
"""
return user_display(user)
def user_display_tag(user):
"""
Example usage::
{% user_display user %}
or if you need to use in a {% blocktrans %}::
{% user_display user as user_display %}
{% blocktrans %}
{{ user_display }} has sent you a gift.
{% endblocktrans %}
"""
return user_display(user)
def email_notification(user, wfm):
ctx = {
'user_name': user_display(user),
'workflow_name': wfm.workflow.name,
'workflow_url': get_absolute_url(wfm.workflow.get_absolute_url()),
'date': wfm.stored_data_version.strftime('%b %-d, %Y at %-I:%M %p')
}
subject = render_to_string("notifications/new_data_version_subject.txt",
ctx)
subject = "".join(subject.splitlines())
message = render_to_string("notifications/new_data_version.txt", ctx)
mail = EmailMultiAlternatives(subject=subject,
body=message,
from_email=settings.DEFAULT_FROM_EMAIL,
to=[user.email])
mail.attach_alternative(message, "text/html")
mail.send()
def test_workflow_init_state(self):
# checks to make sure the right initial data is embedded in the HTML (username etc.)
with patch.dict(
'os.environ', {
'CJW_INTERCOM_APP_ID': 'myIntercomId',
'CJW_GOOGLE_ANALYTICS': 'myGaId'
}):
response = self.client.get(
'/workflows/%d/' %
self.workflow1.id) # need trailing slash or 301
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertContains(response, '"loggedInUser"')
self.assertContains(response, user_display(self.user))
self.assertContains(response, self.user.email)
self.assertContains(response, '"workflow"')
self.assertContains(response, '"modules"')
self.assertContains(response, 'myIntercomId')
self.assertContains(response, 'myGaId')
def email_output_delta(output_delta: OutputDelta,
updated_at: datetime.datetime):
user = output_delta.user
ctx = {
'user_name': user_display(user),
'module_name': output_delta.module_name,
'workflow_name': output_delta.workflow_name,
'workflow_url': output_delta.workflow_url,
'date': updated_at.strftime('%b %-d, %Y at %-I:%M %p'),
}
subject = render_to_string("notifications/new_data_version_subject.txt",
ctx)
subject = "".join(subject.splitlines())
message = render_to_string("notifications/new_data_version.txt", ctx)
mail = EmailMultiAlternatives(subject=subject,
body=message,
from_email=settings.DEFAULT_FROM_EMAIL,
to=[user.email])
mail.attach_alternative(message, "text/html")
mail.send()
def new_cluster(request):
initial = {
'identifier': u'{}-telemetry-analysis'.format(user_display(request.user)),
'size': 1,
}
form = NewClusterForm(
request.user,
initial=initial,
)
if request.method == 'POST':
form = NewClusterForm(
request.user,
data=request.POST,
files=request.FILES,
initial=initial,
)
if form.is_valid():
cluster = form.save() # this will also magically spawn the cluster for us
return redirect(cluster)
context = {
'form': form,
}
return render(request, 'atmo/cluster-new.html', context)
def email_output_delta(output_delta: OutputDelta,
updated_at: datetime.datetime):
user = output_delta.user
ctx = {
**get_i18n_context(user=user),
"user_name": user_display(user),
"module_name": output_delta.module_name,
"workflow_name": output_delta.workflow_name,
"workflow_url": output_delta.workflow_url,
"date": updated_at,
}
subject = render_to_string("notifications/new_data_version_subject.txt",
ctx)
subject = "".join(subject.splitlines())
message = render_to_string("notifications/new_data_version.txt", ctx)
mail = EmailMultiAlternatives(
subject=subject,
body=message,
from_email=settings.DEFAULT_FROM_EMAIL,
to=[user.email],
)
mail.attach_alternative(message, "text/html")
mail.send()
def __str__(self):
return user_display(self.user) + ' (' + self.user.email + ')'
def __str__(self):
return user_display(self.user) + " (" + self.user.email + ")"
def do_user_display(context, user):
display = user_display(user)
return display
def get_display_name(self, user):
return user_display(user)
def socialaccount_user_display(socialaccount):
func = app_settings.SOCIALACCOUNT_STR
if not func:
return user_display(socialaccount.user)
return func(socialaccount)
def get_display_name(self, obj):
return user_display(obj)
