示例#1
0
def check_account(request, email):
    # return render(request, 'main/activated.html', {})
    try:
        user = get_object_or_404(SaarangUser, email=base64.b64decode(email))
        if user.activate_status == 0:
            user.activate_status = 2
            user.save()
            messages.success(request, 'Your account has been activated')
            messages.info(request, 'Your Saarang ID is '+user.saarang_id)
            messages.error(request, 'Check you email for exciting Saarang Goodies !!!')
            messages.warning(request, 'Please login to Saarang Website by clicking on the Saarang logo')
            last = get_object_or_404(LastCoupon, pk=1)
            last_coupon = int(last.coupon_id)
            coupon = get_object_or_404(Coupon, pk=last_coupon, sent=False)
            coupon_code_link = 'https://www.komparify.com/recharge?couponcode='+coupon.code
            mail.send(
                    [user.email], template='email/main/activate_confirm',
                    context={'saarang_id':user.saarang_id, 'coupon_code_link': coupon_code_link, }
            )
            coupon.sent = True
            coupon.sent_to = user
            coupon.save()
            last.coupon_id += 1
            last.save()
        else:
            messages.warning(request, 'Your account has already been activated')
    except Exception, e:
        raise e
        messages.error(request, 'Error')
    def generate_emails(self):
        # Emails are gona be send to all applicants that have
        # interview date and didn't receive an email yet
        recipients = [student for student in Student.objects.filter(
            has_received_email=False,
            has_interview_date=True)]

        for student in recipients:
            mail.send(
                recipients=[student.email],
                template=self.template,
                context={
                    'name': student.name,
                    'applied_course': student.applied_course,
                    'interview_date': student.interviewslot.teacher_time_slot.date,
                    'interview_start_time': student.interviewslot.start_time,
                    'confirm_interview_url': self.confirm_interview_url + student.uuid,
                    'choose_interview_url': self.choose_interview_url + student.uuid,
                })
            try:
                self.__inc_generated_emails()
                student.has_received_email = True
                student.save()
            except Exception as e:
                self.__inc_errors()
                student.has_received_email = False
                student.save()
                print(e)
                pass
示例#3
0
def delete_member(request, team_id, member_id):
    team = get_object_or_404(HospiTeam, pk=team_id)
    user = get_object_or_404(SaarangUser, pk=member_id)

    team.members.remove(user)
    mail.send([user.email], template="email/hospi/member_deleted", context={"team": team})
    return redirect("hospi_home")
示例#4
0
def release_dev(id, currentuser):
    device = Device.objects.get(id=id)
    if device.owner != currentuser:
        return "Your are not the owner of this device."
    else:
        device.owner = None 

        subject = "[Labsmith]%s is released." % ( device.name)
        html_msg = r'You can reserve it now.<br><br><a href="http://10.62.34.99:8010/labsmith/">http://10.62.34.99:8010/labsmith/</a>'
        if device.wanted != None:
            mailto = device.wanted.email
            mail.send(
                [mailto],
                '*****@*****.**',
                subject=subject,
                html_message= html_msg, 
                # priority='now',
            )
            device.wanted = None
        device.user = ""
            
        device.save();
            
        msg = "%s is free now." % (device.name)
        log=Log(device=device,user=currentuser,timestamp=timezone.now(),msg="release")
        log.save()
        return msg
示例#5
0
def send_html_email_with_dj_template(recipients, subject, dj_template,
                                     context={}, sender=None, template=None,
                                     message='', headers=None,
                                     priority=None, backend=''):
    """

    Arguments:
    - `recipients`:
    - `subject`:
    - `sender`:
    - `template`:
    - `context`:

    """
    base_context = {
        'url_base': get_site_scheme_and_netloc(),
        'site_name': SITE_NAME,
        'media_url': MEDIA_URL,
        'logo_path': LOGO_PATH,
    }
    context.update(base_context)
    t = loader.get_template(dj_template)
    html_message = t.render(Context(context))

    mail.send(recipients, sender=sender, template=template, context=context,
              subject=subject, message=message,
              html_message=html_message, headers=headers, priority=priority,
              backend=backend)
    def handle(self, *args, **options):
        translation.activate(settings.LANGUAGE_CODE)
        event = Event.objects.get(code_name=options['event_code_name'])
        from_email = event.get_notification_email()
        # Skip abstracts that already have certificates
        generated_pks = Certificate.objects.values_list('abstracts__pk', flat=True)
        abstracts = Abstract.objects.filter(event=event,
                                            user__isnull=False,
                                            did_presenter_attend=True,
                                            accepted_presentaion_preference__in=["O", "P"])\
                                    .exclude(pk__in=generated_pks)
        domain = Site.objects.get_current().domain
        url = "https://{}{}".format(domain,
                                    reverse('certificates:list_certificates_per_user'))
        for abstract in abstracts:
            if abstract.accepted_presentaion_preference == 'O':
                template = abstract.event.oral_certificate_template
            elif abstract.accepted_presentaion_preference == 'P':
                template = abstract.event.poster_certificate_template

            template.generate_certificate(abstract.user, [abstract.presenting_author, abstract.title])
            if options['send_emails']:
                contxt = {'title': abstract.title,
                          'user': abstract.user,
                          'event': event,
                          'url': url}
                mail.send(abstract.email, from_email,
                          template='event_abstract_certificate',
                          context=context)
示例#7
0
def send_email(request, pk):
    supervisor = get_object_or_404(Supervisor, pk=pk)

    if request.method == 'POST':
        form = EmailForm(request.POST)
        if form.is_valid():
            email_context = {'user': request.user,
                             'supervisor': supervisor,
                             'data': form.cleaned_data}
            mail.send([request.user.email],
                       "*****@*****.**",
                       template="researchhub_send_email_to_student",
                       context=email_context)
            mail.send([supervisor.user.email],
                       "*****@*****.**",
                       bcc="*****@*****.**",
                       template="researchhub_send_email_to_supervisor",
                       context=email_context,
                       headers={'Reply-to': request.user.email})
            return {"message": "success"}
    elif request.method == 'GET':
        form = EmailForm()

    context = {'form': form,
                'supervisor': supervisor}
    return render(request, 'researchhub/send_email_form.html', context)
