1

# coding: utf-8

     2

     3

from svv import database as db

     4

from svv.controllers import PageHandler

     5

from svv.html import tags as html

     6

from svv.forms import BaseForm, FormError

     7

     8

import logging

     9

    10

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

    11

    12

class Item (object) :

    13

    """

    14

        Data-mapping for the items table

    15

    """

    16

    17

db.mapper(Item, db.items, properties=dict(

    18

    # forward ref to parent

    19

    parent      = db.relation(Item, remote_side=db.items.c.id, 

    20

        backref     = db.backref('children', remote_side=db.items.c.parent_id)

    21

    ),

    22

))

    23

    24

    25

class ItemForm (BaseForm) :

    26

    """

    27

        Form for editing item

    28

    """

    29

    30

    def __init__ (self, session) :

    31

        """

    32

            Use given database session for rendering form.

    33

        """

    34

    35

        super(ItemForm, self).__init__()

    36

    37

        self.session = session

    38

    39

    def defaults (self) :

    40

        self.item_id = None

    41

        self.item_name = None

    42

        self.item_detail = None

    43

        self.item_quantity = None

    44

    45

        self.item_parent_id = None

    46

    47

    def load (self, item) :

    48

        """

    49

            Load info from existing item for editing

    50

        """

    51

    52

        self.item_id = item.id

    53

        self.item_name = item.name

    54

        self.item_detail = item.detail

    55

        self.item_quantity = item.quantity

    56

    57

        self.item_parent_id = item.parent.id if item.parent else None

    58

    59

    def render_parent_select (self, name, parent_id) :

    60

        """

    61

            Render <select> for parent

    62

        """

    63

    64

        # existing items suitable as parents

    65

        # XXX: currently only top-level items, as a heuristic

    66

        parent_items = self.session.query(Item.id, Item.name).filter(Item.parent == None).all()

    67

    68

        return (

    69

            # <select> with options and selected=

    70

            self.render_select_input(name, [(0, u"---")] + parent_items, parent_id)

    71

        )

    72

    74

        """

    75

            Render <form> HTML

    76

    77

                return_url          - URL for reset button

    78

        """

    79

    83

    88

   104

                    ),

   105

                ),

   106

            ),

   107

        )

   108

   109

    def process (self, data) :

   110

        """

   111

            Process incoming POST data

   112

        """

   113

   114

        # bind

   115

        self.data = data

   116

   117

        self.do_delete = self.process_action_field('delete')

   118

   119

        if not self.do_delete :

   120

            try :

   121

                # XXX: self.process_id_field?

   122

                self.item_parent_id = self.process_integer_field('item_parent')

   123

   124

            except FormError, e :

   125

                self.fail_field(e, 'item_parent')

   126

   127

            try :

   128

                self.item_name = self.process_text_field('item_name', required=True)

   129

   130

            except FormError, e :

   131

                self.fail_field(e, 'item_name')

   132

   133

            try :

   134

                self.item_detail = self.process_text_field('item_detail')

   135

   136

            except FormError, e :

   137

                self.fail_field(e, 'item_detail')

   138

   139

            try :

   140

                self.item_quantity = self.process_integer_field('item_quantity')

   141

   142

            except FormError, e :

   143

                self.fail_field(e, 'item_quantity')

   144

   145

   146

        # ok? 

   147

        return not self.errors

   148

   149

class DeleteItemForm (BaseForm) :

   150

    """

   151

        Display a list of items to delete, and confirm

   152

    """

   153

   154

    def __init__ (self, session) :

   155

        """

   156

            Use given database session for rendering form.

   157

        """

   158

   159

        super(DeleteItemForm, self).__init__()

   160

   161

        self.session = session

   162

   163

        # list of items to delete

   164

        self.items = []

   165

   167

        """

   169

        """

   170

   172

   215

            )

   219

   221

        """

   222

            Render form with list of target items, and a confirm button

   231

        """

   232

   235

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

   236

            html.fieldset(

   238

   239

                html.ol(

   251

   252

                    html.li(

   255

   257

                    ),

   258

                )

   259

            )

   260

        )

   261

   262

    def process_items_list (self, name) :

   263

        """

   264

            Uses the incoming list of id's to build the list of Item's to delete.

   265

        """

   266

   267

        # incoming ids

   268

        item_ids = self.process_list_field('items', type=int)

   269

   270

        # look up

   271

        items = self.session.query(Item).filter(Item.id.in_(item_ids)).all()

   272

   273

        # make sure they all exist

   274

        found = [item_id for item_id in item_ids if item_id in set(item.id for item in items)]

   275

   276

        if set(found) != set(item_ids) :

   277

            raise FormError(name, found, "Some items were not found")

   278

   279

        if not items :

   280

            raise FormError(name, [], "No items were given")

   281

   282

        # ok

   283

        return items

   284

   285

    def process (self, data) :

   286

        """

   287

            Look up list of Item's to delete.

   288

   289

            Returns True if the delete is confirmed, False otherwise.

   290

        """

   291

   292

        # bind

   293

        self.data = data

   294

   295

        # load items

   296

        try :

   297

            self.items = self.process_items_list('items')

   298

   299

        except FormError, e :

   300

            self.fail_field(e, 'items')

   301

   302

        # confirm?

   303

        confirm = self.process_action_field('confirm')

   304

   305

        return not self.errors and confirm

   306

   307

