1

# coding: utf-8

     2

"""

     3

    Order data model/view/handler

     4

"""

     5

     6

from svv.controllers import PageHandler, DocumentHandler

     7

from svv.forms import FormError, BaseForm, json

     8

from svv.html import tags

     9

from svv import database as db

    10

from svv import pdf, markup

    11

    12

import datetime

    13

import logging

    14

    15

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

    16

    17

class Customer (object) :

    18

    """

    19

        Data-mapping for the customers table

    20

    """

    21

    22

    # customer name (organization or natural person)

    23

    name = None

    24

    25

class Contact (object) :

    26

    """

    27

        Data-mapping for the contacts table

    28

    """

    29

    30

    # human-readable details

    31

    name = None

    32

    phone = None

    33

    email = None

    34

    35

    # relation to Customer

    36

    customer = None

    37

    38

    39

class Order (object) :

    40

    """

    41

        Data-mapping for orders table.

    42

    """

    43

    44

    # relation to Customer

    45

    customer = None

    46

    47

    # relation to Contact

    48

    contact = None

    49

    50

    # event info

    51

    event_name = None

    52

    event_description = None

    53

    event_start = None

    54

    event_end = None

    55

    56

    def __init__ (self) :

    57

        """

    58

            Construct an Order with default values

    59

        """

    60

    61

        ## Set default values

    62

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

    63

    64

        # default to tomorrow afternoon

    65

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

    66

        self.event_end = None   # determined by UI behaviour

    67

    68

    69

    def format_event_time (self) :

    70

        """

    71

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

    72

        """

    73

    74

        start = self.event_start

    75

        end = self.event_end

    76

    77

        # different days

    78

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

    79

            # the full dates

    80

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

    81

    82

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

    83

            # day range

    84

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

    85

    86

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

    87

            # single day

    88

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

    89

    90

        # time

    91

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

    92

    93

        # format

    94

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

    95

    96

    97

    def on_date (self, date) :

    98

        """

    99

            Does the event take place on this date?

   100

        """

   101

   102

        return self.event_start.date() <= date <= self.event_end.date()

   103

   104

# bind against database schema

   105

db.mapper(Customer, db.customers)

   106

db.mapper(Contact, db.contacts)

   107

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

   108

    customer    = db.relation(Customer),

   109

    contact     = db.relation(Contact),

   110

))

   111

   112

