svv/items.py
changeset 53 06dad873204d
parent 48 06fa83c8c0bb
child 55 433842c04ab1
equal deleted inserted replaced
52:b06e34219441 53:06dad873204d
    68         return (
    68         return (
    69             # <select> with options and selected=
    69             # <select> with options and selected=
    70             self.render_select_input(name, [(0, u"---")] + parent_items, parent_id)
    70             self.render_select_input(name, [(0, u"---")] + parent_items, parent_id)
    71         )
    71         )
    72 
    72 
    73     def render (self, action, legend=u"Laitejuttu", return_url=None, delete_action=None) :
    73     def render (self, action, legend=u"Laitetiedot", return_url=None) :
    74         """
    74         """
    75             Render <form> HTML
    75             Render <form> HTML
    76 
    76 
    77                 return_url          - URL for reset button
    77                 return_url          - URL for reset button
    78                 delete_action       - (optional) URL to delete-item option
    78         """
    79         """
    79 
    80 
    80         return html.form(action=action, method='POST')(
    81         return (
    81             html.fieldset(
    82             html.form(action=action, method='POST')(
    82                 html.legend(legend),
    83                 html.fieldset(
    83 
    84                     html.legend(legend),
    84                 html.ol(
    85 
    85                     self.render_form_field('item_parent', u"Case", u"Missä laite sijaitsee", (
    86                     html.ol(
    86                         self.render_parent_select('item_parent', self.item_parent_id)
    87                         self.render_form_field('item_parent', u"Case", u"Missä laite sijaitsee", (
    87                     )),
    88                             self.render_parent_select('item_parent', self.item_parent_id)
    88 
    89                         )),
    89                     self.render_form_field('item_name', u"Nimi", u"Lyhyt nimi", (
    90 
    90                         self.render_text_input('item_name', self.item_name)
    91                         self.render_form_field('item_name', u"Nimi", u"Lyhyt nimi", (
    91                     )),
    92                             self.render_text_input('item_name', self.item_name)
    92 
    93                         )),
    93                     self.render_form_field('item_detail', u"Kuvaus", u"Tarkempi kuvaus", (
    94 
    94                         self.render_text_input('item_detail', self.item_detail, multiline=True)
    95                         self.render_form_field('item_detail', u"Kuvaus", u"Tarkempi kuvaus", (
    95                     )),
    96                             self.render_text_input('item_detail', self.item_detail, multiline=True)
    96 
    97                         )),
    97                     self.render_form_field('item_quantity', u"Kappalemäärä", u"Jos on esim. useampi piuha/adapter, kirjaa niitten määrä; muuten jätä tyhjäksi", (
    98 
    98                         self.render_text_input('item_quantity', self.item_quantity)
    99                         self.render_form_field('item_quantity', u"Kappalemäärä", u"Jos on esim. useampi piuha/adapter, kirjaa niitten määrä; muuten jätä tyhjäksi", (
    99                     )),
   100                             self.render_text_input('item_quantity', self.item_quantity)
   100                     
   101                         )),
   101                     html.li(
   102                         
   102                         self.render_submit_button(u"Tallenna"),
   103                         html.li(
   103                         self.render_reset_button(u"Palaa inventaariin", return_url) if return_url else None,
   104                             self.render_submit_button(u"Tallenna"),
       
   105                             self.render_reset_button(u"Palaa inventaariin", return_url) if return_url else None,
       
   106                         ),
       
   107                     ),
   104                     ),
   108                 ),
   105                 ),
   109             ),
   106             ),
   110 
       
   111             html.form(action=delete_action, method='POST')(
       
   112                 html.fieldset(
       
   113                     html.legend(u"Poistaminen"),
       
   114 
       
   115                     html.input(type='hidden', name='items', value=self.item_id),
       
   116 
       
   117                     html.ol(
       
   118                         html.li(
       
   119                             html.input(type='submit', name='delete', value=u"Poista"),
       
   120                         )
       
   121                     )
       
   122                 ),
       
   123             ) if delete_action else None
       
   124         )
   107         )
   125 
   108 
   126     def process (self, data) :
   109     def process (self, data) :
   127         """
   110         """
   128             Process incoming POST data
   111             Process incoming POST data
   178         self.session = session
   161         self.session = session
   179 
   162 
   180         # list of items to delete
   163         # list of items to delete
   181         self.items = []
   164         self.items = []
   182     
   165     
   183     def render_items_list (self, name, items) :
   166     def load (self, items) :
       
   167         """
       
   168             Init set of items to delete
       
   169         """
       
   170 
       
   171         self.items = items
       
   172 
       
   173     def render_items_list (self, name, items, visible=None) :
   184         """
   174         """
   185             Render list of items to delete.
   175             Render list of items to delete.
   186         """
   176 
   187 
   177                 visible         - display list of items in addition the rendering the <input>'s
   188         def render_items (items) :
   178         """
   189             return (
   179 
   190                 html.ul(
   180         def render_items (items, visible) :
   191                     render_item(item) for item in items
   181             if not items :
   192                 ) if items else None
   182                 # blank
       
   183                 return None
       
   184 
       
   185             elif visible :
       
   186                 # nested list
       
   187                 return html.ul(
       
   188                     render_item(item, True) for item in items
       
   189                 )
       
   190 
       
   191             else :
       
   192                 # just the controls
       
   193                 return [render_item(item, False) for item in items]
       
   194 
       
   195         def render_item (item, visible) :
       
   196             # the form field
       
   197             field = html.input(type='hidden', name='items', value=item.id),
       
   198 
       
   199             if visible :
       
   200                 return html.li(
       
   201                     field,
       
   202 
       
   203                     item.name if visible else None,
       
   204 
       
   205                     render_items(item.children, visible),
       
   206                 )
       
   207             else :
       
   208                 # just the input
       
   209                 return field
       
   210         
       
   211         if visible :
       
   212             # div with nested <li>s
       
   213             return html.div(class_='value')(
       
   214                 render_items(items, True),
   193             )
   215             )
   194 
   216         else :
   195 
   217             # just the <input>s
   196         def render_item (item) :
   218             return render_items(items, False)
   197             return html.li(
   219 
   198                 html.input(type='hidden', name='items', value=item.id),
   220     def render (self, legend=None, delete_action=None, confirm_action=None, return_url=None, item_listing=None) :
   199                 item.name,
       
   200                 render_items(item.children),
       
   201             )
       
   202 
       
   203         return html.div(class_='value')(
       
   204             render_items(items),
       
   205         )
       
   206 
       
   207     def render (self, action, return_url) :
       
   208         """
   221         """
   209             Render form with list of target items, and a confirm button
   222             Render form with list of target items, and a confirm button
   210         """
   223                 
       
   224                 legend              - form title
       
   225                 delete_action       - URL for initial confirm stage submit
       
   226                 confirm_action      - URL for final delete stage submit
       
   227                 reutrn_url          - URL for cancel button
       
   228                 item_listing        - display recursive item listing for confirmation
       
   229 
       
   230             Supply either delete_action or confirm_action, but not both
       
   231         """
       
   232 
       
   233         action = delete_action or confirm_action
   211 
   234 
   212         return html.form(action=action, method='POST')(
   235         return html.form(action=action, method='POST')(
   213             html.fieldset(
   236             html.fieldset(
   214                 html.legend(u"Poistettavat laitteet"),
   237                 html.legend(legend),
   215 
   238 
   216                 html.ol(
   239                 html.ol(
   217                     self.render_form_field('items', u"Poistettavat laitteet", u"Kaikki listatut laitteet poistetaan inventaarista", (
   240                     (
   218                         self.render_items_list('items', self.items)
   241                         # full UI field
   219                     )),
   242                         (self.render_form_field('items', u"Poistettavat laitteet", u"Kaikki listatut laitteet poistetaan inventaarista", (
       
   243                             self.render_items_list('items', self.items, visible=True)
       
   244                         ))) 
       
   245 
       
   246                             if item_listing else 
       
   247                         
       
   248                         # raw field with just the <input>s
       
   249                         (self.render_items_list('items', self.items, visible=False))
       
   250                     ),
   220 
   251 
   221                     html.li(
   252                     html.li(
   222                         self.render_submit_button(u"Varmista", 'confirm'),
   253                         self.render_submit_button(u"Poista") if delete_action else None,
       
   254                         self.render_submit_button(u"Varmista", 'confirm') if confirm_action else None,
   223                         
   255                         
   224                         self.render_reset_button(u"Peruuta", return_url),
   256                         self.render_reset_button(u"Peruuta", return_url) if return_url else None,
   225                     ),
   257                     ),
   226                 )
   258                 )
   227             )
   259             )
   228         )
   260         )
   229 
   261 
   319             
   351             
   320             else :
   352             else :
   321                 # re-render form
   353                 # re-render form
   322                 return
   354                 return
   323 
   355 
       
   356     def render_subitems_table (self, subitems) :
       
   357         """
       
   358             Render listing of child items in this item
       
   359         """
       
   360             
       
   361         return ItemTable(self).render(subitems, parent=self.item)
       
   362         
       
   363 
       
   364     def render_delete_form (self) :
       
   365         """
       
   366             Render delete form for this item
       
   367         """
       
   368 
       
   369         form = DeleteItemForm(self.session)
       
   370         form.load([self.item])
       
   371 
       
   372         return form.render(
       
   373             legend          = u"Poistaminen",
       
   374 
       
   375             delete_action  = self.url_for(DeleteItemView),
       
   376 
       
   377             item_listing    = False,
       
   378         )
       
   379 
   324     def render_content (self, id) :
   380     def render_content (self, id) :
   325         """
   381         """
   326             View item's info
   382             View item's info
   327         """
   383         """
   328 
   384         
       
   385         # ourselves
       
   386         item = self.item
       
   387 
       
   388         # items in this item
       
   389         subitems = item.children
       
   390         
   329         return (
   391         return (
   330             html.h1(u"Laite #%d" % self.item.id),
   392             html.h1("(#%d) %s" % (item.id, item.name)),
       
   393 
       
   394             html.h3(
       
   395                 html.raw(u"Sijaitsee %s:ssa" % (
       
   396                     html.a(href=self.url_for(ItemView, id=item.parent.id))(item.parent.name)
       
   397                 )),
       
   398             ) if item.parent else None,
       
   399             
       
   400             self.render_subitems_table(subitems) if subitems else None,
   331 
   401 
   332             self.form.render(
   402             self.form.render(
   333                 action          = self.url_for(ItemView, id=id), 
   403                 action          = self.url_for(ItemView, id=id), 
   334                 return_url      = self.url_for(InventoryView),
   404                 return_url      = self.url_for(InventoryView),
   335                 delete_action   = self.url_for(DeleteItemView),
       
   336             ),
   405             ),
       
   406 
       
   407             # delete form
       
   408             self.render_delete_form(),
   337         )
   409         )
   338 
   410 
   339 class NewItemView (PageHandler) :
   411 class NewItemView (PageHandler) :
   340     """
   412     """
   341         Create new item
   413         Create new item
   433             # render
   505             # render
   434             pass
   506             pass
   435     
   507     
   436     def render_content (self) :
   508     def render_content (self) :
   437         return (
   509         return (
   438             self.form.render(action=self.url_for(DeleteItemView), return_url=self.url_for(InventoryView))
   510             self.form.render(
   439         )
   511                 legend          = u"Poistettavat laitteet",
   440 
   512 
   441 class InventoryView (PageHandler) :
   513                 confirm_action   = self.url_for(DeleteItemView),
   442     """
   514 
   443         Display overview of all items
   515                 return_url      = self.url_for(InventoryView),
   444     """
   516 
   445     
   517                 item_listing    = True,
   446     def process (self) :
   518             )
   447         # db
   519         )
   448         self.session = self.app.session()
   520 
   449 
   521 class ItemTable (object) :
   450     def render_item_table (self) :
   522     """
   451         """
   523         Table of items
   452             Render HTML for full <table> of all items, sorted heirarchially (by parent)
   524     """
   453         """
   525 
   454 
   526     def __init__ (self, handler) :
   455         # listing of inventory items
   527         """
   456         items = self.session.query(Item).order_by(Item.parent).all()
   528                 handler         - the AppHandler we are running under, used for url_for etc.
       
   529         """
       
   530 
       
   531         self.handler = handler
       
   532 
       
   533     def url_for (self, *args, **kwargs) :
       
   534         """
       
   535             Proxy to handler
       
   536         """
       
   537 
       
   538         return self.handler.url_for(*args, **kwargs)
       
   539 
       
   540     def render (self, items, parent=None) :
       
   541         """
       
   542             Render table for given set of items. If parent is given, those items are assumed to be the children of that
       
   543             item.
       
   544         """
   457 
   545 
   458         return html.table(
   546         return html.table(
   459             html.caption("Kalustolistaus"),
   547             html.caption(
       
   548                 u"Kalustolistaus",
       
   549                 (
       
   550                     html.a(href=self.url_for(ItemView, id=parent.id))(
       
   551                         parent.name
       
   552                     ) if parent else None
       
   553                 ),
       
   554             ),
   460         
   555         
   461             html.thead(
   556             html.thead(
   462                 html.tr(
   557                 html.tr(
   463                     html.th(title) for title in (
   558                     html.th(title) for title in (
   464                         u"#ID",
   559                         u"#ID",
   465                         u"Case",
   560                         u"Case" if not parent else None,
   466                         u"Nimi",
   561                         u"Nimi",
   467                         u"Kuvaus",
   562                         u"Kuvaus",
   468                         u"Määrä",
   563                         u"Määrä",
   469                     )
   564                     ) if title
   470                 ),
   565                 ),
   471             ),
   566             ),
   472 
   567 
   473             html.tbody(
   568             html.tbody(
   474                 html.tr(id=('item-%d' % item.id))(
   569                 html.tr(id=('item-%d' % item.id))(
   480 
   575 
   481                     html.td(
   576                     html.td(
   482                         html.a(href=self.url_for(ItemView, id=item.parent.id))(
   577                         html.a(href=self.url_for(ItemView, id=item.parent.id))(
   483                             item.parent.name
   578                             item.parent.name
   484                         ) if item.parent else None
   579                         ) if item.parent else None
   485                     ),
   580                     ) if not parent else None,
   486 
   581 
   487                     html.td(
   582                     html.td(
   488                         html.a(href=self.url_for(ItemView, id=item.id))(
   583                         html.a(href=self.url_for(ItemView, id=item.id))(
   489                             item.name
   584                             item.name
   490                         )
   585                         )
   499                     ),
   594                     ),
   500                 ) for item in items
   595                 ) for item in items
   501             )
   596             )
   502         )
   597         )
   503 
   598 
       
   599 
       
   600 class InventoryView (PageHandler) :
       
   601     """
       
   602         Display overview of all items
       
   603     """
       
   604     
       
   605     def process (self) :
       
   606         # db
       
   607         self.session = self.app.session()
       
   608 
       
   609     def render_item_table (self) :
       
   610         """
       
   611             Render HTML for full <table> of all items, sorted heirarchially (by parent)
       
   612         """
       
   613 
       
   614         # listing of inventory items
       
   615         items = self.session.query(Item).order_by(Item.parent).all()
       
   616         
       
   617         return ItemTable(self).render(items)
       
   618 
   504     def render_item_form (self) :
   619     def render_item_form (self) :
   505         """
   620         """
   506             Render ItemForm for creating a new item
   621             Render ItemForm for creating a new item
   507         """
   622         """
   508 
   623