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