class OrderForm (BaseForm) :

   113

    """

   114

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

   115

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

   116

    """

   117

   118

    def __init__ (self, app) :

   119

        """

   120

            Bind against app for database access.

   121

        """

   122

   123

        super(OrderForm, self).__init__()

   124

   125

        self.app = app

   126

   127

    def defaults (self) :

   128

        """

   129

            Update our attributes with default values

   130

        """

   131

   132

        self.customer_id = None

   133

        self.customer_name = None

   134

   135

        self.contact_id = None

   136

        self.contact_name = None

   137

        self.contact_phone = None

   138

        self.contact_email = None

   139

        self.contact_customer = None

   140

   141

        self.event_name = None

   142

        self.event_description = None

   143

   144

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

   145

   146

        # default to tomorrow afternoon

   147

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

   148

   149

        # automatically determined once start is set

   150

        self.event_end = None

   151

   152

    def process_customer (self) :

   153

        """

   154

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

   155

        """

   156

   157

        try :

   158

            customer_id = self.process_integer_field('customer_id')

   159

            customer_name = self.process_text_field('customer_name')

   160

   161

            if not customer_id and not customer_name :

   162

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

   163

   164

            return self.process_multifield(db.customers,

   165

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

   166

                (

   167

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

   168

                ),

   169

            )

   170

   171

        except FormError, e :

   172

            # list it

   173

            self.fail_field(e, 'customer_name')

   174

   175

            return None, None

   176

   177

    def process_contact (self, customer_id, customer_name) :

   178

        """

   179

            Process the incoming contact_* fields, returning 

   180

                (contact_id, contact_name, contact_phone, contact_email, contact_customer)

   181

        """

   182

   183

        try :

   184

            contact_id = self.process_integer_field('contact_id')

   185

            contact_name = self.process_text_field('contact_name')

   186

            contact_phone = self.process_text_field('contact_phone')

   187

            contact_email = self.process_text_field('contact_email')

   188

            contact_customer = customer_id

   189

   190

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

   191

                # use customer name as contact name, if otherwise missing

   192

                contact_name = customer_name

   193

   194

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

   195

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

   196

   197

            return self.process_multifield(db.contacts,

   198

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

   199

                (

   200

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

   201

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

   202

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

   203

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

   204

                ),

   205

            )

   206

   207

        except FormError, e :

   208

            # list it

   209

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

   210

   211

            return None, None, None, None, None

   212

   213

    def process_event (self) :

   214

        """

   215

            Process the incoming event_* fields, returning

   216

                (event_name, event_description, event_start, event_end)

   217

        """

   218

   219

        try :

   220

            event_name = self.process_text_field('event_name')

   221

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

   222

            event_start = self.process_datetime_field('event_start')

   223

            event_end = self.process_datetime_field('event_end')

   224

   225

            if event_end < event_start :

   226

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

   227

   228

            return (event_name, event_description, event_start, event_end)

   229

   230

        except FormError, e :

   231

            # list it

   232

            self.fail_field(e)

   233

   234

            return None, None, None, None

   235

   236

    def process (self, data) :

   237

        """

   238

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

   239

   240

                data        - the submitted POST data as a MultiDict

   241

   242

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

   243

        """

   244

   245

        # bind

   246

        self.data = data

   247

   248

        # customer

   249

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

   250

   251

        # contact

   252

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

   253

   254

        if self.contact_customer and not self.customer_id :

   255

            # TODO: be really smart?

   256

            pass

   257

   258

        # event

   259

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

   260

   261

        return not self.errors

   262

   263

    def load (self, order) :

   264

        """

   265

            Load our field values from the given Order.

   266

        """

   267

   268

        if order.customer :

   269

            self.customer_id        = order.customer.id

   270

            self.customer_name      = order.customer.name

   271

   272

        if order.contact :

   273

            self.contact_id         = order.contact.id

   274

            self.contact_name       = order.contact.name

   275

            self.contact_phone      = order.contact.phone

   276

            self.contact_email      = order.contact.email

   277

   278

        self.event_name         = order.event_name

   279

        self.event_description  = order.event_description

   280

        self.event_start        = order.event_start

   281

        self.event_end          = order.event_end

   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])

   298

   299

        if customer_id :

   300

            sql = sql.order_by((db.contacts.c.customer_id == customer_id))

   301

   302

        return self.app.query(sql)

   303

   304

   305

    def render_customer_input (self) :

   306

        """

   307

            Render HTML for customer_id/name field inputs.

   308

        """

   309

   310

        # all known customers

   311

        customers = list(self.build_customer_list())

   312

   313

        return (

   314

            self.render_select_input('customer_id', [(0, u"Luo uusi")] + customers, self.customer_id),

   315

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

   316

   317

            tags.script(r"$(document).ready(function () { $('#customer_id').formSelectsPreset({textTarget: $('#customer_name')}); });"),

   318

        )

   319

   320

    def render_contact_input (self) :

   321

        """

   322

            Render HTML for contact name field <input>s

   323

        """

   324

        # recommended contacts for selected customer, if known

   325

        contacts = list(self.build_contact_list(self.customer_id))

   326

   327

        return (

   328

            self.render_select_input('contact_id', [(0, u"Luo uusi")] + [(id, name) for id, name, phone, email in contacts], self.contact_id),

   329

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

   330

   331

            tags.script("""\

   332

$(document).ready(function () { 

   333

    contact_phones = %(phones)s;

   334

    contact_emails = %(emails)s;

   335

   336

    $('#contact_id').formSelectsPreset({

   337

        textTarget: $('#contact_name'),

   338

   339

        mapTargets: [

   340

            [$('#contact_phone'), contact_phones],

   341

            [$('#contact_email'), contact_emails]

   342

        ]

   343

    });

   344

});

   345

""" %       dict(

   346

                phones  = json.dumps(dict((row[db.contacts.c.id], row[db.contacts.c.phone]) for row in contacts)),

   347

                emails  = json.dumps(dict((row[db.contacts.c.id], row[db.contacts.c.email]) for row in contacts)),

   348

            )),

   349

        )

   350

   351

    def render_event_input (self) :

   352

        """

   353

            Render HTML for event start/end field <input>s

   354

        """

   355

   356

        return (

   357

            self.render_datetime_input('event_start', self.event_start),

   358

            " - ",

   359

            self.render_datetime_input('event_end', self.event_end),

   360

   361

            tags.script(r"""

   362

$(document).ready(function () { 

   363

    var event_start = $('#event_start');

   364

    var event_end = $('#event_end');

   365

   366

    // XXX: datetimepicker breaks beforeShow completely (event having one breaks)

   367

    event_start.change(function () {

   368

        // copy value as default

   369

        var start_date = event_start.datetimepicker("getDate");

   370

   371

        if (start_date) {

   372

            event_end.datetimepicker("option", {

   373

                defaultDate: start_date,

   374

                minDate: start_date,

   375

            });

   376

        }

   377

    });

   378

   379

    // init default as well

   380

    event_start.change();

   381

});"""      ),

   382

   383

        )

   384

   385

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

   386

        """

   387

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

   388

   389

                action          - the target URL for the form to POST to

   390

                submit          - label for the submit button

   391

                return_url      - URL to return to if form is abandoned

   392

        """

   393

   394

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

   395

            (

   396

                tags.h3(u"Lomakkeessa oli virheitä"),

   397

                tags.p(u"Korjaa lomake ja lähetä uudelleen"),

   398

   399

                tags.ul(class_='errors')(

   400

                    tags.li(tags.a(href='#' + error.field)(

   401

                        tags.em(error.field),

   402

                        error.message,

   403

                    )) for field_errors in self.errors.itervalues() for error in field_errors

   404

                ),

   405

            ) if self.errors else None,

   406

   407

            tags.fieldset(

   408

                tags.legend(u"Tilaaja"),

   409

   410

                tags.ol(

   411

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

   412

                        self.render_customer_input()

   413

                    )),

   414

   415

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

   416

                        self.render_contact_input()

   417

                    )),

   418

   419

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

   420

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

   421

                    )),

   422

   423

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

   424

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

   425

                    )),

   426

                ),

   427

            ),

   428

   429

            tags.fieldset(

   430

                tags.legend(u"Tapahtuma"),

   431

   432

                tags.ol(

   433

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

   434

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

   435

                    )),

   436

   437

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

   438

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

   439

                    )),

   440

   441

                    self.render_form_field('event_start', u"Ajankohta", 

   442

                        (

   443

                            u"Tapahtuman ajankohta (kamat noudetaan - palautetaan)", 

   444

                            tags.br(), 

   445

                            u"(%s)" % (datetime.datetime.now().strftime(self.DATETIME_FORMAT)),

   446

                        ), 

   447

                        (self.render_event_input()),

   448

                    ),

   449

                ),

   450

            ),

   451

   452

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

   453

            self.render_reset_button(u"Unohda koko juttu...", return_url) if return_url else None,

   454

        )

   455

   456