示例#8
0
def add_request(request, guide_pk):
    guide = get_object_or_404(GuideProfile, pk=guide_pk,
                              is_deleted=False)
    if request.method == 'POST':
        instance = Request(user=request.user, guide=guide)
        form = RequestForm(request.POST, instance=instance)
        if form.is_valid():
            guide_request = form.save()
            list_guide_requests_url = reverse('studentguide:list_guide_requests', args=(guide.pk,))
            email_full_url = request.build_absolute_uri(list_guide_requests_url)
            email_context = {'guide': guide,
                             'guide_request': guide_request,
                             'full_url': email_full_url}
            mail.send([guide.user.email],
                      template="guide_request_created_to_guide",
                      context=email_context)

            list_my_requests_url = reverse('studentguide:list_my_requests')
            full_url = request.build_absolute_uri(list_my_requests_url)
            return {"message": "success", "list_url": full_url}
    elif request.method == 'GET':
        form = RequestForm()

    context = {'form': form, 'guide': guide}
    return render(request, 'studentguide/edit_request_form.html', context)
示例#9
0
def add_report(request, guide_pk):
    guide = get_object_or_404(GuideProfile, pk=guide_pk)

    if not utils.can_edit_guide(request.user, guide):
        raise Exception(u"لا تستطيع رفع تقرير")

    if request.method == 'POST':
        current_year = StudentClubYear.objects.get_current()
        instance = Report(guide=guide)
        form = ReportForm(request.POST, request.FILES, instance=instance)
        if form.is_valid():
            report = form.save()
            show_report_url = reverse('studentguide:show_report', args=(guide.pk, report.pk))
            full_url = request.build_absolute_uri(show_report_url)
            if guide.assessor:
                email_context = {'assessor': guide.assessor,
                                 'guide': guide,
                                 'full_url': full_url}
                mail.send([guide.assessor.email],
                          template="report_submitted_to_assessor",
                          context=email_context)
            return {"message": "success", "show_url": full_url}
    elif request.method == 'GET':
        form = ReportForm()

    context = {'form': form, 'guide': guide}
    return render(request, 'studentguide/edit_report_form.html', context)
示例#10
0
def email(recipient, context, template_name, sender=None):
    if not settings.MANDRILL_API_KEY or settings.MANDRILL_API_KEY == 'None':
        return
    current_site = Site.objects.get_current()
    context['domain'] = current_site.domain
    User = django.contrib.auth.get_user_model()
    # The recipient list can be a list of User model instances or Email Address string
    # Which means you could pass a User model QuerySet as recipient
    # If a recipient is User model instance then simple convert to Email Address string
    recipient_email_list = []
    for rec in recipient:
        if isinstance(rec, User):
            if rec.first_name and rec.last_name:
                recipient_email_list.append('"%s %s" <%s>' % (rec.first_name, rec.last_name, rec.email))
            elif rec.first_name:
                recipient_email_list.append('"%s" <%s>' % (rec.first_name, rec.email))
            else:
                recipient_email_list.append('%s' % rec.email)
        else:
            recipient_email_list.append(rec)

    mail.send(
        sender=sender or settings.DEFAULT_FROM_EMAIL,
        recipients=recipient_email_list,
        template=template_name,
        context=context,
        priority=PRIORITY.now
    )
示例#11
0
def add_guide(request):
    if request.method == 'POST':
        current_year = StudentClubYear.objects.get_current()
        studentguide_club = clubs.utils.get_club_for_user("Student Guide", request.user)
        random_assessor = studentguide_club.members.order_by('?').first()
        instance = GuideProfile(user=request.user, year=current_year, assessor=random_assessor)
        form = GuideForm(request.POST, request.FILES, instance=instance)
        if form.is_valid() and not utils.has_guide_profile(request.user):
            guide = form.save()
            list_supervised_guides_url = reverse('studentguide:list_supervised_guides')
            full_url = request.build_absolute_uri(list_supervised_guides_url)
            email_context = {'assessor': random_assessor,
                             'guide': guide,
                             'full_url': full_url}
            # If there are members to pick from, send an email.
            if random_assessor:
                mail.send([random_assessor.email],
                          template="guide_assigned_randomly_to_assessor",
                          context=email_context)
            show_guide_url = reverse('studentguide:show_guide', args=(guide.pk,))
            full_url = request.build_absolute_uri(show_guide_url)
            return {"message": "success", "show_url": full_url}
    elif request.method == 'GET':
        form = GuideForm()

    context = {'form': form}
    return render(request, 'studentguide/edit_guide_form.html', context)
示例#12
0
def contato(request):
    name = request.POST.get('name', '')
    parceiro = request.POST.get('parceiro', '')
    phone = request.POST.get('phone', '')
    email = request.POST.get('email', '')
    subject = request.POST.get('subject', '')
    message = request.POST.get('message', '')

    if name and message and email:

		mail.send(
		    ['*****@*****.**'],
		    sender=settings.DEFAULT_FROM_EMAIL,
		    template='contato',
		    context={'name':name,'subject':subject, 'message':message, 'email':email, 'phone':phone},
		)
		return redirect('http://cdr-port.net')

    elif parceiro and message and email:

		mail.send(
		    ['*****@*****.**'],
		    sender=settings.DEFAULT_FROM_EMAIL,
		    template='parceiro',
		    context={'name':parceiro,'subject':subject, 'message':message, 'email':email, 'phone':phone},
		)
        	return redirect('http://parceiros.cdr-port.net')

    else:
        return HttpResponse("Preencha todos os campos.")
示例#13
0
def student_action(request):
    supervision_request_id = request.POST.get('supervision_request_id')
    action = request.POST.get('action')
    supervision_request = get_object_or_404(SupervisionRequest.objects.current_year(),
                                            pk=supervision_request_id)

    if supervision_request.user != request.user:
        raise Exception(u'لست أنت مقدم الطلب!')

    if action == 'delete':
        if supervision_request.status == 'A':
            now = datetime.datetime.now()
            supervision_request.status = 'WN'
            supervision_request.withdrawal_date = now
            to_me_url = reverse('arshidni:supervision_requests_to_me')
            full_url = request.build_absolute_uri(to_me_url)
            arshidni_coordinator = get_arshidni_club_for_user(request.user).coordinator
            if arshidni_coordinator:
                email_context = {'full_url': full_url,
                                 'supervision_request': supervision_request}
                mail.send([supervision_request.colleague.user.email],
                          cc=[arshidni_coordinator.email],
                          template="supervision_request_withdrawn",
                          context=email_context)
        elif supervision_request.status == 'P':
            supervision_request.status = 'D'
        else: # Just in case
            raise Exception(u'حدث خطأ غير معروف.')
        supervision_request.save()
    else:
        raise Exception(u'حدث خطأ غير معروف.')

    return  {'current_status': supervision_request.status,
             'full_current_status': supervision_request.get_status_display()}
