root/branch/ggpolo/umitInventory/ChangesList.py @ 1005

# Copyright (C) 2007 Insecure.Com LLC.
#
# Authors: Guilherme Polo <ggpolo@gmail.com>
#
# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 2 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 
# USA

import gtk
import time
import cairo
import pango
import gobject

from umitCore.I18N import _
from umitCore.Paths import Path

from umitDB.Retrieve import InventoryRetrieve

from umitInventory.TL.Calendar import months
from umitInventory.TL.Calendar import weekdays

umitdb = Path.umitdb_ng

class ChangesList(gtk.VBox):
    def __init__(self, inv_name, host_addr, display):
        """
        Expects a valid Inventory name and a valid host address for this
        Inventory and buils a List showing short change descriptions over time.
        """
        gtk.VBox.__init__(self)

        self.inventory = inv_name
        self.hostaddr = host_addr
        self.display = display
        self.row_data = { }
        self.viewing_rows = { }
        self.invdb = InventoryRetrieve(umitdb)
        self.model = gtk.ListStore(gobject.TYPE_STRING, gobject.TYPE_STRING,
                                   gobject.TYPE_STRING)
        self.modelfilter = self.model.filter_new()
        self.tview = gtk.TreeView()

        self._create_columns()
        self._load_data(self.inventory, self.hostaddr)
        self.tview.get_selection().connect('changed', self.row_changed)

        self.show_states = self.states[:]
        self.index_states = [self.show_states.index(i) for i in self.show_states]
        
        self.modelfilter.set_visible_func(self.visible_tv, self.show_states)
        self.tview.set_model(self.modelfilter)

        self.btns_box = self._setup_top_btns()
        self._setup_columns()
        self.__layout()


    def visible_tv(self, model, iter, data):
        """
        Set "visible" items on list.
        """
        return model.get_value(iter, 0) in data


    def check_buttons(self, tb):
        """
        Do filter based on active bottom buttons.
        """
        self.index_states = [ ]
        del self.show_states[:]
    
        btns_children = self.btns_box.get_children()
        for indx, b in enumerate(btns_children[1:len(btns_children)-1]):
            if b.get_active():
                self.index_states.append(indx)
                self.show_states.append(b.get_label())
    
        self.modelfilter.refilter()
        self.viewing_rows = self.filter_rows(self.row_data, self.index_states)
        self.update_viewing_lbl()

    
    def filter_rows(self, full, states):
        """
        Filter full data to show only partial data based on states.
        """
        count = 0
        partial = { }
        for key, value in full.items():
            if value[3] in states:
                vnew = list(value)
                vnew[2] = count
                partial[count] = tuple(vnew)
                
                count += 1
        
        return partial
        
    
    def row_changed(self, tview):
        """
        Load data for selected row.
        """
        cdata = self.viewing_rows
        
        try:
            row = tview.get_selected_rows()[1][0][0]
        except IndexError: # list not filled with data yet
            return


        if cdata[row][0] == -1: # host down
            self.display.header_empty(self.hostaddr, self.inventory, 
                                      self.model[row][2])
            self.display.show_empty_hostid()
            return
        
        if cdata[row][0] == cdata[row][1]:
            # display complete text for first scan result for this host
            diff = False
            self.display.header_newhost(self.hostaddr, self.inventory,
                                        self.model[row][2])
        else:
            diff = True
            self.display.header_comparison(self.hostaddr, self.inventory,
                                           self.model[row][2])
    
        if self.display:
            self.display.make_diff(cdata[row][0], cdata[row][1])


    def __layout(self):
        """
        Layout widgets.
        """
        sw = gtk.ScrolledWindow()
        sw.add(self.tview)
        sw.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
        sw.set_size_request(-1, 220)
        self.pack_start(self.btns_box, False, False, 0)
        self.pack_start(sw, True, True, 6)
        #self.set_border_width(6)
        self.show_all()


    def _create_columns(self):
        """
        Create TreeView columns.
        """
        self.tview.columns = [None]*3
        self.tview.columns[0] = gtk.TreeViewColumn(_("Affected"))
        self.tview.columns[1] = gtk.TreeViewColumn(_("Short description of \
changes"))
        self.tview.columns[1].set_min_width(400)
        self.tview.columns[2] = gtk.TreeViewColumn(_("Date"))


    def _setup_columns(self):
        """
        Set TreeView properties and etc.
        """
        for n in range(3):
            self.tview.append_column(self.tview.columns[n])
            self.tview.columns[n].cell = gtk.CellRendererText()
            self.tview.columns[n].pack_start(self.tview.columns[n].cell, True)
            self.tview.columns[n].set_attributes(self.tview.columns[n].cell,
                                                 text=n)
            if n == 1:
                self.tview.columns[n].cell.set_property('ellipsize',
                                                        pango.ELLIPSIZE_END)
                          
        self.tview.set_search_column(1)


    def _setup_top_btns(self):
        """
        Create and connect top buttons.
        """
        box = gtk.HBox()
        box.pack_start(gtk.Label(_("Viewing Categories  ")), False, False, 0)
        for state in self.states:
            b = gtk.ToggleButton(state)
            b.set_active(True)
            b.connect('toggled', self.check_buttons)
            box.pack_start(b, False, False, 0)

        # need to change this dinamically!
        self.viewing_lbl = gtk.Label()
        self.update_viewing_lbl()
        box.pack_end(self.viewing_lbl, False, False, 0)
        return box


    def update_viewing_lbl(self):
        """
        Update viewing_lbl based on viewing_rows.
        """
        if len(self.viewing_rows):
            self.viewing_lbl.set_label(_("Viewing 1-%d of %d") % (len(self.viewing_rows),
                                                                  len(self.viewing_rows)))
        else:
            self.viewing_lbl.set_label(_("Nothing to view"))


    def format_date(self, date):
        """
        Format date to be displayed in Date column.
        """
        try:
            date.hour
        except AttributeError, e:
            print "Report this as a BUG!, sqlite didn't return column with \
timestamp format"
            print date, type(date)
            return date

        return "%02d:%02d:%02d, %02d %s %s" % (date.hour, date.minute,
                                               date.second, date.day,
                                               months[date.month-1][:3],
                                               date.year)
    

    def _load_data(self, inventory, host_addr):
        """
        Load data for especified inventory and host address.
        """
        fk_inventory = self.invdb.get_inventory_id_for_name(inventory)
        fk_address = self.invdb.get_address_id_for_address_from_db(host_addr)
        
        changes = self.invdb.get_inventory_changes(fk_inventory, fk_address)
        
        # list of states
        self.states = [ ]
        
        for indx, change in enumerate(changes):
            entry_date = change[2]
            affected = change[3]
            text = change[4]
        
            self.model.append([affected, text, self.format_date(entry_date)])
            if not affected in self.states:
                self.states.append(affected)
            
            self.row_data[indx] = (change[1], change[0], indx,
                                   self.states.index(affected))
                       
        self.viewing_rows = self.row_data.copy()
        

if __name__ == "__main__":
    # demo
    w = gtk.Window()
    w.add(ChangesList("status fixing", "192.168.254.1", None))
    w.show_all()
    w.connect('delete-event', lambda *args:gtk.main_quit())
    gtk.main()