1

# coding: utf-8

     2

"""

     3

    Generic controller base classes.

     4

     5

    respond(Request) -> Response

     6

"""

     7

     8

import werkzeug

     9

from werkzeug import Response

    10

    15

    16

class AppHandler (object):

    17

    """

    18

        Per-request handler type, containing the request context and implementing the response.

    19

    20

        Works on a generic level, i.e. WSGI/Werkzeug URL-mapped request in, response out.

    21

    """

    22

    23

    def __init__ (self, app, request, urlmap) :

    24

        """

    25

            Initialize for processing the given Request, to prepare for action-method later on

    26

    27

                app     - the global Application state

    28

                request - the request state

    29

                urlmap  - the URL map we were matched through

    30

        """

    31

    32

        self.app = app

    33

        self.request = request

    34

        self.urlmap = urlmap

    35

    36

    def url_for (self, endpoint, fragment=None, **values) :

    37

        """

    38

            Return an URL for the given endpoint, applying the given URL-embedded values

    39

    40

                endpoint            - endpoint mapped in svv.urls to target

    41

                fragment            - (optional) #fragment to add to URL

    42

                **values            - url-values for mapped endpoint

    43

        """

    44

    45

        url = self.urlmap.build(endpoint, values)

    46

    47

        if fragment :

    48

            # XXX: encode

    49

            url += '#' + fragment

    50

    51

        return url

    52

    53

    def redirect_for (self, endpoint, **values) :

    54

        """

    55

            Return a Response that will redirect the client to the given endpoint.

    56

        """

    57

    58

        return werkzeug.redirect(self.url_for(endpoint, **values))

    59

    60

    @property

    61

    def POST (self) :

    62

        """

    63

            Access request's POST data

    64

        """

    65

    66

        # MultiDict from werkzeug.Request

    67

        return self.request.form

    68

    69

    def respond (self, **url_values) :

    70

        """

    71

            Handle request that was mapped to ourselves via the URL routing, using given dict of values from URL.

    72

        """

    73

    74

        # process e.g. POST data for e.g. redirect

    75

        response = self.process(**url_values)

    76

    77

        if not response :

    78

            # assume superclass does something else if process didn't handle it

    79

            pass

    80

    81

        return response

    82

    83

    def process (self, **args) :

    84

        """

    85

            Process incoming POST data, optionally returning a redirect response.

    86

        """

    87

    88

        # default to ignore

    89

        pass

    90

    91

class PageHandler (AppHandler) :

    92

    """

    93

        Specialized AppHandler for normal HTML page views.

    94

    95

        Renders the layout template and HTML.

    96

    """

   184

   185

    def render_content (self, **args) :

   186

        """

   187

            Render and return HTML for page content.

   188

   189

            XXX: must be HTML object, support just text?

   190

        """

   191

   192

        raise NotImplementedError()

   193

   194

    def render_layout (self, content) :

   195

        """

   196

            Render the page layout for the given content block.

   197

        """

   198

   199

        # XXX: layout template, should be somewhere far away

   201

        css = [

   202

                "/static/layout.css", 

   203

                "/static/style.css", 

   204

                "/static/forms.css",

   205

                "/static/tables.css",

   206

                "/static/cal.css",

   207

   208

                "/static/treelist.css",

   209

   210

                "/static/jquery-ui.theme/jquery-ui.css",

   211

        ]

   212

        scripts = [

   213

                "/static/js/jquery.js",

   214

                "/static/js/jquery-ui.min.js",  # fairly big

   215

                "/static/js/jquery-ui-timepicker.js",

   216

                "/static/js/jquery-ui-datepicker-fi.js",

   217

   218

                "/static/js/forms.js",

   219

   220

                #"/static/js/prototype.js", 

   221

                #"/static/js/scriptaculous/scriptaculous.js", 

   222

                #"/static/js/treelist.js"

   223

        ]

   224

   266

        )

   267

   268

    def render (self, **url_values) :

   269

        """

   270

            Render full page HTML

   271

        """

   272

   273

        # render page content

   274

        content = self.render_content(**url_values)

   275

   276

        # render into layout

   277

        response = self.render_layout(content)

   278

   279

        # ok

   280

        return response

   281

   282

    def respond (self, **url_values) :

   283

        """

   284

            Build and return a response from the following steps:

   285

   286

            * process() 

   287

            * render() -> render_content() as HTML

   288

        """

   289

   290

        # optional processing

   291

        response = super(PageHandler, self).respond(**url_values)

   292

   293

        if not response :

   296

   297

            # response object

   299

            return Response(html, mimetype='text/html')

   300

   301

        # ok

   302

        return response

   303

   304

class DocumentHandler (AppHandler) :

   305

    """

   306

        PDF generation/export

   307

    """

   308

   309

    def respond (self, **url_values) :

   310

        """

   311

            Generate the document, and return it as a .pdf file, with the filename generated from the document's title.

   312

        """

   313

   314

        # optional processing

   315

        response = super(DocumentHandler, self).respond(**url_values)

   316

   317

        if not response :

   318

            pdf_file = self.generate(**url_values)

   319

   320

            # file wrapper

   321

            # XXX: is this any use at all for StringIO?

   322

            pdf_file = werkzeug.wrap_file(self.request.environ, pdf_file)

   323

   324

            # respond with file wrapper

   325

            response = Response(pdf_file, mimetype='application/pdf', direct_passthrough=True)

   326

   327

        # ok

   328

        return response

   329

   330

    def generate (self, **url_values) :

   331

        """

   332

            Generate the PDF document as a file-like object.

   333

        """

   334

   335

        document, elements = self.generate_document(**url_values)

   336

   337

        # render and return StringIO

   338

        return document.render_buf(elements)

   339

   340

    def generate_document (self, **url_values) :

   341

        """

   342

            Return the

   343

                (DocumentTemplate, elements)

   344

            to generate the PDF document from.

   345

        """

   346

   347

        raise NotImplementedError()

   348

   349

### XXX: random test controllers

   350

   351

class Index (PageHandler) :

   352

    DATA = (

   353

        (100, "Top A", []),

   354

        (200, "Top B", [

   355

            (210, "Mid BA", [

   356

                (211, "Sub BAA", []),

   357

                (212, "Sub BAB", []),

   358

            ]),

   359

            (220, "Mid BB", []),

   360

        ]),

   361

        (300, "Top C", [

   362

            (310, "Mid CA", []),

   363

            (320, "Mid CB", []),

   364

        ]),

   365

    )

   366

   367

    def render_content (self) :

   368

        # build data set

   369

        data = self.DATA

   370

   371

        def render_item (id, text, children) :

   374

                    # item text

   376

                        'checked' if self.request.form.get(str(id)) else None

   377

                    )), text, class_='text'),

   378

                ),

   379

   380

                # children

   382

   383

                # 

   384

                class_=('more open' if children else None),

   385

            )

   386

   387

        # XXX: nothing much to see here

   389

   390

        # render it

   391

        return (

   396

            ),

   397

        )

   398

   399

   400