示例#14
0
def submit_group(request):
    if request.method == 'POST':
        group_object = StudyGroup(coordinator=request.user)
        form = StudyGroupForm(request.POST, instance=group_object)
        if form.is_valid():
            new_group = form.save()
            group_url = reverse('arshidni:show_group',
                                args=(new_group.pk,))
            group_full_url = request.build_absolute_uri(group_url)
            admin_url = reverse('arshidni_admin:index')
            admin_full_url = request.build_absolute_uri(admin_url)
            arshidni_coordinator = get_arshidni_club_for_user(request.user).coordinator
            if arshidni_coordinator:
                email_context = {'arshidni_coordinator': arshidni_coordinator,
                                 'group': new_group,
                                 'full_url': group_full_url,
                                 'admin_full_url': admin_full_url}
                mail.send([arshidni_coordinator.email],
                          template="study_group_submitted",
                          context=email_context)
            return HttpResponseRedirect(group_url)
        else:
            context = {'form': form}
    elif request.method == 'GET':
        form = StudyGroupForm()
        context = {'form': form}

    return render(request, 'arshidni/group_edit.html', context)
示例#15
0
def register_team(request,eventId,teamId):
    email = request.session.get('saaranguser_email')
    try:
        user = SaarangUser.objects.get(email=email)
    except:
        messages.error(request, 'Please login to continue')
        return render(request, 'main/login.html', {})
    event = get_object_or_404(Event,id=eventId)
    team = get_object_or_404(Team,id=teamId)
    if EventRegistration.objects.filter(event=event,team=team):
        if event.id in EVENT_WITH_OPTIONS:
            return HttpResponseRedirect(reverse('band_details',kwargs={'eventId':eventId,'teamId':teamId}))
        messages.info(request,'Already registered for the event')
    else:
        if not event.registration_open :
            messages.info(request,'Registration is closed for the event.')
        else:
            EventRegistration.objects.create(participant=user,team=team,event=event,options='')
            mail_list = [member.email for member in team.members.all()]
            mail_list.append(email)
            mail.send(
                mail_list, template='email/main/register_team',
                context={'event_name':event.long_name, 'team_name':team.name,},
                )
            if event.id in EVENT_WITH_OPTIONS:
                return HttpResponseRedirect(reverse('band_details',kwargs={'eventId':eventId,'teamId':teamId}))
            messages.success(request,'Team registered successfully')
    return render(request, 'main/register_response.html')
示例#16
0
文件: views.py 项目: hkarl/svpb
    def form_valid(self, form):

        if form.has_changed():
            user = self.get_user()
            self.storeUser(form, user)

            user.save()
            user.mitglied.save()

            # print ({'user': user.__dict__,
            #         'mitglied': user.mitglied.__dict__})
            # print type(user)
            # print user.last_name
            # print type(user.mitglied)

            # inform the relevant Vorstand in charge of memeberhsip
            mail.send(['*****@*****.**'],
                      template="updatedProfile",
                      context={'user': user,
                               'mitglied': user.mitglied,
                               'changed': form.changed_data},
                      priority='now',
                      )

            messages.success(self.request,
                             format_html(
                                 u"Das Profil {} {} ({}) wurde erfolgreich aktualisiert.",
                                 user.first_name, user.last_name,
                                 user.mitglied.mitgliedsnummer))
        else:
            messages.success(self.request,
                             "Sie haben keine Änderungen vorgenommen."
                             )

        return super(AccountEdit, self).form_valid(form)
 def handle(self, *args, **options):
     domain = Site.objects.get_current().domain
     end_date_target = timezone.now().date()
     end_time_since = (timezone.now() - datetime.timedelta(minutes=10)).time()
     end_time_until = timezone.now().time()
     for activity in Activity.objects.current_year().approved().done().filter(episode__end_date=end_date_target)\
                                                                      .exclude(assessment__criterionvalue__criterion__category='P')\
                                                                      .exclude(primary_club__is_assessed=False)\
                                                                      .distinct():
         # If the activity didn't end within the past ten minutes,
         # skip, because another proccess would have sent a
         # notification about it.
         if not activity.episode_set.filter(episode__end_date=end_date_target,
                                            episode__end_time__gt=end_time_since,
                                            episode__end_time__lte=end_time_until).exists():
             continue
         email_context = {'activity': activity}
         assessor_club = Club.objects.club_assessing_parents(activity.primary_club).first()
         if assessor_club.coordinator:
             full_url = "https://{}{}".format(domain,
                                              reverse('activities:assess',
                                                      args=(activity.pk, 'p')))
             email_context['full_url'] = full_url
             email_context['assessor_club'] =  assessor_club
             email_context['assessor'] = assessor_club.coordinator
             mail.send([assessor_club.coordinator.email],
                        template="activity_done_to_assessor",
                        context=email_context)
         self.stdout.write(u'Assigned {0} to {1}. Emailing {1}.'.format(activity.name, assessor_club))
示例#18
0
def user_create(request, template_name='vnoiusers/user_create.html'):
    form = UserCreateForm()
    if request.user.is_authenticated():
        messages.warning(request, 'Invalid request')
        return HttpResponseRedirect(reverse('main:index'))

    if request.POST:
        form = UserCreateForm(request.POST)
        if form.is_valid():
            form.save()  # save user to database if form is valid

            username = form.cleaned_data['username']
            email = form.cleaned_data['email']
            salt = hashlib.sha1(str(random.random())).hexdigest()[:8]
            activation_key = hashlib.sha1(salt+email).hexdigest()

            # Get user by username
            user = User.objects.get(username=username)
            user.profile.activation_key = activation_key
            user.profile.save()

            # Send email with activation key
            if not DEBUG:
                email_subject = 'Đăng ký tài khoản VNOI'
                email_body = "Hi %s, chào mừng bạn đã đến với VNOI. Để kích hoạt tài khoản, hãy click vào link: %s/user/confirm/%s" % (username, ROOT_URL, activation_key)
                mail.send(email, subject=email_subject, message=email_body, priority="now")
                return HttpResponse('Một email đã được gửi đến tài khoản email mà bạn đăng ký. Hãy kiểm tra hòm thư của bạn và làm theo hướng dẫn để kích hoạt tài khoản.')
            else:
                return HttpResponse('Bạn đã đăng ký thành công. Bạn có thể trở về trang chủ để đăng nhập')
        else:
            return render(request, template_name,
                          {'form': form, 'message': form.errors})
    else:
        return render(request, template_name,
                      {'form': form, 'message': ''})
