1

# coding: utf-8

     2

"""

     3

    Order data model/view/handler

     4

"""

     5

     6

from svv.controllers import PageHandler, DocumentHandler

     7

from svv.html import tags

     8

from svv import database as db

     9

from svv import pdf

    10

    11

import datetime

    12

import logging

    13

import collections

    14

    15

try :

    16

    # Python2.6 stdlib

    17

    import json

    18

    19

except ImportError :

    20

    # simplejson, API should be similar

    21

    import simplejson as json

    22

    23

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

    24

    25

class FormError (Exception) :

    26

    """

    27

        A user-level error in a form field

    28

    """

    29

    30

    def __init__ (self, field, value, error) :

    31

        """

    32

                field       - name of field with error

    33

                value       - the errenous value in the form that we recieved it

    34

                              may be None if it was the *lack* of a value that caused the issue

    35

                error       - descriptive text for user

    36

        """

    37

    38

        self.field = field

    39

        self.value = value

    40

    41

        super(FormError, self).__init__(error)

    42

    43

class BaseForm (object) :

    44

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

    45

    data = None

    46

    47

    def __init__ (self, app) :

    48

        """

    49

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

    50

        """

    51

    52

        self.app = app

    53

    54

        # accumulated errors

    55

        self.errors = collections.defaultdict(list)

    56

    57

    def defaults (self) :

    58

        """

    59

            Update our attributes with default values

    60

        """

    61

    62

        raise NotImplementedError()

    63

    64

    def fail_field (self, form_error, field=None) :

    65

        """

    66

            Mark the field mentioned inside the given FormError as failed.

    67

    68

                form_error      - the FormError to store

    69

                field           - the name of the field to store the error under, if not the same as in form_error

    70

        """

    71

    72

        field = field or form_error.field

    73

    74

        log.warn("Marking field %s as failed: %s", field, form_error)

    75

    76

        self.errors[field].append(form_error)

    77

    78

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

    79

        """

    80

            Process a generic incoming data field.

    81

    82

                default         - value to return if no value was present

    83

                required        - raise a FormError if no value present

    84

    85

            Returns the value as a str, or default

    86

        """

    87

    88

        if name in self.data :

    89

            return self.data[name]

    90

    91

        elif required :

    92

            raise FormError(name, None, "Required field")

    93

    94

        else :

    95

            return default

    96

    97

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

    98

        """

    99

            Process a generic incoming string field.

   100

   101

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

   102

   103

            Returns the value as unicode, or default.

   104

        """

   105

   106

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

   107

   108

        if value is None :

   109

            return default

   110

   111

        try :

   112

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

   113

            value = unicode(value)

   114

   115

        except UnicodeDecodeError :

   116

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

   117

   118

        if strip :

   119

            value = value.strip()

   120

   121

        return value

   122

   123

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

   124

        """

   125

            Process a generic incoming int field.

   126

   127

            Returns the value as int, or default.

   128

        """

   129

   130

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

   131

   132

        if value is None :

   133

            return default

   134

   135

        try :

   136

            return int(value)

   137

   138

        except ValueError :

   139

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

   140

   141

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

   142

   143

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

   144

        """

   145

            Process an incoming datetime field.

   146

   147

            Returns the value as datetime, or default.

   148

        """

   149

   150

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

   151

   152

        if value is None :

   153

            return default

   154

   155

        try :

   156

            return datetime.datetime.strptime(value, format)

   157

   158

        except ValueError, ex :

   159

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

   160

   161

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

   162

        """

   163

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

   164

   165

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

   166

   167

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

   168

   169

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

   170

        """

   171

   172

        id_name, id_col, id_value = id

   173

   174

        if id_value :

   175

            # look up object from db

   176

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

   177

   178

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

   179

   180

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

   181

                # XXX: sanity-check row values vs our values

   182

   183

                # new values

   184

                fields = tuple(

   185

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

   186

                )

   187

   188

                # ok, just use the first one

   189

                break

   190

   191

            else :

   192

                # not found!

   193

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

   194

   195

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

   196

   197

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

   198

            # look up identical object from db?

   199

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

   200

   201

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

   202

                if id_value :

   203

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

   204

   205

                # found object's id

   206

                id_value = row[id_col]

   207

   208

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

   209

   210

            # create new object?

   211

            if not id_value :

   212

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

   213

   214

                id_value, = self.app.insert(sql)

   215

   216

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

   217

   218

        else :

   219

            # not known

   220

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

   221

   222

        # return full set of values

   223

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

   224

   225

    def process (self, data) :

   226

        """

   227

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

   228

   229

                data        - the submitted POST data as a MultiDict

   230

   231

            Returns True if all fields were processed without errors, False otherwise.

   232

        """

   233

   234

        raise NotImplmentedError()

   235

   236

        return not self.errors

   237

   238

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

   239

        """

   240

            Render HTML for a generic text field input.

   241

   242

                name            - field name, as used for POST

   243

                value           - default field value

   244

                multiline       - use a multi-line <textarea> instead

   245

        """

   246

   247

        if multiline :

   248

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

   249

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

   250

   251

        else :

   252

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

   253

   254

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

   255

        """

   256

            Render HTML for a generic select control.

   257

   258

                name            - field name, as used for POST

   259

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

   260

                value           - the selected value

   261

        """

   262

   263

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

   264

            (

   265

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

   266

            ) for opt_value, opt_title in options

   267

        )

   268

   269

    def render_datetime_input (self, name, value=None) :

   270

        """

   271

            Render HTML for a generic datetime control (using jQuery).

   272

   273

                name            - field name, as used for POST

   274

                value           - selected date

   275

        """

   276

   277

        return (

   278

            self.render_text_input(name, (value.strftime(self.DATETIME_FORMAT) if value else None)),

   279

   280

            tags.script("$(document).ready(function () { $('#" + name + "').datetimepicker(); });"),

   281

        )

   282

   283

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

   284

        """

   285

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

   286

        """

   287

   288

        # any errors for this field?

   289

        errors = self.errors[name]

   290

   291

        return tags.li(class_='field' + (' failed' if errors else ''))(

   292

            tags.label((

   293

                title,

   294

                tags.strong(u"(Virheellinen)") if errors else None,

   295

            ), for_=name),

   296

   297

            inputs,

   298

   299

            tags.p(description),

   300

   301

            # possible errors

   302

            tags.ul(class_='errors')(tags.li(error.message) for error in errors) if errors else None,

   303

        )

   304

   305

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

   306

        """

   307

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

   308

   309

                action          - the target URL for the form to POST to

   310

                submit          - label for the submit button

   311

        """

   312

   313

        raise NotImplementedError()

   314

   315

   316

