Exemplo n.º 1
0
    def post(self, request, *args, **kwargs):
        application = get_object_or_404(Application, pk=self.args[0])

        original_issue_date = None
        if application.licence is not None:
            issue_licence_form = IssueLicenceForm(request.POST, instance=application.licence)
            original_issue_date = application.licence.issue_date
        else:
            issue_licence_form = IssueLicenceForm(request.POST)

        if issue_licence_form.is_valid():
            licence = issue_licence_form.save(commit=False)
            licence.licence_type = application.licence_type
            licence.profile = application.applicant_profile
            licence.holder = application.applicant_profile.user
            licence.issuer = request.user

            if application.previous_application is not None:
                licence.licence_number = application.previous_application.licence.licence_number

                # if licence is renewal, want to use previous licence's sequence number
                if licence.licence_sequence == 0:
                    licence.licence_sequence = application.previous_application.licence.licence_sequence

            if not licence.licence_number:
                licence.save(no_revision=True)
                licence.licence_number = '%s-%s' % (str(licence.licence_type.pk).zfill(LICENCE_TYPE_NUM_CHARS),
                                                    str(licence.id).zfill(LICENCE_NUMBER_NUM_CHARS))

            licence.licence_sequence += 1

            licence_filename = 'licence-%s-%d.pdf' % (licence.licence_number, licence.licence_sequence)

            licence.licence_document = create_licence_pdf_document(licence_filename, licence, application,
                                                                   request.build_absolute_uri(reverse('home')),
                                                                   original_issue_date)

            cover_letter_filename = 'cover-letter-%s-%d.pdf' % (licence.licence_number, licence.licence_sequence)

            licence.cover_letter_document = create_cover_letter_pdf_document(cover_letter_filename, licence,
                                                                             request.build_absolute_uri(reverse('home')))

            licence.save()

            licence_issued.send(sender=self.__class__, wildlife_licence=licence)

            application.customer_status = 'approved'
            application.processing_status = 'issued'
            application.licence = licence

            application.save()

            # The licence should be emailed to the customer if they applied for it online. If an officer entered
            # the application on their behalf, the licence needs to be posted to the user, although if they provided
            # an email address in their offline application, they should receive the licence both via email and in the
            # post
            if application.proxy_applicant is None:
                # customer applied online
                messages.success(request, 'The licence has now been issued and sent as an email attachment to the '
                                 'licencee.')
                send_licence_issued_email(licence, application, request)
            elif not application.applicant_profile.user.is_dummy_user:
                # customer applied offline but provided an email address
                messages.success(request, 'The licence has now been issued and sent as an email attachment to the '
                                 'licencee. However, as the application was entered on behalf of the licencee by '
                                 'staff, it should also be posted to the licencee. Click this link to show '
                                 'the licence <a href="{0}" target="_blank">Licence PDF</a><img height="20px" '
                                 'src="{1}"></img> and this link to show the cover letter <a href="{2}" target="_blank">'
                                 'Cover Letter PDF</a><img height="20px" src="{3}"></img>'.
                                 format(licence.licence_document.file.url, static('wl/img/pdf.png'),
                                        licence.cover_letter_document.file.url, static('wl/img/pdf.png')))
                send_licence_issued_email(licence, application, request)
            else:
                # customer applied offline and did not provide an email address
                messages.success(request, 'The licence has now been issued and must be posted to the licencee. Click '
                                 'this link to show the licence <a href="{0}" target="_blank">Licence PDF'
                                 '</a><img height="20px" src="{1}"></img> and this link to show the cover letter '
                                 '<a href="{2}" target="_blank">Cover Letter PDF</a><img height="20px" src="{3}">'
                                 '</img>'.format(licence.licence_document.file.url, static('wl/img/pdf.png'),
                                                 licence.cover_letter_document.file.url, static('wl/img/pdf.png')))

            return redirect('dashboard:home')
        else:
            messages.error(request, issue_licence_form.errors)

            purposes = '\n\n'.join(Assessment.objects.filter(application=application).values_list('purpose', flat=True))

            return render(request, self.template_name, {'application': serialize(application, posthook=format_application),
                                                        'issue_licence_form': IssueLicenceForm(purpose=purposes)})
