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, markup

    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 Customer (object) :

    26

    """

    27

        Data-mapping for the customers table

    28

    """

    29

    30

    # customer name (organization or natural person)

    31

    name = None

    32

    33

class Contact (object) :

    34

    """

    35

        Data-mapping for the contacts table

    36

    """

    37

    38

    # human-readable details

    39

    name = None

    40

    phone = None

    41

    email = None

    42

    43

    # relation to Customer

    44

    customer = None

    45

    46

    47

class Order (object) :

    48

    """

    49

        Data-mapping for orders table.

    50

    """

    51

    52

    # relation to Customer

    53

    customer = None

    54

    55

    # relation to Contact

    56

    contact = None

    57

    58

    # event info

    59

    event_name = None

    60

    event_description = None

    61

    event_start = None

    62

    event_end = None

    63

    64

    def __init__ (self) :

    65

        """

    66

            Construct an Order with default values

    67

        """

    68

    69

        ## Set default values

    70

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

    71

    72

        # default to tomorrow afternoon

    73

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

    74

        self.event_end = None   # determined by UI behaviour

    75

    76

    77

    def format_event_time (self) :

    78

        """

    79

            Return a concise string describing the event's approximate time span.

    80

        """

    81

    82

        start = self.event_start

    83

        end = self.event_end

    84

    85

        # different days

    86

        if (start.year, start.month) != (end.year, end.month) :

    87

            # the full dates

    88

            date = "%s - %s" % (start.strftime("%d.%m.%Y"), end.strftime("%d.%m.%Y"))

    89

    90

        elif (start.day != end.day) :

    91

            # day range

    92

            date = "%s-%s.%s" % (start.strftime("%d"), end.strftime("%d"), start.strftime("%m.%Y"))

    93

    94

        else : # start.date() == end.date()

    95

            # single day

    96

            date = start.strftime("%d.%m.%Y")

    97

    98

        # time

    99

        time = "%s-%s" % (start.strftime("%H:%M"), end.strftime("%H:%M"))

   100

   101

        # format

   102

        return "%s %s" % (date, time)

   103

   104

   105

# bind against database schema

   106

db.mapper(Customer, db.customers)

   107

db.mapper(Contact, db.contacts)

   108

db.mapper(Order, db.orders, properties=dict(

   109

    customer    = db.relation(Customer),

   110

    contact     = db.relation(Contact),

   111

))

   112

   113

class FormError (Exception) :

   114

    """

   115

        A user-level error in a form field

   116

    """

   117

   118

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

   119

        """

   120

                field       - name of field with error

   121

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

   122

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

   123

                error       - descriptive text for user

   124

        """

   125

   126

        self.field = field

   127

        self.value = value

   128

   129

        super(FormError, self).__init__(error)

   130

   131

