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

    11

from svv import html, pdf

    12

from svv.html import tags

    13

    14

class AppHandler (object):

    15

    """

    16

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

    17

    18

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

    19

    """

    20

    21

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

    22

        """

    23

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

    24

    25

                app     - the global Application state

    26

                request - the request state

    27

                urlmap  - the URL map we were matched through

    28

        """

    29

    30

        self.app = app

    31

        self.request = request

    32

        self.urlmap = urlmap

    33

    34

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

    35

        """

    36

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

    37

    38

                endpoint            - endpoint mapped in svv.urls to target

    39

                fragment            - (optional) #fragment to add to URL

    40

                **values            - url-values for mapped endpoint

    41

        """

    42

    43

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

    44

    45

        if fragment :

    46

            # XXX: encode

    47

            url += '#' + fragment

    48

    49

        return url

    50

    51

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

    52

        """

    53

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

    54

        """

    55

    56

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

    57

    58

    @property

    59

    def POST (self) :

    60

        """

    61

            Access request's POST data

    62

        """

    63

    64

        # MultiDict from werkzeug.Request

    65

        return self.request.form

    66

    67

    def respond (self, **url_values) :

    68

        """

    69

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

    70

        """

    71

    72

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

    73

        response = self.process(**url_values)

    74

    75

        if not response :

    76

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

    77

            pass

    78

    79

        return response

    80

    81

    def process (self, **args) :

    82

        """

    83

            Process incoming POST data, optionally returning a redirect response.

    84

        """

    85

    86

        # default to ignore

    87

        pass

    88

    89

class PageHandler (AppHandler) :

    90

    """

    91

        Specialized AppHandler for normal HTML page views.

    92

    93

        Renders the layout template and HTML.

    94

    """

    95

    96

    def render_content (self, **args) :

    97

        """

    98

            Render and return HTML for page content.

    99

   100

            XXX: must be HTML object, support just text?

   101

        """

   102

   103

        raise NotImplementedError()

   104

   105

    def render_layout (self, content) :

   106

        """

   107

            Render the page layout for the given content block.

   108

        """

   109

   110

        # XXX: layout template, should be somewhere far away

   111

        title = "Index"

   112

        css = [

   113

                "/static/layout.css", 

   114

                "/static/style.css", 

   115

                "/static/forms.css",

   116

                "/static/tables.css",

   117

                "/static/cal.css",

   118

   119

                "/static/treelist.css",

   120

   121

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

   122

        ]

   123

        scripts = [

   124

                "/static/js/jquery.js",

   125

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

   126

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

   127

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

   128

   129

                "/static/js/forms.js",

   130

   131

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

   132

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

   133

                #"/static/js/treelist.js"

   134

        ]

   135

   136

        head = (

   137

            tags.title(title),

   138

            (tags.link(rel='Stylesheet', type="text/css", href=src) for src in css),

   139

            # XXX: script can't self-close >_<

   140

            (tags.script(src=src)(" ") for src in scripts),

   141

        )

   142

   143

        # XXX: silly circular-import hack for urls

   144

        #      it's not sustainable for a base class to referr to its subclasses at define time

   145

        from svv import urls

   146

   147

        header = ("Foo List")

   148

        nav = [tags.ul(tags.li(tags.a(href='#')(name)) for name in ['Nav A', 'Nav B', 'Nav C'])]

   149

        menu = [tags.ul(tags.li(tags.a(href=url)(name)) for name, url in [

   150

            ("Kalenteri",   self.url_for(urls.CalendarView)),

   151

            ("Uusi tilaus", self.url_for(urls.NewOrderView)),

   152

            ("Tilaukset",   self.url_for(urls.OrdersView)),

   153

            ("Tilaajat",    self.url_for(urls.CustomersView)),

   154

            ("Inventaari",  self.url_for(urls.InventoryView)),

   155

        ])]

   156

        footer = ("Copyright?")

   157

   158

        layout = (

   159

            tags.div(id='header')(header),

   160

            tags.div(id='container')(

   161

                tags.div(id='menu')(menu),

   162

                # tags.div(id='nav')(nav),

   163

                tags.div(id='content')(content),

   164

            ),

   165

            tags.div(id='footer')(footer),

   166

        )

   167

   168

        # perform the actual rendering (run generators etc.)

   169

        return unicode(html.document(head, layout))

   170

   171

    def render (self, **url_values) :

   172

        """

   173

            Render full page HTML

   174

        """

   175

   176

        # render page content

   177

        content = self.render_content(**url_values)

   178

   179

        # render into layout

   180

        response = self.render_layout(content)

   181

   182

        # ok

   183

        return response

   184

   185

    def respond (self, **url_values) :

   186

        """

   187

            Build and return a response from the following steps:

   188

   189

            * process() 

   190

            * render() -> render_content() as HTML

   191

        """

   192

   193

        # optional processing

   194

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

   195

   196

        if not response :

   197

            # render page HTML

   198

            html = self.render(**url_values)

   199

   200

            # response object

   201

            # XXX: unicode?

   202

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

   203

   204

        # ok

   205

        return response

   206

   207

class DocumentHandler (AppHandler) :

   208

    """

   209

        PDF generation/export

   210

    """

   211

   212

    def respond (self, **url_values) :

   213

        """

   214

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

   215

        """

   216

   217

        # optional processing

   218

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

   219

   220

        if not response :

   221

            pdf_file = self.generate(**url_values)

   222

   223

            # file wrapper

   224

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

   225

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

   226

   227

            # respond with file wrapper

   228

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

   229

   230

        # ok

   231

        return response

   232

   233

    def generate (self, **url_values) :

   234

        """

   235

            Generate the PDF document as a file-like object.

   236

        """

   237

   238

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

   239

   240

        # render and return StringIO

   241

        return document.render_buf(elements)

   242

   243

    def generate_document (self, **url_values) :

   244

        """

   245

            Return the

   246

                (DocumentTemplate, elements)

   247

            to generate the PDF document from.

   248

        """

   249

   250

        raise NotImplementedError()

   251

   252

### XXX: random test controllers

   253

   254

class Index (PageHandler) :

   255

    DATA = (

   256

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

   257

        (200, "Top B", [

   258

            (210, "Mid BA", [

   259

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

   260

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

   261

            ]),

   262

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

   263

        ]),

   264

        (300, "Top C", [

   265

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

   266

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

   267

        ]),

   268

    )

   269

   270

    def render_content (self) :

   271

        # build data set

   272

        data = self.DATA

   273

   274

        def render_item (id, text, children) :

   275

            return tags.li(

   276

                tags.div(class_='item')(

   277

                    # item text

   278

                    tags.a(tags.input(type='checkbox', name_=id, checked=(

   279

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

   280

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

   281

                ),

   282

   283

                # children

   284

                tags.ul(render_item(*item) for item in children if item) if children else None,

   285

   286

                # 

   287

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

   288

            )

   289

   290

        # XXX: nothing much to see here

   291

        return tags.h1("Mui.")

   292

   293

        # render it

   294

        return (

   295

            tags.h3("Item list"),

   296

            tags.form(action='.', method='post')(

   297

                tags.ul(class_='treelist')(render_item(*item) for item in data),

   298

                tags.input(type='submit'),

   299

            ),

   300

        )

   301

   302

   303