11

import logging

    13

log = logging.getLogger('svv.orders')

    15

class FormError (Exception) :

    16

    """

    17

        A user-level error in a form field

    18

    """

    20

    def __init__ (self, field, error) :

    21

        """

    22

                field       - name of field with error

    23

                error       - descriptive text for user

    24

        """

    26

        self.field = field

    27

    28

        super(FormError, self).__init__(error)

    29

    30

class OrderForm (object) :

    31

    """

    32

        A single instance of a <form>, where we can process submitted data from the client, storing the associated

    33

        Order-related data, and then render a form for any of that related data.

    34

    """

    35

    36

    # any POST data we have processed, updated from process()

    37

    data = None

    38

    39

    def __init__ (self, app) :

    40

        """

    41

                app             - bind this form to the app state (db etc)

    42

        """

    43

    44

        self.app = app

    45

    46

    def defaults (self) :

    47

        """

    48

            Update our attributes with default values

    49

        """

    50

    51

        self.customer_id = None

    52

        self.customer_name = None

    53

    54

        self.contact_id = None

    55

        self.contact_name = None

    56

        self.contact_phone = None

    57

        self.contact_email = None

    58

        self.contact_customer = None

    59

    60

        self.event_name = None

    61

        self.event_description = None

    62

    63

        tomorrow = datetime.date.today() + datetime.timedelta(days=1)

    64

    65

        # default to tomorrow afternoon

    66

        self.event_start = datetime.datetime.combine(tomorrow, datetime.time(16, 00))

    67

    68

        # automatically determined once start is set

    69

        self.event_end = None

    70

    71

    def process_raw_field (self, name, default=None, required=None) :

    72

        """

    73

            Process a generic incoming data field.

    74

    75

                default         - value to return if no value was present

    76

                required        - raise a FormError if no value present

    77

    78

            Returns the value as a str, or default

    79

        """

    80

    81

        if name in self.post :

    82

            return self.post[name]

    83

    84

        elif required :

    85

            raise FormError(name, "Required field")

    86

    87

        else :

    88

            return default

    89

    90

    def process_string_field (self, name, default=None, required=None, strip=True) :

    91

        """

    92

            Process a generic incoming string field.

    93

    94

            Trims extra whitespace from around the value, unless strip=False is given.

    95

    96

            Returns the value as unicode, or default.

    97

        """

    98

    99

        value = self.process_raw_field(name, required=required)

   100

   101

        if value is None :

   102

            return default

   103

   104

        try :

   105

            # XXX: decode somehow, or can werkzeug handle that?

   106

            value = unicode(value)

   107

   108

        except UnicodeDecodeError :

   109

            raise FormError(name, "Failed to decode Unicode characters")

   110

   111

        if strip :

   112

            value = value.strip()

   113

   114

        return value

   115

   116

    def process_integer_field (self, name, default=None, required=None) :

   117

        """

   118

            Process a generic incoming int field.

   119

   120

            Returns the value as int, or default.

   121

        """

   122

   123

        value = self.process_raw_field(name, required=required)

   124

   125

        if value is None :

   126

            return default

   127

   128

        try :

   129

            return int(value)

   130

   131

        except ValueError :

   132

            raise FormError(name, "Must be a number")

   133

   134

    DATETIME_FORMAT = "%d.%m.%Y %H:%M"

   135

   136

    def process_datetime_field (self, name, default=None, required=None, format=DATETIME_FORMAT) :

   137

        """

   138

            Process an incoming datetime field.

   139

   140

            Returns the value as datetime, or default.

   141

        """

   142

   143

        value = self.process_raw_field(name, required=required)

   144

   145

        if value is None :

   146

            return default

   147

   148

        try :

   149

            return datetime.datetime.strptime(value, format)

   150

   151

        except ValueError, ex :

   152

            raise FormError(name, "Invalid date/time value: " + str(ex))

   153

   154

    def process_multifield (self, table, id, fields) :

   155

        """

   156

            Process a set of user-given field values for an object with an unique id, and some set of additional fields.

   157

   158

            If the id is given, look up the corresponding field values, and return those.

   159

   160

            If any of the fields are given, either look up a matching row, or create a new one, and return its id.

   161

   162

            Returns an (id_name, field_name, ...) N-tuple.

   163

        """

   164

   165

        id_name, id_col, id_value = id

   166

   167

        if id_value :

   168

            # look up object from db

   169

            columns = [col for name, col, value in fields]

   170

   171

            sql = db.select(columns, (id_col == id_value))

   172

   173

            for row in sql :

   174

                # XXX: sanity-check row values vs our values

   175

   176

                # new values

   177

                fields = tuple(

   178

                    (name, col, row[col]) for name, col, value in fields

   179

                )

   180

   181

                # ok, just use the first one

   182

                break

   183

   184

            else :

   185

                # not found!

   186

                raise FormError(id_name, "Item selected does not seem to exist")

   187

   188

            log.info("Lookup %s=%d -> %s", id_name, id_value, dict((name, value) for name, col, value in fields))

   189

   190

        elif any(value for name, col, value in fields) :

   191

            # look up identical object from db?

   192

            sql = db.select([id_col], db.and_(*[(col == value) for name, col, value in fields]))

   193

   194

            for row in self.app.query(sql) :

   195

                if id_value :

   196

                    log.warn("Duplicate %s=%d for %s", id_name, id_value, dict((name, value) for name, col, value in fields))

   197

   198

                # found object's id

   199

                id_value = row[id_col]

   200

   201

                log.info("Found %s -> %d", dict((name, value) for name, col, value in fields), id_value)

   202

   203

            # create new object?

   204

            if not id_value :

   205

                sql = db.insert(table).values(dict((col, value) for name, col, value in fields))

   206

   207

                id_value, = self.app.insert(sql)

   208

   209

                log.info("Create %s -> %d", dict((name, value) for name, col, value in fields), id_value)

   210

   211

        else :

   212

            # not known

   213

            log.debug("No %s known for order...", id_name)

   214

   215

        # return full set of values

   216

        return (id_value, ) + tuple(value for name, col, value in fields)

   217

   218

    def process_customer (self) :

   219

        """

   220

            Process the incoming customer_* fields, returning (customer_id, customer_name).

   221

        """

   222

   223

        return self.process_multifield(db.customers,

   224

            ('customer_id', db.customers.c.id, self.process_integer_field('customer_id')),

   225

            (

   226

                ('customer_name', db.customers.c.name, self.process_string_field('customer_name')),

   227

            ),

   230

    def process_contact (self, customer_id) :

   232

            Process the incoming contact_* fields, returning 

   233

                (contact_id, contact_name, contact_phone, contact_email, contact_customer)

   236

        return self.process_multifield(db.contacts,

   237

            ('contact_id', db.contacts.c.id, self.process_integer_field('contact_id')),

   238

            (

   239

                ('contact_name', db.contacts.c.name, self.process_string_field('contact_name')),

   240

                ('contact_phone', db.contacts.c.phone, self.process_string_field('contact_phone')),

   241

                ('contact_email', db.contacts.c.email, self.process_string_field('contact_email')),

   242

                ('contact_customer', db.contacts.c.customer, customer_id),

   243

            ),

   244

        )

   246

    def process_event (self) :

   248

            Process the incoming event_* fields, returning

   249

                (event_name, event_description, event_start, event_end)

   252

        event_name = self.process_string_field('event_name')

   253

        event_description = self.process_string_field('event_description', strip=False)

   254

        event_start = self.process_datetime_field('event_start')

   255

        event_end = self.process_datetime_field('event_end')

   256

   257

        return (event_name, event_description, event_start, event_end)

   258

   259

    def process (self, data) :

   260

        """

   261

            Bind ourselves to the given incoming POST data, and update our order field attributes.

   262

   263

                data        - the submitted POST data as a MultiDict

   264

        """

   265

   266

        # bind the raw post data

   267

        self.data = data

   268

   269

        # customer

   270

        self.customer_id, self.customer_name = self.process_customer()

   271

   272

        # contact

   273

        self.contact_id, self.contact_name, self.contact_phone, self.contact_email, self.contact_customer = self.process_contact(customer_id)

   274

   275

        if self.contact_customer and not self.customer_id :

   276

            # TODO: be really smart?

   277

            pass

   278

   279

        # event

   280

        self.event_name, self.event_description, self.event_start, self.event_end = self.process_event()

   281

   282

   283

    def build_customer_list (self) :

   284

        """

   285

            Query a (id, name) list of customers.

   286

        """

   287

   288

        sql = db.select([db.customers.c.id, db.customers.c.name])

   289

   290

        return self.app.query(sql)

   291

   292

    def build_contact_list (self, customer_id=None) :

   293

        """

   294

            Query a (id, name, phone, email) list of contacts, optionally for given customer if given.

   295

        """

   296

   297

        sql = db.select([db.contacts.c.id, db.contacts.c.name, db.contacts.c.phone, db.contacts.c.email])

   300

            sql = sql.where((db.contacts.c.customer == customer_id))

   302

        return self.app.query(sql)

   303

   304

   305

    def render_text_input (self, name, value=None, multiline=False) :

   306

        """

   307

            Render HTML for a generic text field input.

   308

   309

                name            - field name, as used for POST

   310

                value           - default field value

   311

                multiline       - use a multi-line <textarea> instead

   312

        """

   313

   314

        if multiline :

   315

            # XXX: textarea can't be self-closing for some reason?

   316

            return tags.textarea(name=name, id=name, _selfclosing=False, _whitespace_sensitive=True)(value)

   317

   318

        else :

   319

            return tags.input(type='text', name=name, id=name, value=value)

   320

   321

    def render_select_input (self, name, options, value=None) :

   322

        """

   323

            Render HTML for a generic select control.

   324

   325

                name            - field name, as used for POST

   326

                options         - sequence of (value, title) options. `value` may be None to omit.

   327

                value           - the selected value

   328

        """

   329

   330

        return tags.select(name=name, id=name)(

   331

            (

   332

                tags.option(value=opt_value, selected=('selected' if opt_value == value else None))(opt_title)

   333

            ) for opt_value, opt_title in options

   334

        )

   338

            Render HTML for customer_id/name field inputs.

   341

        # all known customers

   342

        customers = self.build_customer_list()

   345

            self.render_select_input('customer_id', customers, self.customer_id),

   346

            self.render_text_input('customer_name', self.customer_name),

   355

        # recommended contacts for selected customer, if known

   356

        contacts = self.get_contact_list(self.customer_id)

   359

            self.render_select_input('contact_id', ((id, name) for id, name, phone, email in contacts), self.contact_id)

   360

            self.render_text_input('contact_name', self.contact_name),

   371

            self.render_text_input('event_start', (self.event_start.strftime(self.DATETIME_FORMAT) if event_start else None)),

   373

            self.render_text_input('event_end', (self.event_end.strftime(self.DATETIME_FORMAT) if event_end else None)),

   383

/* Buggy shit doesn't work

   384

   385

    {

   386

        beforeShow: function (input, inst) {

   387

            // copy default value from event_start

   388

            event_end.datetimepicker("option", "defaultDate", event_start.datetimepicker("getDate"));

   389

        }

   390

    }   

   391

   401

*/

   406

    def render_form_field (self, name, title, description, inputs) :

   407

        """

   408

            Render the label, input control, error note and description for a single field, along with their containing <li>.

   409

        """

   411

        return tags.li(class_='field')(

   412

            tags.label(title, for_=name),

   413

   414

            inputs,

   415

   416

            # XXX: somewhere where we tag these!

   417

            # tags.span("Error!"),

   418

   419

            tags.p(description),

   420

        )

   421

   422

   423

    def render (self, action, submit=u"Tallenna") :

   424

        """

   425

            Render the entire <form>, using any loaded/processed values.

   426

   427

                action          - the target URL for the form to POST to

   428

                submit          - label for the submit button

   429

        """

   430

   431

        return tags.form(action=action, method='POST')(

   436

                    self.render_form_field('customer_name', u"Tilaaja", u"Tilaavan yhdistyksen/henkilön nimi", (

   437

                        self.render_customer_input()

   440

                    self.render_form_field('contact_name', u"Yhteyshenkilö", u"Yhteyshenkilön nimi, jos eri kun tilaaja", (

   441

                        self.render_contact_input()

   442

                    )),

   443

   444

                    self.render_form_field('contact_phone', u"Puhelin", u"Yhteyshenkilön puhelinnumero", (

   445

                        self.render_text_input('contact_phone', self.contact_phone)

   446

                    )),

   447

   448

                    self.render_form_field('contact_email', u"Sähköposti", u"Yhteyshenkilön sähköpostiosoite", (

   449

                        self.render_text_input('contact_email', self.contact_email)

   458

                    self.render_form_field('event_name', u"Tapahtuma", u"Tapahtuman lyhyt nimi", (

   459

                        self.render_text_input('event_name', self.event_name)

   462

                    self.render_form_field('event_description', u"Lisätiedot", u"Tapahtuman tarkemmat tiedot", (

   463

                        self.render_text_input('event_description', self.event_description, multiline=True)

   466

                    self.render_form_field('event_start', u"Ajankohta", u"Tapahtuman ajankohta (kamat noudetaan - palautetaan)", (

   467

                        self.render_event_input()

   468

                    )),

   472

            tags.input(type='submit', value=submit),

   475

   476

class OrdersView (PageHandler) :

   477

    def render (self) :

   478

        return tags.h1("Orders list")

   479

   480

class OrderView (PageHandler) :

   481

    def render (self, id) :

   482

        return tags.h1("Order info for #%d" % (id, ))

   483

   484

class NewOrderView (PageHandler) :

   485

    """

   486

   487

    """

   488

   489

    def render (self) :

   490

        if self.POST :

   491

            print self.POST

   492

   493

            # 

   494

   495

            # if we've gotten this far, then we can create it!