示例#19
0
def order_event_notification(sender, instance=None, target=None, **kwargs):
    from shop.rest import serializers

    if not isinstance(instance, OrderModel):
        return
    for notification in Notification.objects.filter(transition_target=target):
        recipient = notification.get_recipient(instance)
        if recipient is None:
            continue

        # emulate a request object which behaves similar to that one, when the customer submitted its order
        emulated_request = EmulateHttpRequest(instance.customer, instance.stored_request)
        order_serializer = serializers.OrderDetailSerializer(instance, context={'request': emulated_request})
        language = instance.stored_request.get('language')
        context = {
            'customer': serializers.CustomerSerializer(instance.customer).data,
            'data': order_serializer.data,
            'ABSOLUTE_BASE_URI': emulated_request.build_absolute_uri().rstrip('/'),
            'render_language': language,
        }
        try:
            template = notification.mail_template.translated_templates.get(language=language)
        except EmailTemplate.DoesNotExist:
            template = notification.mail_template
        attachments = {}
        for notiatt in notification.notificationattachment_set.all():
            attachments[notiatt.attachment.original_filename] = notiatt.attachment.file.file
        mail.send(recipient, template=notification.mail_template, context=context,
                  attachments=attachments, render_on_delivery=True)
示例#20
0
    def handle(self, *args, **options):
        # set the locale right, to get the dates represented correctly
        translation.activate(settings.LANGUAGE_CODE)

        offeneLeistungen = (models.Leistung.objects.
                            filter(
                                erstellt__lte=datetime.date.today()-datetime.timedelta(days=7)).
                            exclude(
                                status=models.Leistung.ACK).
                            exclude(
                                status=models.Leistung.NEG)
                            )

        print offeneLeistungen
        kontakte = set([l.aufgabe.kontakt() for l in offeneLeistungen])

        print kontakte
        
        for k in kontakte: 
            mail.send(
                [k.email], # to address
                template="leistungReminder",
            )

        call_command('send_queued_mail')

        translation.deactivate()
示例#21
0
def send_mass_mail(request):
    allowed = ['webops', 'events', 'publicity']
    if not request.user.userprofile.dept.name in allowed:
        to_return={
            'msg':'You dont have permission to send mass mail',
        }
        return render(request, 'alert.html', to_return)
    data = request.POST.copy()
    new_mail = MailLog.objects.create(from_email=data['from_email'], \
        to_email='*****@*****.**', subject=data['subject'], \
        body=data['body'], created_by=request.user)
    email_list=[]
    EL = EmailList.objects.all()
    for eml in EL:
        email_list.append(eml.email)
    mail.send(
        email_list,data['from_email'],
        subject=data['subject'],
        html_message=data['body'],
    )
    to_return ={
            'mail': new_mail,
        }
    messages.success(request, 'Email has been sent')
    return render(request, 'alert.html', to_return)
示例#22
0
def home(request):
    if request.method == 'POST':
        userform =SaarangUserForm(request.POST)
        data=request.POST.copy()
        if userform.is_valid():
            user = userform.save()
            user.saarang_id = auto_id(user.pk)
            characters = string.ascii_letters + string.punctuation  + string.digits
            password =  "".join(choice(characters) for x in range(randint(8, 16)))
            user.password = password
            user.activate_status = 2
            user.save()
            mail.send(
                [user.email], template='email/main/activate_confirm',
                context={'saarang_id':user.saarang_id, 'password':user.password}
            )
            userform = SaarangUserForm()
            messages.success(request, data['desk_id'] +' Successfully saved')
        else:
            userform = SaarangUserForm(request.POST)
    else:
        userform = SaarangUserForm()
    to_return={
            'form':userform,
            'action':  "",
            'title': "Add a new User"
        }
    return render(request, 'user_registration/qms.html', to_return)
示例#23
0
def user_create(request, template_name='vnoiusers/user_create.html'):
    form = UserCreateForm()
    if request.user.is_authenticated():
        messages.warning(request, 'Invalid request')
        return HttpResponseRedirect(reverse('main:index'))

    if request.POST:
        form = UserCreateForm(request.POST)
        if form.is_valid():
            form.save()  # save user to database if form is valid

            username = form.cleaned_data['username']
            email = form.cleaned_data['email']
            salt = hashlib.sha1(str(random.random())).hexdigest()[:8]
            activation_key = hashlib.sha1(salt+email).hexdigest()

            # Get user by username
            user = User.objects.get(username=username)
            user.profile.activation_key = activation_key
            user.profile.save()

            # Send email with activation key
            email_subject = 'Vnoiwebsite Account confirmation'
            email_body = "Hey %s, thanks for signing up. To activate your account, click this link http://127.0.0.1:8000/user/confirm/%s" % (username, activation_key)
            mail.send(email, subject=email_subject, message=email_body, priority="now")

            return HttpResponse('You have successfully register a new account. An email will be sent to your email shortly. Please click the confirmation link in the email')
        else:
            return render(request, template_name,
                          {'form': form, 'message': form.errors})
    else:
        return render(request, template_name,
                      {'form': form, 'message': ''})
    def handle(self, *args, **options):
        translation.activate(settings.LANGUAGE_CODE)
        event = Event.objects.get(code_name=options['event_code_name'])
        event_users = (User.objects.filter(certificate__sessions__event=event) | \
                       User.objects.filter(certificate__abstracts__event=event)).distinct()
        count = 1
        self.stdout.write("We got {} users to handle!".format(event_users.count()))
        domain = Site.objects.get_current().domain
        url = "https://{}{}".format(domain,
                                    reverse('certificates:list_certificates_per_user'))
        for user in event_users.iterator():
            email_context = {'user': user,
                             'url': url,
                             'event': event}
            notification_email = event.get_notification_email()
            cc = accounts.utils.get_user_cc(user)
            mail.send([user.email],
                      u"بوابة إنجاز <{}>".format(notification_email),
                      cc=cc,
                      template="event_certificates",
                      context=email_context)

            self.stdout.write("{:06d}: Sent to {}!".format(count, user.email))
            count +=1
            if options['sleep_time']:
                time.sleep(options['sleep_time'])
