### Navigation

- index
- modules
- toc
- jmb.core 0.8.6 documentation »
- Module code »

# Source code for jmb.core.views.odt

    # -*- coding: utf-8 -*-
    """
    .. _class-based-odt:

    OdtTemplateView
    ================

    these views are Class Views implementation that return a response to serve
    ``pdf``, ``odt`` or ``ods`` files. It's pretty easy to create a view that
    is :ref:`not class based <appypod>` so I'm not stating this is really needed,
    but you may prefere this approach.

    variants
    --------

    :|PdfTemplateView|: return a Pdf object

    :|OdtTemplateView|: return a Odt object

    :|OdsTemplateView|: return a Ods object

    examples
    --------

    A simple example:

    .. code-block:: python

      class MyPdfTemplateView(PdfTemplateView):
          template_name = app_label/template.odt

      class MyOdtTemplateView(PdfTemplateView):
          template_name = app_label/template.odt

      urlpatterns = patterns('',
           url(r'^pdf/(?P<slug>[a-zA-Z-]+)/$', MyPdfTemplateView.as_view(),  name='pdf_detail')
           url(r'^odt/(?P<slug>[a-zA-Z-]+)/$', MyOdtTemplateView.as_view(),  name='odt_detail')
      )

    debug
    -----

    Since it's pretty standard to create the .odt template via try and fix
    you can create a method named debug_template to step into and just lanch
    creation of the file w/o recreating the context::

      def debug_template(self, template, context):
            template.save_as('/tmp/output.odt', context=context)
            import ipdb; ipdb.set_trace()

    API
    ---

    .. autoclass:: OdtTemplateResponseMixin
       :members:

    .. autoclass:: PdfTemplateView
       :members:

    .. autoclass:: OdtTemplateView

    .. autoclass:: OdsTemplateView

    .. |PdfTemplateView| replace:: :class:`PdfTemplateView`
    .. |OdtTemplateView| replace:: :class:`OdtTemplateView`
    .. |OdsTemplateView| replace:: :class:`OdsTemplateView`

    """
    import os
    import copy

    from django.views.generic.base import TemplateResponseMixin, ContextMixin, View
    from django.http import HttpResponse

    from jmb.core.utils.appypod import AppyPodTemplate

    class OdtTemplateResponseMixin(TemplateResponseMixin):

        """
        A mixin class that implements Odt rendering and Django response construction.
        """

        #: Type of the output; used to set content-type appropriately
        output_type = None

        #: forces use of openoffice even if the output is and odt file (passed to appyod render)
        forceOoCall = False

        #: Boolean. Add 'attachment;' to Content-Disposition so that a popup queringwhat to do
        #: is triggerend rather that in-browser representation
        attachment = False

        @property
        def output_filename(self):
            return "%s.%s" % (os.path.splitext(os.path.basename(self.template_name))[0],
                              self.output_type)

        def get_template_names(self):
            """
            Return the template names (string or list)
            """
            return self.template_name

        def get_output_filename(self):
            """
            Returns :attr:`pdf_filename` value by default.

            If left blank the browser will display the Odt inline.
            Otherwise it will pop up the "Save as.." dialog.

            :rtype: :func:`str`
            """
            return self.output_filename

        def get_mime_type(self, output_type='pdf'):
            return {
                'pdf': 'application/pdf',
                'odt': 'application/vnd.oasis.opendocument.text',
                'ods': 'application/vnd.oasis.opendocument.spreadsheet',
            }[output_type]

        def get_response(self, context, **response_kwargs):
            """
            Renders Odt document and prepares response.

            :arg context: the context
            :arg response_kwargs: received from :meth:`render_to_response`
            :returns: a rendered template (.pdf, .odt or .ods document)
            """
            template = AppyPodTemplate(self.get_template_names())
            try:
                self.debug_template(template, context)
            except AttributeError:
                pass

            return template.render(
                file_type=self.output_type,
                context=context,
                forceOoCall=self.forceOoCall
            )

        def render_to_response(self, context, **response_kwargs):
            """
            Return a rendered template as an HttpRespons
            :rtype: :class:`django.http.HttpResponse`
            """
            response = HttpResponse(
                self.get_response(context, **response_kwargs),
                content_type=self.get_mime_type(self.output_type),
            )
            output_filename = self.get_output_filename()
            if output_filename:
                response['Content-Disposition'] = '%sfilename="%s"' % (
                    self.attachment and 'attachment; ' or '', output_filename
                )

            return response

    class PdfTemplateView(OdtTemplateResponseMixin, ContextMixin, View):

        """
        Concrete view for serving Pdf files.
        """
        output_type = 'pdf'

        def get(self, request, *args, **kwargs):
            """
            Handles GET request and returns HTTP response.
            """
            context = self.get_context_data(**kwargs)
            return self.render_to_response(context)

    class OdtTemplateView(PdfTemplateView):

        """
        Concrete view for serving Odt files.
        """
        output_type = 'odt'

    class OdsTemplateView(PdfTemplateView):

        """
        Concrete view for serving Ods files.
        """
        output_type = 'ods'

### Navigation

- index
- modules
- toc
- jmb.core 0.8.6 documentation »
- Module code »