class OrderForm (BaseForm) :

   317

    """

   318

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

   319

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

   320

    """

   321

   322

    def defaults (self) :

   323

        """

   324

            Update our attributes with default values

   325

        """

   326

   327

        self.customer_id = None

   328

        self.customer_name = None

   329

   330

        self.contact_id = None

   331

        self.contact_name = None

   332

        self.contact_phone = None

   333

        self.contact_email = None

   334

        self.contact_customer = None

   335

   336

        self.event_name = None

   337

        self.event_description = None

   338

   339

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

   340

   341

        # default to tomorrow afternoon

   342

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

   343

   344

        # automatically determined once start is set

   345

        self.event_end = None

   346

   347

    def process_customer (self) :

   348

        """

   349

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

   350

        """

   351

   352

        try :

   353

            customer_id = self.process_integer_field('customer_id')

   354

            customer_name = self.process_string_field('customer_name')

   355

   356

            if not customer_id and not customer_name :

   357

                raise FormError('customer_name', None, "Must enter a customer")

   358

   359

            return self.process_multifield(db.customers,

   360

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

   361

                (

   362

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

   363

                ),

   364

            )

   365

   366

        except FormError, e :

   367

            # list it

   368

            self.fail_field(e, 'customer_name')

   369

   370

            return None, None

   371

   372

    def process_contact (self, customer_id, customer_name) :

   373

        """

   374

            Process the incoming contact_* fields, returning 

   375

                (contact_id, contact_name, contact_phone, contact_email, contact_customer)

   376

        """

   377

   378

        try :

   379

            contact_id = self.process_integer_field('contact_id')

   380

            contact_name = self.process_string_field('contact_name')

   381

            contact_phone = self.process_string_field('contact_phone')

   382

            contact_email = self.process_string_field('contact_email')

   383

            contact_customer = customer_id

   384

   385

            if not contact_id and not contact_name and (contact_phone or contact_email) and customer_name :

   386

                # use customer name as contact name, if otherwise missing

   387

                contact_name = customer_name

   388

   389

            if not contact_id and not (contact_name or contact_phone or contact_email) :

   390

                raise FormError('contact_name', None, "Must enter a contact")

   391

   392

            return self.process_multifield(db.contacts,

   393

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

   394

                (

   395

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

   396

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

   397

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

   398

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

   399

                ),

   400

            )

   401

   402

        except FormError, e :

   403

            # list it

   404

            self.fail_field(e, 'contact_name' if e.field == 'contact_id' else None)

   405

   406

            return None, None, None, None, None

   407

   408

    def process_event (self) :

   409

        """

   410

            Process the incoming event_* fields, returning

   411

                (event_name, event_description, event_start, event_end)

   412

        """

   413

   414

        try :

   415

            event_name = self.process_string_field('event_name')

   416

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

   417

            event_start = self.process_datetime_field('event_start')

   418

            event_end = self.process_datetime_field('event_end')

   419

   420

            if event_end < event_start :

   421

                raise FormError('event_start', event_end, "Event must end after start")

   422

   423

            return (event_name, event_description, event_start, event_end)

   424

   425

        except FormError, e :

   426

            # list it

   427

            self.fail_field(e)

   428

   429

            return None, None, None, None

   430

   431

    def process (self, data) :

   432

        """

   433

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

   434

   435

                data        - the submitted POST data as a MultiDict

   436

   437

            Returns True if all fields were processed without errors, False otherwise.

   438

        """

   439

   440

        # bind the raw post data

   441

        self.data = data

   442

   443

        # customer

   444

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

   445

   446

        # contact

   447

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

   448

   449

        if self.contact_customer and not self.customer_id :

   450

            # TODO: be really smart?

   451

            pass

   452

   453

        # event

   454

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

   455

   456

        return not self.errors

   457

   458

    def load (self, id) :

   459

        """

   460

            Load our field values from the database using the given id

   461

   462

            XXX: move SQL stuff out into an OrderModel class or something

   463

        """

   464

   465

        # query tables from db

   466

        sql_from = db.orders.join(db.customers).join(db.contacts, (db.orders.c.contact == db.contacts.c.id))

   467

        sql = db.select(

   468

            [

   469

                db.orders,

   470

                db.customers,

   471

                db.contacts

   472

            ],

   473

            (db.orders.c.id == id),

   474

            from_obj = sql_from,

   475

            use_labels = True,

   476

        )

   477

   478

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

   479

            # load data

   480

   481

            self.customer_id = row[db.customers.c.id]

   482

            self.customer_name = row[db.customers.c.name]

   483

   484

            self.contact_id = row[db.contacts.c.id]

   485

            self.contact_name = row[db.contacts.c.name]

   486

            self.contact_phone = row[db.contacts.c.phone]

   487

            self.contact_email = row[db.contacts.c.email]

   488

   489

            self.event_name = row[db.orders.c.event_name]

   490

            self.event_description = row[db.orders.c.event_description]

   491

            self.event_start = row[db.orders.c.event_start]

   492

            self.event_end = row[db.orders.c.event_end]