class ItemView (PageHandler) :

   308

    """

   309

        Display/edit info for a single item

   310

    """

   311

   312

    def update (self, item, form) :

   313

        """

   314

            Update item data from form

   315

        """

   316

   317

        # lookup

   318

        item.parent = self.session.query(Item).get(form.item_parent_id)

   319

   320

        # modify

   321

        item.name = form.item_name

   322

        item.detail = form.item_detail

   323

        item.quantity = form.item_quantity

   324

   325

        # update

   326

        self.session.commit()

   327

   328

    def process (self, id) :

   329

        """

   330

            Update item data if POST'd

   331

        """

   332

   333

        # db

   334

        self.session = self.app.session()

   335

   336

        # item in concern

   337

        self.item = self.session.query(Item).get(id)

   338

   339

        # form

   340

        self.form = ItemForm(self.session)

   341

        self.form.load(self.item)

   342

   343

        # process?

   344

        if self.POST :

   345

            if self.form.process(self.POST) :

   346

                # update

   347

                self.update(self.item, self.form)

   348

   349

                # ok, done with item, redirect to full list view...

   350

                return self.redirect_for(InventoryView, fragment=('item-%d' % self.item.id))

   351

   352

            else :

   353

                # re-render form

   354

                return

   355

   380

    def render_content (self, id) :

   381

        """

   382

            View item's info

   383

        """

   387

   391

        return (

   401

   402

            self.form.render(

   403

                action          = self.url_for(ItemView, id=id), 

   404

                return_url      = self.url_for(InventoryView),

   405

            ),

   409

        )

   410

   411

class NewItemView (PageHandler) :

   412

    """

   413

        Create new item

   414

    """

   415

   416

    def create (self, form) :

   417

        """

   418

            Create and return new item from ItemForm data.

   419

        """

   420

   421

        item = Item()

   422

   423

        # validate and lookup parent

   424

        item.parent = self.session.query(Item).get(form.item_parent_id)

   425

   426

        # store

   427

        item.name = form.item_name

   428

        item.detail = form.item_detail

   429

        item.quantity = form.item_quantity

   430

   431

        # insert

   432

        self.session.add(item)

   433

        self.session.commit()

   434

   435

        # ok

   436

        return item

   437

   438

    def process (self) :

   439

        # db

   440

        self.session = self.app.session()

   441

   442

        self.form = ItemForm(self.session)

   443

   444

        # load POST

   445

        if self.POST :

   446

            if self.form.process(self.POST) :

   447

                # create

   448

                item = self.create(self.form)

   449

   450

                # redirect to full list view...

   451

                return self.redirect_for(InventoryView, fragment=('item-%d' % item.id))

   452

   453

            else :

   454

                # fail, just render...

   455

                return

   456

   457

        else :

   458

            # render blank form

   459

            self.form.defaults()

   460

   461

    def render_content (self) :

   462

        """

   463

            Render the proecss()'d form

   464

        """

   465

   466

        return (

   467

            self.form.render(action=self.url_for(NewItemView), legend=u"Lisää uusi", delete=True)

   468

        )

   469

   470

class DeleteItemView (PageHandler) :

   471

    """

   472

        Confirm deletion of items.

   473

    """

   474

   475

    def delete (self, form) :

   476

        """

   477

            Delete items from form

   478

        """

   479

   480

        # list of root Item's to delete, along with children

   481

        items = form.items

   482

   483

        for item in items :

   484

            self.session.delete(item)

   485

   486

        # ok

   487

        self.session.commit()

   488

   489

    def process (self) :

   490

        # db

   491

        self.session = self.app.session()

   492

   493

        # form

   494

        self.form = DeleteItemForm(self.session)

   495

   496

        # process

   497

        if self.form.process(self.POST) :

   498

            # delete

   499

            self.delete(self.form)

   500

   501

            # redirect back

   502

            return self.redirect_for(InventoryView)

   503

   504

        else :

   505

            # render

   506

            pass

   507

   508

    def render_content (self) :

   509

        return (