示例#25
0
    def handle(self, *args, **options):
        # set the locale right, to get the dates represented correctly
        translation.activate(settings.LANGUAGE_CODE)


        t = loader.get_template("boote/email_booking.html")
        
        # get records
        
        for booking in models.Booking.objects.filter(notified = False).order_by('-date'):
            c = Context({ 'booking': booking})
            payload = t.render(c)
            sbj = '[SVPB] Reservation (' + booking.date.strftime('%d, %b %Y') + ') - ' + booking.boat.type.name + " \"" + booking.boat.name + "\"" 
            self.stdout.write('From: ' +  settings.DEFAULT_FROM_EMAIL)
            self.stdout.write('To: ' + booking.user.email)
            self.stdout.write('Subject: ' + sbj)
            self.stdout.write('Content:\n\r' + payload)
            
            mail.send(
                  [booking.user.email], 
                  settings.DEFAULT_FROM_EMAIL,
                  subject=sbj,                  
                  html_message=payload,
            )
            
            booking.notified = True
            booking.save()     
            

        call_command('send_queued_mail')

        translation.deactivate()
    def handle(self, *args, **options):
        translation.activate(settings.LANGUAGE_CODE)
        domain = Site.objects.get_current().domain
        end_date_target = timezone.now().date()
        end_time_since = (timezone.now() - timedelta(minutes=10)).time()
        end_time_until = timezone.now().time()
        for episode in Episode.objects.filter(activity__is_approved=True,
                                              requires_report=True,
                                              end_date=end_date_target,
                                              end_time__gt=end_time_since,
                                              end_time__lte=end_time_until)\
                                      .exclude(followupreport__isnull=False,
                                               employeereport__isnull=False):
            print episode
            email_context = {'episode': episode}

            if not episode.employee_report_is_submitted() and \
               episode.activity.primary_club.employee:
                full_url = "https://{}{}".format(domain,
                                                 reverse('media:submit_employee_report',
                                                         args=(episode.pk,)))
                email_context['full_url'] = full_url
                mail.send([episode.activity.primary_club.employee.email],
                          template="due_report_to_report_submitter",
                          context=email_context)
            if not episode.report_is_submitted():
                emails = episode.activity.primary_club.media_representatives.values_list('email', flat=True)
                if emails:
                    full_url = "https://{}{}".format(domain,
                                                     reverse('media:submit_report',
                                                             args=(episode.pk,)))
                    email_context['full_url'] = full_url
                    mail.send(list(emails),
                              template="due_report_to_report_submitter",
                              context=email_context)
    def handle(self, *args, **options):
        translation.activate(settings.LANGUAGE_CODE)
        wb = load_workbook(options['excel_file'], read_only=True)
        domain = Site.objects.get_current().domain
        event = Event.objects.get(code_name=options['event_code_name'])
        from_email = event.get_notification_email()
        url = "https://{}{}".format(domain,
                                    reverse('certificates:list_certificates_per_user'))
        generated_pks = Certificate.objects.values_list('abstracts__pk', flat=True)

        for sheet_name in wb.get_sheet_names():
            sheet = wb[sheet_name]
            print "Reading sheet '{}'".format(sheet_name)
            for row in sheet:
                pk = row[0].value
                # If pk is empty, we are done from this sheet.
                if not pk:
                    break
                try:
                    pk = int(pk)
                except ValueError:
                    # If pk cannot be turned into intger
                    # (i.e. header), skip!
                    continue

                if pk in generated_pks:
                    print "Skipping {} as previously generated.".format(pk)
                    continue

                authors = [cell.value.strip() for cell in row[3:12] if cell.value]
                abstract = Abstract.objects.get(pk=pk)

                # Let's make sure that the abstract deserves a
                # certificate
                if abstract.accepted_presentaion_preference in ['O', 'P'] and \
                   abstract.did_presenter_attend:
                    if abstract.accepted_presentaion_preference == 'O':
                        template = abstract.event.oral_certificate_template
                    elif abstract.accepted_presentaion_preference == 'P':
                        template = abstract.event.poster_certificate_template

                    for author in authors:
                        description = "شهادة {} لتقديم {}".format(author, abstract.title)
                        print 'Generating {}\'s "{}"'.format(author, abstract.title)
                        template.generate_certificate(user=abstract.user,
                                                      texts=[author, abstract.title],
                                                      description=description,
                                                      content_object=abstract)
                        # Other than the first author, we are going to
                        # use the co_author certificate template
                        template = abstract.event.coauthor_certificate_template
                    if options['send_emails']:
                        contxt = {'title': abstract.title,
                                  'user': abstract.user,
                                  'event': event,
                                  'url': url}
                        mail.send(abstract.email, from_email,
                                  template='event_abstract_certificate',
                                  context=context)
示例#28
0
文件: utils.py 项目: Teplitsa/Rynda
def send_templated_email(template_name, user_list):
    for u in user_list:
        mail.send(
            recipients=[u.email],
            sender='*****@*****.**',
            template=template_name,
            context={'user': u},
            priority=3
        )
示例#29
0
文件: email.py 项目: hambro/chemie
def send_my_lockers_mail(email, lockers, user):
    template = 'lockers_mine_skap'

    mail.send(
        email,  # List of email addresses also accepted
        DEFAULT_FROM_EMAIL,
        template=template,  # Could be an EmailTemplate instance or name
        context={'user': user, 'email': email, 'lockers': lockers},
        )
示例#30
0
def send_user_contact_email(name, from_address, message):
    subject = "EMAIL FROM GBE SITE USER %s" % name
    to_addresses = settings.USER_CONTACT_RECIPIENT_ADDRESSES
    mail.send(to_addresses,
              from_address,
              subject=subject,
              message=message,
              priority='now',
              )
