editdb.py

Network Administration Visualized 网络管理可视化源码

    defaultSortBy = None            # Default columnnumber sorted by
    headingDefinition = None        # list of tuples (heading,show sort link)
    cellDefintion = None            # cellDefinition list
    where = None                    # List of id's (strings)
    sortingOn = True                # Show links for sorting the list

    # SQL filters
    filters = None
    filterConfirm = 'cn_filter'
    filterConfirmText = 'Update list'
    selectedId = None

    def __init__(self,req,struct,sort,deleteWhere=None):
        self.headings = []
        self.rows = []

        if sort:
            sort = int(sort)
        self.sortBy = sort
        self.tableName = struct.tableName
        self.tableIdKey = struct.tableIdKey
        self.basePath = struct.basePath
        self.deleteWhere = deleteWhere
        self.formAction = self.basePath + 'edit'
        self.filterAction = self.basePath + 'list'

        if deleteWhere:
            self.buttonTypeOverride = entryListCell.HIDDEN
            self.hideFirstHeading = True
            self.where = deleteWhere
            title = 'Are you sure you want to delete the ' + \
                    'selected '
            if len(deleteWhere) > 1:
                title += struct.plural
            else:
                title += struct.singular
            self.title = title + '?'
            self.sortingOn = False
            self.buttonsTop = None
            self.buttonsBottom = [(self.CNAME_CONFIRM_DELETE, 'Delete'),
                                  (self.CNAME_CANCEL, 'Cancel')]
        else:
            self.title = 'Edit ' + struct.plural
            self.sortingOn = True

    def fill(self,req):
        """ Fill the list with data from the database. """
        
        # No filters if this is a delete list
        if self.deleteWhere:
            self.filters = None
        # Make filters
        if self.filters:
            self.makeFilters(req)

        # Make headings
        i = 0
        for heading,sortlink,sortFunction in self.headingDefinition:
            if self.hideFirstHeading:
                heading = ''
                self.hideFirstHeading = False
            if self.sortBy:
                currentOrder = self.sortBy
            else:
                currentOrder = self.defaultSortBy
            s = i
            if i == currentOrder:
                # Reverse sort?
                s = -i
            url = self.basePath + 'list?sort=' + str(s)
            if sortlink and self.sortingOn:
                self.headings.append(entryListCell(heading,
                                                    url))
            else:
                self.headings.append(entryListCell(heading,
                                                    None))
            i = i + 1

        # Check filters and decide if we're going to show list
        renderList = True
        filterSettings = []
        if self.filters:
            renderList = False
            for filter in self.filters:
                # filter[10] is selected id in filter
                if filter[10]:
                    # Something is selected, show list
                    renderList = True
                    # filter[6] is tableIdKey
                    filterSettings.append((filter[10],filter[6]))

        # Skip filling if no result from filter
        if renderList:
            # Preparse tooltips, etc.
            for sqlQuery,definition in self.cellDefinition:
                for column in definition:
                    for cell in column:
                        if type(cell) is list:
                            # This cell definition is a list, as opposed to
                            # a tuple, so we must prefetch some data for the
                            # parse function
                            # Must prefetch data for this column
                            for tooltipDef in cell:
                                # There can be one or more defintions per cell
                                sql = tooltipDef[0]
                                # column[2] is reserved for data
                                tooltipDef[2] = executeSQLreturn(sql)

            # Make rows
            reverseSort = False
            if self.sortBy:
                if self.sortBy < 0:
                    self.sortBy = self.sortBy * -1
                    reverseSort = True

            for sqlTuple,definition in self.cellDefinition:
                # Create SQL query from tuple
                columns,tablenames,join,where,orderBy = sqlTuple
                sqlQuery = 'SELECT ' + columns + ' FROM ' + tablenames
                if join:
                    sqlQuery += ' %s ' % (join,)
                if where:
                    sqlQuery += ' WHERE ' + where
                # Add where clause if self.where is present
                if self.where:
                    if not where:
                        # No where defined in sqlTuple, so add it now
                        sqlQuery += ' WHERE '
                    else:
                        # Else, these are additional so add AND
                        sqlQuery += ' AND '
                    first = True
                    sqlQuery += ' ('
                    for id in self.where:
                        if not first:
                            sqlQuery += 'OR'
                        sqlQuery += " %s.%s='%s' " % (self.tableName,
                                                      self.tableIdKey,id)
                        if first:
                            first = False
                    sqlQuery += ') '
                # Add where clause if filterSettings is present
                for filter in filterSettings:
                    if not where:
                        # No where defined in sqlTuple, so add it now
                        sqlQuery += ' WHERE '
                    else:
                        # Else, these are additional so add AND
                        sqlQuery += ' AND '
                    sqlQuery += filter[1] + "='" + filter[0] + "' "
                if orderBy:
                    sqlQuery += ' ORDER BY ' + orderBy                                
                fetched = executeSQLreturn(sqlQuery)
                for row in fetched:
                    id = row[0]
                    cells = []
                    for text,url,buttonType,image,tooltip in definition:
                        if buttonType and self.buttonTypeOverride:
                            buttonType = self.buttonTypeOverride
                        cells.append(entryListCell(self.parse(text,row),
                                                   self.parse(url,row,True),
                                                   buttonType,
                                                   image,
                                                   self.parse(tooltip,row))) 
                    
                    sortKey = None
                    if self.sortBy:
                        sortKey = row[self.sortBy]
                    self.rows.append([sortKey,(id,cells)])
            if self.sortBy:
                if self.headingDefinition[self.sortBy][2]:
                    # Optional compare method
                    self.rows.sort(self.headingDefinition[self.sortBy][2])
                else:
                    self.rows.sort()
                if reverseSort:
                    self.rows.reverse()

    def parse(self,parseString,currentRow,url=False):
        """ Parses format strings used by the list definitions. """
        result = None
        if type(parseString) is int:
            # parseString refers to integer column
            result = [currentRow[parseString]]
        elif type(parseString) is str:
            parseString = parseString.replace('{p}',self.basePath)
            parseString = parseString.replace('{id}',str(currentRow[0]))
            parseString = parseString.replace('{descr}',str(currentRow[1]))
            if parseString.find('SELECT') == 0:
                # This string is a sql query (used by vlan)
                resultString = ''
                sqlresult = executeSQLreturn(parseString)
                for row in sqlresult:
                    for col in row:
                        resultString += col + '<br>'
                result = [resultString]    
            else:
                if url:
                    result = parseString
                else:
                    result = [parseString]
        elif type(parseString) is list:
            result = []
            for tooltipDef in parseString:
                data = tooltipDef[2]
                if data:
                    # There is preparsed data (ie. the sql returned something)
                    result.append(tooltipDef[1][0])
                    # [1][0] = Tooltip (can also be other preparsed data) header
                    for row in data:
                        if currentRow[0] == row[0]:
                            # ID's match
                            result.append(row[1])
        return result        

    def makeFilters(self,req):
        for filter in self.filters:
            text,firstEntry,sqlTuple,idFormat,optionFormat,\
            controlName,tableId,table,fields = filter
           
            optionsList = []
            if firstEntry:
                firstEntry = ([firstEntry[0]],[firstEntry[1]])
                optionsList.append(firstEntry)
            # Make sql
            sql = "SELECT " + sqlTuple[0] + " FROM " + sqlTuple[1] + " "
            if sqlTuple[2]:
                sql += sqlTuple[2] + " "
            if sqlTuple[3]:
                sql += "WHERE " + sqlTuple[3] + " "
            if sqlTuple[4]:
                sql += "ORDER BY " + sqlTuple[4]
            result = executeSQLreturn(sql)
            for row in result:
                id = self.parse(idFormat,row)
                text = self.parse(optionFormat,row)
                optionsList.append((id,text))
            filter.append(optionsList)
            # Selected id
            selected = None
            if self.selectedId:
                entry = table(self.selectedId)
                fieldList = fields.split('.')
                for field in fieldList:
                    entry = getattr(entry,field)
                selected = str(entry) 
            if req.form.has_key(controlName):
                if len(req.form[controlName]):
                    selected = req.form[controlName]
            filter.append(selected)