class BaseForm (object) :

   132

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

   133

    data = None

   134

   135

    def __init__ (self, app) :

   136

        """

   137

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

   138

        """

   139

   140

        self.app = app

   141

   142

        # accumulated errors

   143

        self.errors = collections.defaultdict(list)

   144

   145

    def defaults (self) :

   146

        """

   147

            Update our attributes with default values

   148

        """

   149

   150

        raise NotImplementedError()

   151

   152

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

   153

        """

   154

            Mark the field mentioned inside the given FormError as failed.

   155

   156

                form_error      - the FormError to store

   157

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

   158

        """

   159

   160

        field = field or form_error.field

   161

   162

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

   163

   164

        self.errors[field].append(form_error)

   165

   166

    def build_name_for_armed_input (self, name) :

   167

        """

   168

            Return the name used for the checkbox associated with the named armed text input

   169

        """

   170

   171

        return name + '_enabled'

   172

   173

   174

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

   175

        """

   176

            Process a generic incoming data field.

   177

   178

                default         - value to return if no value was present

   179

                required        - raise a FormError if no value present

   180

   181

            Returns the value as a str, or default

   182

        """

   183

   184

        if name in self.data :

   185

            return self.data[name]

   186

   187

        elif required :

   188

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

   189

   190

        else :

   191

            return default

   192

   193

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

   194

        """

   195

            Process a generic incoming string field.

   196

   197

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

   198

   199

            Returns the value as unicode, or default.

   200

        """

   201

   202

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

   203

   204

        if value is None :

   205

            return default

   206

   207

        try :

   208

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

   209

            value = unicode(value)

   210

   211

        except UnicodeDecodeError :

   212

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

   213

   214

        if strip :

   215

            value = value.strip()

   216

   217

        return value

   218

   219

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

   220

        """

   221

            Process a generic incoming int field.

   222

   223

            Returns the value as int, or default.

   224

        """

   225

   226

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

   227

   228

        if value is None :

   229

            return default

   230

   231

        try :

   232

            return int(value)

   233

   234

        except ValueError :

   235

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

   236

   237

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

   238

   239

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

   240

        """

   241

            Process an incoming datetime field.

   242

   243

            Returns the value as datetime, or default.

   244

        """

   245

   246

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

   247

   248

        if value is None :

   249

            return default

   250

   251

        try :

   252

            return datetime.datetime.strptime(value, format)

   253

   254

        except ValueError, ex :

   255

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

   256

   257

    def process_checkbox_field (self, name, required=None) :

   258

        """

   259

            Process an incoming checkbox input's value.

   260

   261

            Any non-empty/non-whitespace value will be accepted as True.

   262

        """

   263

   264

        value = self.process_raw_field(name, required)

   265

   266

        if not value and required :

   267

            raise FormError(name, value, "Must be checked")

   268

   269

        elif value and value.strip() :

   270

            # checked

   271

            return True

   272

   273

        else :

   274

            # unchecked

   275

            return False

   276

   277

    def process_armed_text_field (self, name, required=None) :

   278

        """

   279

            A text field that must be enabled by a checkbox before being used.

   280

   281

            If not enabled, returns False. Otherwise, text field value, and fails if empty but required.

   282

        """

   283

   284

        checkbox_name = self.build_name_for_armed_input(name)

   285

   286

        if self.process_checkbox_field(checkbox_name) :

   287

            # use input value

   288

            return self.process_text_field(name, required=required)

   289

   290

        else :

   291

            # not selected

   292

            return False

   293

   294

   295

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

   296

        """

   297

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

   298

   299

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

   300

   301

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

   302

   303

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

   304

        """

   305

   306

        id_name, id_col, id_value = id

   307

   308

        if id_value :

   309

            # look up object from db

   310

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

   311

   312

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

   313

   314

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

   315

                # XXX: sanity-check row values vs our values

   316

   317

                # new values

   318

                fields = tuple(

   319

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

   320

                )

   321

   322

                # ok, just use the first one

   323

                break

   324

   325

            else :

   326

                # not found!

   327

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

   328

   329

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

   330

   331

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

   332

            # look up identical object from db?

   333

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

   334

   335

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

   336

                if id_value :

   337

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

   338

   339

                # found object's id

   340

                id_value = row[id_col]

   341

   342

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

   343

   344

            # create new object?

   345

            if not id_value :

   346

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

   347

   348

                id_value, = self.app.insert(sql)

   349

   350

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

   351

   352

        else :

   353

            # not known

   354

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

   355

   356

        # return full set of values

   357

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

   358

   359

    def process (self, data) :

   360

        """

   361

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

   362

   363

                data        - the submitted POST data as a MultiDict

   364

   365

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

   366

        """

   367

   368

        raise NotImplmentedError()

   369

   370

        return not self.errors

   371

   372

    def render_text_input (self, name, value=None, multiline=False, rows=10, autoscale=True) :

   373

        """

   374

            Render HTML for a generic text field input.

   375

   376

                name            - field name, as used for POST

   377

                value           - default field value

   378

                multiline       - use a multi-line <textarea> instead

   379

                rows            - number of rows for <textarea> per default

   380

                autoscale       - automatically scale the <textarea> to the number of lines of text

   381

        """

   382

   383

        if multiline :

   384

            if autoscale and value :

   385

                rows = value.count('\n') * 5 / 4

   386

   387

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

   388

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

   389

   390

        else :

   391

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

   392

   393

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

   394

        """

   395

            Render HTML for a generic select control.

   396

   397

                name            - field name, as used for POST

   398

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

   399

                value           - the selected value

   400

        """

   401

   402

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

   403

            (

   404

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

   405

            ) for opt_value, opt_title in options

   406

        )

   407

   408

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

   409

        """

   410

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

   411

   412

                name            - field name, as used for POST

   413

                value           - selected date

   414

        """

   415

   416

        return (

   417

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

   418

   419

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

   420

        )

   421

   422

    def render_checkbox_input (self, name, checked=None) :

   423

        """

   424

            Render HTML for a checkbox.

   425

        """

   426

   427

        return tags.input(type="checkbox", name=name, id=name, value="1",

   428

            checked=("checked" if checked else None)

   429

        )

   430

   431

    def render_armed_text_input (self, name, value=False, default=None) :

   432

        """

   433

            Render HTML for a text field that must be enabled by a checkbox before being used.

   434

   435

                value       - the three-state value

   436

                                False       - not checked, use default as value

   437

                                None        - checked, use empty value

   438

                                str         - checked, ues value

   439

        """

   440

   441

        checkbox_name = self.build_name_for_armed_input(name)

   442

   443

        if value is False :

   444

            checked = False

   445

            value = default

   446

   447

        else :

   448

            checked = True

   449

   450

        return (

   451

            self.render_checkbox_input(checkbox_name, checked),

   452

            self.render_text_input(name, value),

   453

   454

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

   455

        )

   456

   457

   458

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

   459

        """

   460

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

   461

        """

   462

   463

        # any errors for this field?

   464

        errors = self.errors[name]

   465

   466

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

   467

            tags.label((

   468

                title,

   469

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

   470

            ), for_=name),

   471

   472

            inputs,

   473

   474

            tags.p(description),

   475

   476

            # possible errors

   477

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

   478

        )

   479

   480

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

   481

        """

   482

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

   483

   484

                action          - the target URL for the form to POST to

   485

                submit          - label for the submit button

   486

        """

   487

   488

        raise NotImplementedError()

   489

   490

   491

class OrderForm (BaseForm) :

   492

    """

   493

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