Exemplo n.º 2
0
    def _issue_licence(self, request, application, issue_licence_form):
        # do credit card payment if required
        payment_status = payment_utils.PAYMENT_STATUSES.get(
            payment_utils.get_application_payment_status(application))

        if payment_status == payment_utils.PAYMENT_STATUS_AWAITING:
            raise PaymentException(
                'Payment is required before licence can be issued')
        elif payment_status == payment_utils.PAYMENT_STATUSES.get(
                payment_utils.PAYMENT_STATUS_CC_READY):
            payment_utils.invoke_credit_card_payment(application)

        licence = application.licence

        licence.issuer = request.user

        previous_licence = None
        if application.previous_application is not None:
            previous_licence = application.previous_application.licence
            licence.licence_number = previous_licence.licence_number

            # if licence is renewal, start with previous licence's sequence number
            if licence.licence_sequence == 0:
                licence.licence_sequence = previous_licence.licence_sequence

        if not licence.licence_number:
            licence.save(no_revision=True)
            licence.licence_number = '%s-%s' % (
                str(licence.licence_type.pk).zfill(LICENCE_TYPE_NUM_CHARS),
                str(licence.id).zfill(LICENCE_NUMBER_NUM_CHARS))

        # for re-issuing
        original_issue_date = application.licence.issue_date if application.licence.is_issued else None

        licence.licence_sequence += 1

        licence.issue_date = date.today()

        # reset renewal_sent flag in case of reissue
        licence.renewal_sent = False

        licence_filename = 'licence-%s-%d.pdf' % (licence.licence_number,
                                                  licence.licence_sequence)

        cover_letter_filename = 'cover-letter-%s-%d.pdf' % (
            licence.licence_number, licence.licence_sequence)

        licence.cover_letter_document = create_cover_letter_pdf_document(
            cover_letter_filename, licence,
            request.build_absolute_uri(reverse('home')))

        licence.save()

        if previous_licence is not None:
            previous_licence.replaced_by = licence
            previous_licence.save()

        licence_issued.send(sender=self.__class__, wildlife_licence=licence)

        # update statuses
        application.customer_status = 'approved'
        application.processing_status = 'issued'
        Assessment.objects.filter(application=application, status='awaiting_assessment').\
            update(status='assessment_expired')

        application.save()

        # The licence should be emailed to the customer if they applied for it online. If an officer entered
        # the application on their behalf, the licence needs to be posted to the user.

        # CC's and attachments
        # Rules for emails:
        #  If application lodged by proxy officer and there's a CC list: send email to CCs (to recipients = CCs)
        #  else send the email to customer and if there are CCs put them into the bccs of the email
        ccs = None
        if 'ccs' in issue_licence_form.cleaned_data and issue_licence_form.cleaned_data[
                'ccs']:
            ccs = re.split('[,;]', issue_licence_form.cleaned_data['ccs'])
        attachments = []
        if request.FILES and 'attachments' in request.FILES:
            for _file in request.FILES.getlist('attachments'):
                doc = Document.objects.create(file=_file, name=_file.name)
                attachments.append(doc)

        # Merge documents
        if attachments and not isinstance(attachments, list):
            attachments = list(attachments)

        current_attachment = create_licence_pdf_document(
            licence_filename, licence, application, settings.WL_PDF_URL,
            original_issue_date)
        if attachments:
            other_attachments = []
            pdf_attachments = []
            merger = PdfFileMerger()
            merger.append(PdfFileReader(current_attachment.file.path))
            for a in attachments:
                if a.file.name.endswith('.pdf'):
                    merger.append(PdfFileReader(a.file.path))
                else:
                    other_attachments.append(a)
            output = BytesIO()
            merger.write(output)
            # Delete old document
            current_attachment.delete()
            # Attach new document
            new_doc = Document.objects.create(name=licence_filename)
            new_doc.file.save(licence_filename, File(output), save=True)
            licence.licence_document = new_doc
            licence.save()
            output.close()
        else:
            licence.licence_document = current_attachment
            licence.save()

        # check we have an email address to send to
        if licence.profile.email and not licence.profile.user.is_dummy_user:
            to = [licence.profile.email]
            messages.success(
                request,
                'The licence has now been issued and sent as an email attachment to the '
                'licencee: {}.'.format(licence.profile.email))
            send_licence_issued_email(licence,
                                      application,
                                      request,
                                      to=to,
                                      bcc=ccs,
                                      additional_attachments=attachments)
        else:
            # no email
            messages.success(
                request,
                'The licence has now been issued and must be posted to the licencee. Click '
                'this link to show the licence <a href="{0}" target="_blank">Licence PDF'
                '</a><img height="20px" src="{1}"></img> and this link to show the cover letter '
                '<a href="{2}" target="_blank">Cover Letter PDF</a><img height="20px" src="{3}">'
                '</img>'.format(licence.licence_document.file.url,
                                static('wl/img/pdf.png'),
                                licence.cover_letter_document.file.url,
                                static('wl/img/pdf.png')))
            if ccs:
                send_licence_issued_email(licence,
                                          application,
                                          request,
                                          to=ccs,
                                          additional_attachments=attachments)

        application.log_user_action(
            ApplicationUserAction.ACTION_ISSUE_LICENCE_.format(licence),
            request)