# Class representing a form, used by the template
class editForm:
    """ Class representing a form element, the main component of every
        edit page. Each form element can have any number of editbox
        objects added to it. """
    
    # For the template
    method = 'post'
    action = None
    title = None
    error = None
    status = None
    backlink = None
    enctype = 'application/x-www-form-urlencoded'

    # Text and controlname
    textConfirm = None
    cnameConfirm = 'form_confirm'
    showConfirm = True

    textCancel = 'Cancel'
    cnameCancel = 'form_cancel'
    showCancel = True
    actionCancel = BASEPATH

    # Only used for netboxes (see template)
    # 'submit_delete' is fetched by the same handler as when deleting multiple
    # entities from a list
    textDelete = 'Delete'
    cnameDelete = 'submit_delete'
    showDelete = True

    # Used by edit netbox in the intermediate
    CNAME_CONTINUE = 'cname_continue'

    # List of editboxes to display
    editboxes = []

    def __init__(self,cnameConfirm=None):
        if cnameConfirm:
            self.cnameConfirm = cnameConfirm
 
        self.editboxes = []

    def add(self,box):
        """ Add an editbox object to this form element. """
        self.editboxes.append(box)

class inputText:
    """ Class representing a textinput html control. """

    type = 'text'
    name = None
    maxlength = None
    
    def __init__(self,value='',size=22,maxlength=None,disabled=False):
        self.value = value
        self.disabled = disabled
        self.size = str(size)
        if maxlength:
            self.maxlength = str(maxlength)

class inputTreeSelect:
    """ Container class for treeselects. Used to get treeselect in the 
        same format as all the other inputs used by the template. """

    type = 'treeselect'
    name = None
    treeselect = None
    disabled = False

    def __init__(self,treeselect):
        self.value = ''
        self.treeselect = treeselect

class inputSelect:
    """ Class representing a select input html control. """

    type = 'select'
    name = None
    
    def __init__(self,options=None,table=None,attribs=None,disabled=False):
        self.value = ''
        self.options = options
        self.attribs = attribs
        self.disabled = disabled

        if table:
            self.options = table.getOptions() 

class inputMultipleSelect:
    """ Class representing a multiple select input html control. """
    type = 'multipleselect'
    name = None
    value = []
    def __init__(self,options=None,table=None,disabled=False):
        self.options = options
        self.disabled = disabled