示例#31
0
def submit_supervision_request(request, colleague_profile_id):
    colleague_profile = get_object_or_404(
        ColleagueProfile.objects.current_year(),
        pk=colleague_profile_id,
        is_published=True)
    context = {'colleague_profile': colleague_profile}
    if request.method == 'POST':
        request_object = SupervisionRequest(user=request.user,
                                            colleague=colleague_profile)
        form = SupervisionRequestForm(request.POST, instance=request_object)
        if form.is_valid():
            new_request = form.save()
            to_me_url = reverse('arshidni:supervision_requests_to_me')
            full_url = request.build_absolute_uri(to_me_url)
            email_context = {
                'full_url': full_url,
                'supervision_request': new_request,
                'colleague_profile': colleague_profile
            }
            mail.send([colleague_profile.user.email],
                      template="supervision_request_submitted",
                      context=email_context)
            after_url = reverse('arshidni:my_supervision_requests'
                                ) + '#request-' + str(new_request.pk)
            return HttpResponseRedirect(after_url)
        else:
            context['form'] = form
    elif request.method == 'GET':
        # Check if the user has any pending or accepted supervision
        # requests
        accepted_student_requests = SupervisionRequest.objects.filter(
            user=request.user, status='A')
        pending_student_requests = SupervisionRequest.objects.filter(
            user=request.user, status='P')
        # Check if the colleague has exceeded the supervision limit.
        colleague_supervisions = colleague_profile.supervision_requests.accepted(
        )
        if colleague_supervisions.filter(user=request.user).exists():
            context['error'] = 'already_supervisor'
        elif accepted_student_requests.exists():
            context['error'] = 'accepted_supervision_requests'
        elif pending_student_requests.exists():
            context['error'] = 'pending_supervision_requests'
        elif colleague_supervisions.count() >= COLLEAGUE_SUPERVISION_LIMIT:
            context['error'] = 'colleague_supervision_limit'
        elif get_user_gender(request.user) != get_user_gender(
                colleague_profile.user):
            context['error'] = 'gender'
        else:
            form = SupervisionRequestForm()
            context['form'] = form

    return render(request, 'arshidni/colleague_choose.html', context)
示例#32
0
def test_mail(request):

    mail.send(
        ['*****@*****.**', '*****@*****.**'
         ],  # List of email addresses also accepted
        '*****@*****.**',
        subject='My email',
        message='Hi there!',
        html_message='Hi <strong>there</strong>!',
    )

    return HttpResponse("SENT")
示例#33
0
def send_password_recovery_code(user: User):
    token = user_activation_token.make_token(user=user)
    link = f'{BASE_URL}users/new_password/{user.pk}/{token}'

    context = {'token': token, 'link': link, 'user': user}

    mail.send([user.email],
              NOREPLY_EMAIL,
              template='user_password_recovery',
              context=context)

    return context
示例#34
0
    def send_mail(self):
        from post_office import mail

        mail.send(
            recipients=[self.user.email],
            template=
            'decima_question',  # Could be an EmailTemplate instance or name
            context={'decima': self},
            priority='now',
        )
        # print "Send mail implementation"
        return
示例#35
0
    def diagnostics(request):
        from django.conf import settings
        from post_office import mail

        ping_socket_url = (
            request.build_absolute_uri(f'{reverse("tracker:index_all")}ws/ping/')
            .replace('https:', 'wss:')
            .replace('http:', 'ws:')
        )

        celery_socket_url = (
            request.build_absolute_uri(f'{reverse("tracker:index_all")}ws/celery/')
            .replace('https:', 'wss:')
            .replace('http:', 'ws:')
        )

        if request.method == 'POST':
            test_email_form = TestEmailForm(data=request.POST)
            if test_email_form.is_valid():
                mail.send(
                    [test_email_form.cleaned_data['email']],
                    f'webmaster@{request.get_host().split(":")[0]}',
                    subject='Test Email',
                    message='If you got this, email is set up correctly.',
                )
                messages.info(
                    request, 'Test email queued. Check Post Office models for status.'
                )
        else:
            test_email_form = TestEmailForm()

        try:
            storage = DefaultStorage()
            output = storage.save(f'testfile_{int(time.time())}', BytesIO(b'test file'))
            storage.open(output).read()
            assert storage.exists(output)
            storage.delete(output)
            storage_works = True
        except Exception as e:
            storage_works = e

        return render(
            request,
            'admin/tracker/diagnostics.html',
            {
                'is_secure': request.is_secure(),
                'test_email_form': test_email_form,
                'ping_socket_url': ping_socket_url,
                'celery_socket_url': celery_socket_url,
                'storage_works': storage_works,
                'HAS_CELERY': getattr(settings, 'HAS_CELERY', False),
            },
        )
示例#36
0
 def save(self, request=None):
     '''
     send mail and so
     '''
     email = self.cleaned_data['email']
     subject = self.cleaned_data['subject']
     body = self.cleaned_data['body']
     mail.send(settings.WELTLADEN_EMAIL_ADDRESS,
               email,
               subject=subject,
               message=body)
     email_queued()
示例#37
0
def export(target_id):
    target = Export.objects.get(id=target_id)
    response = target.run()
    if settings.EXPORT_NOTIFICATIONS_ENABLED and target.notify and target.as_user.email:
        mail.send(
            target.as_user.email,  # List of email addresses also accepted
            '*****@*****.**',
            template='export_ready',
            context={'target': target,
                     'user': target.as_user,
                     'download_url': reverse('urf:export-fetch', args=[target.id])}
        )
    return response.status_code
示例#38
0
 def send_tour_operator_reject_email(self, tour_operator):
     email_to = tour_operator.email
     if not settings.REAL_EMAILS:
         email_to = settings.TESTING_EMAILS
     from post_office import mail
     URL = settings.BASE_URL
     context = {'tour_operator': tour_operator.name}
     mail.send(
         email_to,
         'Your African Safari <*****@*****.**>',
         template='tour_operator_rejected',
         context=context,
     )
示例#39
0
    def test_extends(self):
        post_office_mail.send(
            '*****@*****.**',
            '*****@*****.**',
            template='template1',
            context={},
        )

        self.assertEqual(len(mail.outbox), 1)
        content = mail.outbox[0].alternatives[0]
        self.assertEqual(content[1], 'text/html')
        self.assertIn('Base template', content[0])
        self.assertIn('Template1', content[0])
示例#40
0
 def form_valid(self, form):
     response = super(TestCreateView, self).form_valid(form)
     mail.send([self.object.epost],
               settings.SERVER_EMAIL,
               template=self.testtype,
               context={'deltager': self.object},
               priority='now')
     mail.send([settings.TEST_NOTIFY_EMAIL],
               settings.SERVER_EMAIL,
               template='%s_notify' % self.testtype,
               context={'deltager': self.object},
               priority='now')
     return response
示例#41
0
    def send(self):
        kwargs = {
            'subject': self.subject,
            'html_message': self.html_message,
            'message': self.text_message,
            'language': self.language,
            'attachments': self.attachments,
        }

        if self.from_email:
            mail.send(self.recipient, self.from_email, **kwargs)
        else:
            mail.send(self.recipient, **kwargs)