Exemplo n.º 3
0
    def post(self, request, *args, **kwargs):
        application = get_object_or_404(Application, pk=self.args[0])

        payment_status = payment_utils.get_application_payment_status(
            application)

        if payment_status == payment_utils.PAYMENT_STATUS_AWAITING:
            messages.error(request,
                           'Payment is required before licence can be issued')

            return redirect(request.get_full_path())

        # do credit card payment if required
        if payment_status == payment_utils.PAYMENT_STATUS_CC_READY:
            payment_utils.invoke_credit_card_payment(application)

        original_issue_date = None
        if application.licence is not None:
            issue_licence_form = IssueLicenceForm(request.POST,
                                                  instance=application.licence,
                                                  files=request.FILES)
            original_issue_date = application.licence.issue_date
        else:
            issue_licence_form = IssueLicenceForm(request.POST,
                                                  files=request.FILES)

        if issue_licence_form.is_valid():
            licence = issue_licence_form.save(commit=False)

            licence.licence_type = application.licence_type

            licence.profile = application.applicant_profile
            licence.holder = application.applicant
            licence.issuer = request.user

            if application.previous_application is not None:
                licence.licence_number = application.previous_application.licence.licence_number

                # if licence is renewal, use previous licence's sequence number
                if licence.licence_sequence == 0:
                    licence.licence_sequence = application.previous_application.licence.licence_sequence

            if not licence.licence_number:
                licence.save(no_revision=True)
                licence.licence_number = '%s-%s' % (
                    str(licence.licence_type.pk).zfill(LICENCE_TYPE_NUM_CHARS),
                    str(licence.id).zfill(LICENCE_NUMBER_NUM_CHARS))

            licence.licence_sequence += 1

            licence_filename = 'licence-%s-%d.pdf' % (licence.licence_number,
                                                      licence.licence_sequence)

            licence.licence_document = create_licence_pdf_document(
                licence_filename, licence, application,
                request.build_absolute_uri(reverse('home')),
                original_issue_date)

            cover_letter_filename = 'cover-letter-%s-%d.pdf' % (
                licence.licence_number, licence.licence_sequence)

            licence.cover_letter_document = create_cover_letter_pdf_document(
                cover_letter_filename, licence,
                request.build_absolute_uri(reverse('home')))

            licence.save()

            licence.variants.clear()
            for index, avl in enumerate(
                    application.variants.through.objects.all().order_by(
                        'order')):
                WildlifeLicenceVariantLink.objects.create(licence=licence,
                                                          variant=avl.variant,
                                                          order=index)

            issue_licence_form.save_m2m()

            licence_issued.send(sender=self.__class__,
                                wildlife_licence=licence)

            application.customer_status = 'approved'
            application.processing_status = 'issued'
            application.licence = licence

            application.save()

            # The licence should be emailed to the customer if they applied for it online. If an officer entered
            # the application on their behalf, the licence needs to be posted to the user.

            # CC's and attachments
            # Rules for emails:
            #  If application lodged by proxy officer and there's a CC list: send email to CCs (to recipients = CCs)
            #  else send the email to customer and if there are CCs put them into the bccs of the email
            ccs = None
            if 'ccs' in issue_licence_form.cleaned_data and issue_licence_form.cleaned_data[
                    'ccs']:
                ccs = re.split('[,;]', issue_licence_form.cleaned_data['ccs'])
            attachments = []
            if request.FILES and 'attachments' in request.FILES:
                for _file in request.FILES.getlist('attachments'):
                    doc = Document.objects.create(file=_file, name=_file.name)
                    attachments.append(doc)
            if application.proxy_applicant is None:
                # customer applied online
                messages.success(
                    request,
                    'The licence has now been issued and sent as an email attachment to the '
                    'licencee.')
                send_licence_issued_email(licence,
                                          application,
                                          request,
                                          bcc=ccs,
                                          additional_attachments=attachments)
            else:
                # customer applied offline
                messages.success(
                    request,
                    'The licence has now been issued and must be posted to the licencee. Click '
                    'this link to show the licence <a href="{0}" target="_blank">Licence PDF'
                    '</a><img height="20px" src="{1}"></img> and this link to show the cover letter '
                    '<a href="{2}" target="_blank">Cover Letter PDF</a><img height="20px" src="{3}">'
                    '</img>'.format(licence.licence_document.file.url,
                                    static('wl/img/pdf.png'),
                                    licence.cover_letter_document.file.url,
                                    static('wl/img/pdf.png')))

            if ccs:
                send_licence_issued_email(licence,
                                          application,
                                          request,
                                          to=ccs,
                                          additional_attachments=attachments)
            return redirect('wl_dashboard:home')
        else:
            messages.error(request, issue_licence_form.errors)

            log_entry_form = ApplicationLogEntryForm(
                to=get_log_entry_to(application),
                fromm=self.request.user.get_full_name())

            return render(
                request, self.template_name, {
                    'application':
                    serialize(application, posthook=format_application),
                    'issue_licence_form':
                    issue_licence_form,
                    'log_entry_form':
                    log_entry_form
                })