class OrderContractForm (BaseForm) :

   457

    """

   458

        Form for generating an order's contract document

   459

    """

   460

   461

    DEFAULT_PLACE = u"Otaniemi"

   462

   463

    DEFAULT_TEXT = u"""\

   464

# Vuokrasopimus

   465

### Teekkarispeksi ry AV-tekniikka

   466

   467

## Sopimusehdot

   468

   469

1.  ## Osapuolet

   470

    1.  Teekkarispeksi ry (Y-tunnus 1888541-7), jäljempänä “Vuokranantaja”.

   471

    2.  {order.customer.name}, jäljempänä “Vuokraaja”. 1.1 ja 1.2 jäljempänä yhdessä “osapuolet”.

   472

   473

2.  ## Kaluston lainaaminen

   474

    1.  ### Yleistä

   475

        Tässä sopimuksessa sovitaan toiminnasta Vuokranantajan lainatessa tanssimattoja Vuokraajalle.

   476

   477

    2.  ### Vuokranantajan velvollisuudet

   478

        Vuokranantaja sitoutuu toimittamaan sovittuna ajankohtana Vuokraajalle erikseen sovittava (liite) määrä tanssimattoja.

   479

   480

    3.  ### Blaa Blaa

   481

        Etc.

   482

   483

3. ## Tätä sopimusta ja sitä koskevia erimielisyyksiä koskevat määräykset

   484

    1.  ### Sopimuksen voimassaolo

   485

        Sopimus on osapuolia sitova sen jälkeen, kun osapuolet ovat sen allekirjoittaneet.

   486

   487

    2.  ### Muutosten tekeminen

   488

        Muutokset sopimukseen on tehtävä kirjallisesti molempien osapuolten kesken.

   489

   490

    3.  ### Blaa Blaa

   491