示例#42
0
def _send_mail_template(request,
                        plaintext_template,
                        html_template,
                        subject,
                        recipient,
                        context=None):
    msg_plain = render_to_string(plaintext_template, context, request)
    msg_html = render_to_string(html_template, context, request)
    mail.send(recipients=[recipient],
              sender=settings.DEFAULT_FROM_EMAIL,
              subject=subject,
              message=msg_plain,
              html_message=msg_html)
示例#43
0
def send_locker_email(user, token, activation_type):
    mail.send(
        user.user.email,
        settings.DEFAULT_FROM_EMAIL,
        template=activation_type,
        context={
            "user": user,
            "email": user.user.email,
            "ownership": token.ownership,
            "token": token,
            "root_url": get_current_site(None),
        },
    )
示例#44
0
 def send_confirmed(self):
     logger.debug(f'sending confirmation to owner: {self.owner.email}')
     mail.send(
         [self.owner.email],
         '*****@*****.**',
         'appointment_confirmed',
         context={
             'appointment': self,
             'confirming_party': self.invitee,
             'other_party': self.owner
         })
     self.confirmation_request_time = timezone.now()
     self.save()
示例#45
0
def transition_change_notification(order):
    """
    This function shall be called, after an Order object performed a transition change.

    """
    if not isinstance(order, BaseOrder):
        raise TypeError("Object order must inherit from class BaseOrder")
    emails_in_queue = False
    for notification in Notification.objects.filter(
            transition_target=order.status):
        recipient = notification.get_recipient(order)
        if recipient is None:
            continue

        # emulate a request object which behaves similar to that one, when the customer submitted its order
        emulated_request = EmulateHttpRequest(order.customer,
                                              order.stored_request)
        customer_serializer = app_settings.CUSTOMER_SERIALIZER(order.customer)
        render_context = {'request': emulated_request, 'render_label': 'email'}
        order_serializer = OrderDetailSerializer(order, context=render_context)
        language = order.stored_request.get('language')
        context = {
            'customer': customer_serializer.data,
            'order': order_serializer.data,
            'ABSOLUTE_BASE_URI':
            emulated_request.build_absolute_uri().rstrip('/'),
            'render_language': language,
        }
        try:
            latest_delivery = order.delivery_set.latest()
            context['latest_delivery'] = DeliverySerializer(
                latest_delivery, context=render_context).data
        except (AttributeError, models.ObjectDoesNotExist):
            pass
        try:
            template = notification.mail_template.translated_templates.get(
                language=language)
        except EmailTemplate.DoesNotExist:
            template = notification.mail_template
        attachments = {}
        for notiatt in notification.notificationattachment_set.all():
            attachments[notiatt.attachment.
                        original_filename] = notiatt.attachment.file.file
        mail.send(recipient,
                  template=template,
                  context=context,
                  attachments=attachments,
                  render_on_delivery=True)
        emails_in_queue = True
    if emails_in_queue:
        email_queued()
示例#46
0
    def handle(self, *args, **options):
        #test = options['test']

        for email, lang in CustomOrder.objects.filter(
                status__gte=CustomOrder.CONFIRMED,
                personal_information_consent=False).values_list(
                    'email', 'language_code').distinct():
            if lang != 'cs':
                # we don't have translated consent, so just skip it
                continue

            hash = email_hash(email)

            text = """Pěkný den,
jsme moc rádi, že podporujete náš projekt dračích kalendářů!
Aby to tak zůstalo, je potřeba, abychom od Vás měli na základě Obecného nařízení o ochraně osobních údajů (GDPR) Váš jednoznačný souhlas se zpracováním Vašich osobních údajů.

Pokud od nás chcete i nadále dostávat informace o nových produktech, slevových akcích a novinkách, potvrďte tento email tlačítkem níže. Tento souhlas bude dán na 20 let a je kdykoli odvolatelný.

<a href="{}" style="font-size: 150%;">ANO, souhlasím</a>

Pokud souhlas nepotvrdíte, přestanete od nás od 25. května dostávat veškeré novinky a všechny Vaše osobní údaje budou u nás vymazána (s výjimkou dat ze zákona požadovaných pro účetnictví).

Jaké Vaše osobní údaje zpracováváme? Jde o jméno, příjmení, adresu, e-mail a IP adresu. Nově máte právo na přístup, opravu a výmaz spravovaných osobních dat, dále právo být zapomenut, právo na omezení zpracování, přenositelnost údajů a v neposlední řadě právo vznést námitku.

Kompletní znění souhlasu se zpracováním osobních údajů najdete <a href="https://kalendar.draci.info/souhlas-s-poskytnutim-osobnich-udaju/">na našem webu</a>.

Nechť Vás draci provází!

Organizační tým projektů Draci.info""".format(
                "https://kalendar.draci.info/gdpr_consent/?email=%s&hash=%s" %
                (email, hash))
            logger.info('Preparing email for %s', email)
            mail.send(
                [email],
                '*****@*****.**',
                template='default_%s' % lang,
                context={
                    'domain':
                    'http://kalendar.draci.info',
                    'subject':
                    'Kalendář Draci.info - souhlas s poskytnutím osobních údajů',
                    'content_html':
                    text.replace('\n', '<br />'),
                    'content_text':
                    re.sub(r'<a href="([^"]*)"[^>]*>([^<]+)</a>',
                           '\\2 \\1 ',
                           text,
                           flags=re.U),
                },
            )
示例#47
0
def send_mail(sender, template, variables, *recipients):
    """
    Single mail send hook that is reused across the project
    """
    try:
        mail.send(
            [recp for recp in recipients],
            sender,
            template=template,
            context=variables,
        )
    except Exception as exp:
        print exp.message
        print traceback.format_exc()
示例#48
0
    def post(self, request, *args, **kwargs):
        email = request.data.get("email", None)
        if email is not None:
            code = verifycodegenerator()
            store = EmailCode.objects.create(code=code)
            mail.send([email],
                      subject="FleaMddarket验证码",
                      priority="medium",
                      message=code)
            sendEmail.delay()
            deleteRow.apply_async((store.pk, ), countdown=600)

            return Response(data=store.pk, status=200)
        return Response(status=400)
示例#49
0
def send_review_thank_you_email(request, item):
    email_to = request.user.email
    if not settings.REAL_EMAILS:
        email_to = settings.TESTING_EMAILS
    from post_office import mail
    context = {}
    context['member'] = request.user.profile.display_name_for_email()
    context['item'] = item
    mail.send(
        email_to,
        'Your African Safari <*****@*****.**>',
        template='review_thank_you',
        context=context,
    )