Exemplo n.º 4
0
    def _issue_licence(self, request, application, issue_licence_form):
        # do credit card payment if required
        payment_status = payment_utils.PAYMENT_STATUSES.get(payment_utils.get_application_payment_status(application))

        if payment_status == payment_utils.PAYMENT_STATUS_AWAITING:
            raise PaymentException('Payment is required before licence can be issued')
        elif payment_status == payment_utils.PAYMENT_STATUSES.get(payment_utils.PAYMENT_STATUS_CC_READY):
            payment_utils.invoke_credit_card_payment(application)

        licence = application.licence

        licence.issuer = request.user

        previous_licence = None
        if application.previous_application is not None:
            previous_licence = application.previous_application.licence
            licence.licence_number = previous_licence.licence_number

            # if licence is renewal, start with previous licence's sequence number
            if licence.licence_sequence == 0:
                licence.licence_sequence = previous_licence.licence_sequence

        if not licence.licence_number:
            licence.save(no_revision=True)
            licence.licence_number = '%s-%s' % (str(licence.licence_type.pk).zfill(LICENCE_TYPE_NUM_CHARS),
                                                str(licence.id).zfill(LICENCE_NUMBER_NUM_CHARS))

        # for re-issuing
        original_issue_date = application.licence.issue_date if application.licence.is_issued else None

        licence.licence_sequence += 1

        licence.issue_date = date.today()

        # reset renewal_sent flag in case of reissue
        licence.renewal_sent = False

        licence_filename = 'licence-%s-%d.pdf' % (licence.licence_number, licence.licence_sequence)


        cover_letter_filename = 'cover-letter-%s-%d.pdf' % (licence.licence_number, licence.licence_sequence)

        licence.cover_letter_document = create_cover_letter_pdf_document(cover_letter_filename, licence,
                                                                         request.build_absolute_uri(reverse('home')))

        licence.save()

        if previous_licence is not None:
            previous_licence.replaced_by = licence
            previous_licence.save()

        licence_issued.send(sender=self.__class__, wildlife_licence=licence)

        # update statuses
        application.customer_status = 'approved'
        application.processing_status = 'issued'
        Assessment.objects.filter(application=application, status='awaiting_assessment').\
            update(status='assessment_expired')

        application.save()

        # The licence should be emailed to the customer if they applied for it online. If an officer entered
        # the application on their behalf, the licence needs to be posted to the user.

        # CC's and attachments
        # Rules for emails:
        #  If application lodged by proxy officer and there's a CC list: send email to CCs (to recipients = CCs)
        #  else send the email to customer and if there are CCs put them into the bccs of the email
        ccs = None
        if 'ccs' in issue_licence_form.cleaned_data and issue_licence_form.cleaned_data['ccs']:
            ccs = re.split('[,;]', issue_licence_form.cleaned_data['ccs'])
        attachments = []
        if request.FILES and 'attachments' in request.FILES:
            for _file in request.FILES.getlist('attachments'):
                doc = Document.objects.create(file=_file, name=_file.name)
                attachments.append(doc)

        # Merge documents
        if attachments and not isinstance(attachments, list):
            attachments = list(attachments)

        current_attachment = create_licence_pdf_document(licence_filename, licence, application,
                                                           settings.WL_PDF_URL,
                                                           original_issue_date)
        if attachments:
            other_attachments = []
            pdf_attachments = []
            merger = PdfFileMerger()
            merger.append(PdfFileReader(current_attachment.file.path))
            for a in attachments:
                if a.file.name.endswith('.pdf'):
                    merger.append(PdfFileReader(a.file.path))
                else:
                    other_attachments.append(a)
            output = BytesIO()
            merger.write(output)
            # Delete old document
            current_attachment.delete()
            # Attach new document
            new_doc = Document.objects.create(name=licence_filename)
            new_doc.file.save(licence_filename, File(output), save=True)
            licence.licence_document = new_doc
            licence.save()
            output.close()
        else:
            licence.licence_document = current_attachment
            licence.save()

        # check we have an email address to send to
        if licence.profile.email and not licence.profile.user.is_dummy_user:
            to = [licence.profile.email]
            messages.success(request, 'The licence has now been issued and sent as an email attachment to the '
                             'licencee: {}.'.format(licence.profile.email))
            send_licence_issued_email(licence, application, request,
                                      to=to,
                                      bcc=ccs, additional_attachments=attachments)
        else:
            # no email
            messages.success(request, 'The licence has now been issued and must be posted to the licencee. Click '
                             'this link to show the licence <a href="{0}" target="_blank">Licence PDF'
                             '</a><img height="20px" src="{1}"></img> and this link to show the cover letter '
                             '<a href="{2}" target="_blank">Cover Letter PDF</a><img height="20px" src="{3}">'
                             '</img>'.format(licence.licence_document.file.url, static('wl/img/pdf.png'),
                                             licence.cover_letter_document.file.url, static('wl/img/pdf.png')))
            if ccs:
                send_licence_issued_email(licence, application, request, to=ccs, additional_attachments=attachments)

        application.log_user_action(
            ApplicationUserAction.ACTION_ISSUE_LICENCE_.format(licence),
            request
        )
