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 defaults (self) :

   119

        """

   120

            Update our attributes with default values

   121

        """

   122

   123

        self.customer_id = None

   124

        self.customer_name = None

   125

   126

        self.contact_id = None

   127

        self.contact_name = None

   128

        self.contact_phone = None

   129

        self.contact_email = None

   130

        self.contact_customer = None

   131

   132

        self.event_name = None

   133

        self.event_description = None

   134

   135

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

   136

   137

        # default to tomorrow afternoon

   138

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

   139

   140

        # automatically determined once start is set

   141

        self.event_end = None

   142

   143

    def process_customer (self) :

   144

        """

   145

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

   146

        """

   147

   148

        try :

   149

            customer_id = self.process_integer_field('customer_id')

   150

            customer_name = self.process_text_field('customer_name')

   151

   152

            if not customer_id and not customer_name :

   153

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

   154

   155

            return self.process_multifield(db.customers,

   156

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

   157

                (

   158

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

   159

                ),

   160

            )

   161

   162

        except FormError, e :

   163

            # list it

   164

            self.fail_field(e, 'customer_name')

   165

   166

            return None, None

   167

   168

    def process_contact (self, customer_id, customer_name) :

   169

        """

   170

            Process the incoming contact_* fields, returning 

   171

                (contact_id, contact_name, contact_phone, contact_email, contact_customer)

   172

        """

   173

   174

        try :

   175

            contact_id = self.process_integer_field('contact_id')

   176

            contact_name = self.process_text_field('contact_name')

   177

            contact_phone = self.process_text_field('contact_phone')

   178

            contact_email = self.process_text_field('contact_email')

   179

            contact_customer = customer_id

   180

   181

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

   182

                # use customer name as contact name, if otherwise missing

   183

                contact_name = customer_name

   184

   185

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

   186

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

   187

   188

            return self.process_multifield(db.contacts,

   189

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

   190

                (

   191

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

   192

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

   193

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

   194

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

   195

                ),

   196

            )

   197

   198

        except FormError, e :

   199

            # list it

   200

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

   201

   202

            return None, None, None, None, None

   203

   204

    def process_event (self) :

   205

        """

   206

            Process the incoming event_* fields, returning

   207

                (event_name, event_description, event_start, event_end)

   208

        """

   209

   210

        try :

   211

            event_name = self.process_text_field('event_name')

   212

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

   213

            event_start = self.process_datetime_field('event_start')

   214

            event_end = self.process_datetime_field('event_end')

   215

   216

            if event_end < event_start :

   217

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

   218

   219

            return (event_name, event_description, event_start, event_end)

   220

   221

        except FormError, e :

   222

            # list it

   223

            self.fail_field(e)

   224

   225

            return None, None, None, None

   226

   227

    def process (self, data) :

   228

        """

   229

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

   230

   231

                data        - the submitted POST data as a MultiDict

   232

   233

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

   234

        """

   235

   236

        # bind the raw post data

   237

        self.data = data

   238

   239

        # customer

   240

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

   241

   242

        # contact

   243

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

   244

   245

        if self.contact_customer and not self.customer_id :

   246

            # TODO: be really smart?

   247

            pass

   248

   249

        # event

   250

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

   251

   252

        return not self.errors

   253

   254

    def load (self, order) :

   255

        """

   256

            Load our field values from the given Order.

   257

        """

   258

   259

        if order.customer :

   260

            self.customer_id        = order.customer.id

   261

            self.customer_name      = order.customer.name

   262

   263

        if order.contact :

   264

            self.contact_id         = order.contact.id

   265

            self.contact_name       = order.contact.name

   266

            self.contact_phone      = order.contact.phone

   267

            self.contact_email      = order.contact.email

   268

   269

        self.event_name         = order.event_name

   270

        self.event_description  = order.event_description

   271

        self.event_start        = order.event_start

   272

        self.event_end          = order.event_end

   273

   274

    def build_customer_list (self) :

   275

        """

   276

            Query a (id, name) list of customers.

   277

        """

   278

   279

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

   280

   281

        return self.app.query(sql)

   282

   283

    def build_contact_list (self, customer_id=None) :

   284

        """

   285

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

   286

        """

   287

   288

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

   289

   290

        if customer_id :

   291

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

   292

   293

        return self.app.query(sql)

   294

   295

   296

    def render_customer_input (self) :

   297

        """

   298

            Render HTML for customer_id/name field inputs.

   299

        """

   300

   301

        # all known customers

   302

        customers = list(self.build_customer_list())

   303

   304

        return (

   305

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

   306

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

   307

   308

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

   309

        )

   310

   311

    def render_contact_input (self) :

   312

        """

   313

            Render HTML for contact name field <input>s

   314

        """

   315

        # recommended contacts for selected customer, if known

   316

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

   317

   318

        return (

   319

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

   320

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

   321

   322

            tags.script("""\

   323

$(document).ready(function () { 

   324

    contact_phones = %(phones)s;

   325

    contact_emails = %(emails)s;

   326

   327

    $('#contact_id').formSelectsPreset({

   328

        textTarget: $('#contact_name'),

   329

   330

        mapTargets: [

   331

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

   332

            [$('#contact_email'), contact_emails]

   333

        ]

   334

    });

   335

});

   336

""" %       dict(

   337

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

   338

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

   339

            )),

   340

        )

   341

   342

    def render_event_input (self) :

   343

        """

   344

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

   345

        """

   346

   347

        return (

   348

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

   349

            " - ",

   350

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

   351

   352

            tags.script(r"""

   353

$(document).ready(function () { 

   354

    var event_start = $('#event_start');

   355

    var event_end = $('#event_end');

   356

   357

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

   358

    event_start.change(function () {

   359

        // copy value as default

   360

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

   361

   362

        if (start_date) {

   363

            event_end.datetimepicker("option", {

   364

                defaultDate: start_date,

   365

                minDate: start_date,

   366

            });

   367

        }

   368

    });

   369

   370

    // init default as well

   371

    event_start.change();

   372

});"""      ),

   373

   374

        )

   375

   376

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

   377

        """

   378

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

   379

   380

                action          - the target URL for the form to POST to

   381

                submit          - label for the submit button

   382

                return_url      - URL to return to if form is abandoned

   383

        """

   384

   385

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

   386

            (

   387

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

   388

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

   389

   390

                tags.ul(class_='errors')(

   391

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

   392

                        tags.em(error.field),

   393

                        error.message,

   394

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

   395

                ),

   396

            ) if self.errors else None,

   397

   398

            tags.fieldset(

   399

                tags.legend(u"Tilaaja"),

   400

   401

                tags.ol(

   402

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

   403

                        self.render_customer_input()

   404

                    )),

   405

   406

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

   407

                        self.render_contact_input()

   408

                    )),

   409

   410

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

   411

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

   412

                    )),

   413

   414

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

   415

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

   416

                    )),

   417

                ),

   418

            ),

   419

   420

            tags.fieldset(

   421

                tags.legend(u"Tapahtuma"),

   422

   423

                tags.ol(

   424

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

   425

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

   426

                    )),

   427

   428

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

   429

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

   430

                    )),

   431

   432

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

   433

                        (

   434

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

   435

                            tags.br(), 

   436

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

   437

                        ), 

   438

                        (self.render_event_input()),

   439

                    ),

   440

                ),

   441

            ),

   442

   443

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

   444

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

   445

        )

   446

   447

class OrderContractForm (BaseForm) :

   448

    """

   449

        Form for generating an order's contract document

   450

    """

   451

   452

    DEFAULT_PLACE = u"Otaniemi"

   453

   454

    DEFAULT_TEXT = u"""\

   455

# Vuokrasopimus

   456

### Teekkarispeksi ry AV-tekniikka

   457

   458

## Sopimusehdot

   459

   460

1.  ## Osapuolet

   461

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

   462

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

   463

   464

2.  ## Kaluston lainaaminen

   465

    1.  ### Yleistä

   466

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

   467

   468

    2.  ### Vuokranantajan velvollisuudet

   469

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

   470

   471

    3.  ### Blaa Blaa

   472

        Etc.

   473

   474

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

   475

    1.  ### Sopimuksen voimassaolo

   476

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

   477

   478

    2.  ### Muutosten tekeminen

   479

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

   480

   481

    3.  ### Blaa Blaa

   482

   483

        Etc.

   484

   485

## Nouto

   486

    Aika: _______________       Paikka: _______________

   487

   488

## Palautus

   489

    Aika: _______________       Paikka: _______________

   490

        """

   491