示例#50
0
def sendFeedback(request):
	if (request.method == 'POST'):
		parsed_json = json.loads(request.body.decode("utf-8"))
		description = UserProfile.objects.get(user_id=parsed_json['id']).description
		mail.send(
		    parsed_json['email'], # List of email addresses also accepted
		    '*****@*****.**',
		    subject=parsed_json['subject'],
		    message=description + "\n" + parsed_json['message'],
		    priority='now'
		)
		return JsonResponse({ 'success': 1 })
	else:
		return redirect('/')
示例#51
0
 def send(self, to, **data):
     """
     This is the method to be called
     """
     self.data = data
     self.get_context()
     if settings.EMAIL_SEND_EMAILS:
         try:
             mail.send(to,
                       template=self.template,
                       context=self.context_data)
         except EmailTemplate.DoesNotExist:
             msg = 'Trying to use a non existent email template {0}'.format(
                 self.template)
             logger.error(msg)
示例#52
0
文件: forms.py 项目: angga30/academy
    def send_email(self, user):
        data = {
            'token': default_token_generator.make_token(user),
            'uid': int_to_base36(user.id),
            'host': settings.HOST,
            'user': user,
            'email_title': 'Lupa kata sandi'
        }

        mail.send([user.email],
                  settings.DEFAULT_FROM_EMAIL,
                  subject='Lupa Kata Sandi',
                  context=data,
                  html_message=render_to_string('emails/forgot_password.html',
                                                context=data))
示例#53
0
文件: models.py 项目: sarutobi/Rynda
def activate_user(user, code):
    """ Checks activation code, activate user and send email notification """

    encoder = UserAuthCode(settings.SECRET_KEY)
    if encoder.is_valid(user, code):
        user.is_active = True
        user.save()
        mail.send([user.email],
                  template="registration complete",
                  context={
                      'user': user,
                      'site': Site.objects.get(),
                  })
        return True
    return False
示例#54
0
    def post(self, request):
        email_to = self.request.data.get('receiver')

        mail.send(
            email_to,  # List of email addresses also accepted
            '*****@*****.**',
            subject='hay',
            message='Welcome home, {{ name }}!',
            html_message='Welcome home, <b>{{ name }}</b>!',
            headers={'Reply-to': '*****@*****.**'},
            # scheduled_time=date(2014, 1, 1),
            context={'name': 'Alice'},
            priority='now',
        )
        return Response(email_to)
示例#55
0
    def send_mail(self):
        User = get_user_model()

        if isinstance(self.sender, User):
            sender = self.sender.email
        elif self.from_address:
            sender = self.from_address
        else:
            sender = settings.DEFAULT_FROM_EMAIL

        if isinstance(self.template_data, str):
            template_data = json.loads(self.template_data)
        else:
            template_data = self.template_data

        try:
            email = mail.send(
                recipients=self.recipients,
                cc=self.cc,
                sender=sender,
                template=self.template_name,
                context=template_data,
                subject=self.subject,  # actually template text
                message=self.text_message,  # actually template text
                html_message=self.html_message,  # actually template text
            )
        except Exception:
            # log an exception, with traceback
            logger.exception('Failed to send mail.')
        else:
            self.sent_recipients = self.recipients + self.cc
            self.sent_email = email
            self.save()
 def send_normal_email(to_email,
                       from_email,
                       context,
                       subject_template_name,
                       email_template_name,
                       attachments={},
                       bcc=list(MODS_EMAILS)):
     subject = render_to_string(subject_template_name, context)
     subject = ''.join(subject.splitlines())
     message = render_to_string(email_template_name, context)
     mail.send(to_email,
               from_email,
               subject=subject,
               html_message=message,
               bcc=bcc,
               attachments=attachments)
def generate_email(sender: str,
                   email_context: RenderedEmailContext,
                   to: Optional[List[str]] = None,
                   cc: Optional[List[str]] = None,
                   bcc: Optional[List[str]] = None,
                   in_reply_to: Optional[InboxMessage] = None) -> post_office_models.Email:
    msg_id = make_msgid(domain=DNS_NAME)  # TODO: try use ZONE from settings or even provider server name

    headers = {
        'Message-ID': msg_id
    }
    if in_reply_to:
        headers['In-Reply-To'] = in_reply_to.message_id
        headers['References'] = in_reply_to.message_id

    return mail.send(commit=False,
                     recipients=to,
                     sender=sender,
                     subject=email_context.subject,
                     message=email_context.message,
                     html_message=email_context.html_message,
                     headers=headers,
                     context=None,
                     cc=cc,
                     bcc=bcc,
                     )
示例#58
0
 def send_verified_email(self):
     subject, from_email, to = "Verifizierung für naklar.io", "*****@*****.**", self.user.email
     d = {
         "user": self.user,
         "login_url": settings.HOST,
     }
     if EmailTemplate.objects.filter(name='tutor_verification').exists():
         mail.send(to, from_email, template='tutor_verification', context=d)
     else:
         text_content = TUTOR_VERIFICATION_PLAINTEXT.render(d)
         html_content = TUTOR_VERIFICATION_HTMLY.render(d)
         mail.send(to,
                   from_email,
                   subject=subject,
                   message=text_content,
                   html_message=html_content)
示例#59
0
def mail_send_gbe(to_list, from_address, template, context, priority='now'):
    if settings.DEBUG:
        to_list = []
        for admin in settings.ADMINS:
            to_list += [admin[1]]

    try:
        mail.send(
            to_list,
            from_address,
            template=template,
            context=context,
            priority=priority,
        )
    except:
        return "EMAIL_SEND_ERROR"
示例#60
0
    def send_notification(self, now=False):
        form = self.form
        ctx = self.get_context()
        priority = None
        if now:
            priority = PRIORITY.now
        emails = []
        for email_template in form.get_email_templates():
            to = email_template.to
            if email_template.is_reply_to_sender:
                to = [self.email]
            if not to:
                continue

            template_attachments = list(email_template.attachments.all())

            if email_template.do_forward_attachments:
                template_attachments += list(self.attachments.all())

            attachments = {}
            if template_attachments:
                for a in template_attachments:
                    attachments[a.get_filename()] = a.file

            email = mail.send(recipients=to,
                              sender=email_template.from_email or None,
                              bcc=email_template.bcc,
                              cc=email_template.cc,
                              template=email_template.email_template,
                              context=ctx,
                              priority=priority,
                              attachments=attachments or {})
            emails.append(email)
        return emails