Exemplo n.º 5
0
    def post(self, request, *args, **kwargs):
        application = get_object_or_404(Application, pk=self.args[0])

        payment_status = payment_utils.get_application_payment_status(application)

        if payment_status == payment_utils.PAYMENT_STATUS_AWAITING:
            messages.error(request, 'Payment is required before licence can be issued')

            return redirect(request.get_full_path())

        original_issue_date = None
        if application.licence is not None:
            issue_licence_form = IssueLicenceForm(request.POST, instance=application.licence, files=request.FILES)
            original_issue_date = application.licence.issue_date
            extracted_fields = application.licence.extracted_fields
        else:
            issue_licence_form = IssueLicenceForm(request.POST, files=request.FILES)
            extracted_fields = extract_licence_fields(application.licence_type.application_schema, application.data)

        # update contents of extracted field based on posted data
        extracted_fields = update_licence_fields(extracted_fields, request.POST)

        if issue_licence_form.is_valid():
            licence = issue_licence_form.save(commit=False)

            licence.licence_type = application.licence_type

            licence.profile = application.applicant_profile
            licence.holder = application.applicant
            licence.issuer = request.user

            previous_licence = None
            if application.previous_application is not None:
                previous_licence = application.previous_application.licence
                licence.licence_number = previous_licence.licence_number

                # if licence is renewal, start with previous licence's sequence number
                if licence.licence_sequence == 0:
                    licence.licence_sequence = previous_licence.licence_sequence

            if not licence.licence_number:
                licence.save(no_revision=True)
                licence.licence_number = '%s-%s' % (str(licence.licence_type.pk).zfill(LICENCE_TYPE_NUM_CHARS),
                                                    str(licence.id).zfill(LICENCE_NUMBER_NUM_CHARS))

            licence.licence_sequence += 1

            licence.extracted_fields = extracted_fields

            # reset renewal_sent flag in case of reissue
            licence.renewal_sent = False

            licence_filename = 'licence-%s-%d.pdf' % (licence.licence_number, licence.licence_sequence)

            licence.licence_document = create_licence_pdf_document(licence_filename, licence, application,
                                                                   request.build_absolute_uri(reverse('home')),
                                                                   original_issue_date)

            cover_letter_filename = 'cover-letter-%s-%d.pdf' % (licence.licence_number, licence.licence_sequence)

            licence.cover_letter_document = create_cover_letter_pdf_document(cover_letter_filename, licence,
                                                                             request.build_absolute_uri(reverse('home')))

            licence.save()

            if previous_licence is not None:
                previous_licence.replaced_by = licence
                previous_licence.save()

            licence.variants.clear()
            for index, avl in enumerate(application.variants.through.objects.all().order_by('order')):
                WildlifeLicenceVariantLink.objects.create(licence=licence, variant=avl.variant, order=index)

            issue_licence_form.save_m2m()

            licence_issued.send(sender=self.__class__, wildlife_licence=licence)

            application.customer_status = 'approved'
            application.processing_status = 'issued'
            application.licence = licence

            application.save()

            application.log_user_action(
                ApplicationUserAction.ACTION_ISSUE_LICENCE_.format(licence),
                request
            )

            # do credit card payment if required
            if payment_status == payment_utils.PAYMENT_STATUS_CC_READY:
                payment_utils.invoke_credit_card_payment(application)

            # The licence should be emailed to the customer if they applied for it online. If an officer entered
            # the application on their behalf, the licence needs to be posted to the user.

            # CC's and attachments
            # Rules for emails:
            #  If application lodged by proxy officer and there's a CC list: send email to CCs (to recipients = CCs)
            #  else send the email to customer and if there are CCs put them into the bccs of the email
            ccs = None
            if 'ccs' in issue_licence_form.cleaned_data and issue_licence_form.cleaned_data['ccs']:
                ccs = re.split('[,;]', issue_licence_form.cleaned_data['ccs'])
            attachments = []
            if request.FILES and 'attachments' in request.FILES:
                for _file in request.FILES.getlist('attachments'):
                    doc = Document.objects.create(file=_file, name=_file.name)
                    attachments.append(doc)
            if application.proxy_applicant is None:
                # customer applied online
                messages.success(request, 'The licence has now been issued and sent as an email attachment to the '
                                 'licencee.')
                send_licence_issued_email(licence, application, request, bcc=ccs, additional_attachments=attachments)
            else:
                # customer applied offline
                messages.success(request, 'The licence has now been issued and must be posted to the licencee. Click '
                                 'this link to show the licence <a href="{0}" target="_blank">Licence PDF'
                                 '</a><img height="20px" src="{1}"></img> and this link to show the cover letter '
                                 '<a href="{2}" target="_blank">Cover Letter PDF</a><img height="20px" src="{3}">'
                                 '</img>'.format(licence.licence_document.file.url, static('wl/img/pdf.png'),
                                                 licence.cover_letter_document.file.url, static('wl/img/pdf.png')))
                if ccs:
                    send_licence_issued_email(licence, application, request, to=ccs, additional_attachments=attachments)
            return redirect('wl_dashboard:home')
        else:
            messages.error(request, issue_licence_form.errors)

            log_entry_form = ApplicationLogEntryForm(to=get_log_entry_to(application), fromm=self.request.user.get_full_name())

            payment_status = payment_utils.PAYMENT_STATUSES.get(payment_utils.get_application_payment_status(application))

            return render(request, self.template_name, {'application': serialize(application, posthook=format_application),
                                                        'issue_licence_form': issue_licence_form,
                                                        'extracted_fields': extracted_fields,
                                                        'payment_status': payment_status,
                                                        'log_entry_form': log_entry_form})