305 lines
9.3 KiB
Python
305 lines
9.3 KiB
Python
import os
|
|
|
|
class DisplayHTMLRaw(object):
|
|
|
|
def __init__(self, html=''):
|
|
self.html = html
|
|
|
|
def setRawHTML(self, html):
|
|
self.html = html
|
|
|
|
def _buildHTML(self):
|
|
pass
|
|
|
|
def _build(self, f, html):
|
|
if html: f.write(html)
|
|
|
|
def build(self, f):
|
|
self._buildHTML()
|
|
self._build(f, self.html)
|
|
|
|
class DisplayHTMLBlock(DisplayHTMLRaw):
|
|
|
|
def __init__(self, title=''):
|
|
super(DisplayHTMLBlock, self).__init__(html='')
|
|
self.title = title
|
|
self.cssclass = 'iwla_block'
|
|
self.title_cssclass = 'iwla_block_title'
|
|
self.value_cssclass = 'iwla_block_value'
|
|
|
|
def getTitle(self):
|
|
return self.title
|
|
|
|
def setTitle(self, value):
|
|
self.title = value
|
|
|
|
def setCSSClass(self, cssclass):
|
|
self.cssclass = cssclass
|
|
|
|
def setTitleCSSClass(self, cssclass):
|
|
self.title_cssclass = cssclass
|
|
|
|
def setValueCSSClass(self, cssclass):
|
|
self.value_cssclass = cssclass
|
|
|
|
def _buildHTML(self):
|
|
html = '<div class="%s">' % (self.cssclass)
|
|
if self.title:
|
|
html += '<div class="%s">%s</div>' % (self.title_cssclass, self.title)
|
|
html += '<div class="%s">%s</div>' % (self.value_cssclass, self.html)
|
|
html += '</div>'
|
|
|
|
self.html = html
|
|
|
|
class DisplayHTMLBlockTable(DisplayHTMLBlock):
|
|
|
|
def __init__(self, title, cols):
|
|
super(DisplayHTMLBlockTable, self).__init__(title=title)
|
|
self.cols = cols
|
|
self.rows = []
|
|
self.cols_cssclasses = ['' for e in cols]
|
|
self.rows_cssclasses = []
|
|
|
|
def appendRow(self, row):
|
|
self.rows.append(listToStr(row))
|
|
self.rows_cssclasses.append(['' for e in row])
|
|
|
|
def getCellValue(self, row, col):
|
|
if row < 0 or col < 0 or\
|
|
row >= len(self.rows) or col >= len(self.cols):
|
|
raise ValueError('Invalid indices %d,%d' % (row, col))
|
|
|
|
return self.rows[row][col]
|
|
|
|
def setCellValue(self, row, col, value):
|
|
if row < 0 or col < 0 or\
|
|
row >= len(self.rows) or col >= len(self.cols):
|
|
raise ValueError('Invalid indices %d,%d' % (row, col))
|
|
|
|
return self.rows[row][col]
|
|
|
|
def setCellCSSClass(self, row, col, value):
|
|
if row < 0 or col < 0 or\
|
|
row >= len(self.rows) or col >= len(self.cols):
|
|
raise ValueError('Invalid indices %d,%d' % (row, col))
|
|
|
|
self.rows_cssclasses[row][col] = value
|
|
|
|
def getCellCSSClass(self, row, col):
|
|
if row < 0 or col < 0 or\
|
|
row >= len(self.rows) or col >= len(self.cols):
|
|
raise ValueError('Invalid indices %d,%d' % (row, col))
|
|
|
|
return self.rows_cssclasses[row][col]
|
|
|
|
def getColCSSClass(self, col):
|
|
if col < 0 or col >= len(self.cols):
|
|
raise ValueError('Invalid indice %d' % (col))
|
|
|
|
return self.cols_cssclasses[col]
|
|
|
|
def setRowCSSClass(self, row, value):
|
|
if row < 0 or row >= len(self.rows):
|
|
raise ValueError('Invalid indice %d' % (row))
|
|
|
|
for i in range(0, self.rows_cssclasses[row]):
|
|
self.rows_cssclasses[row][i] = value
|
|
|
|
def setColCSSClass(self, col, value):
|
|
if col < 0 or col >= len(self.cols):
|
|
raise ValueError('Invalid indice %d' % (col))
|
|
|
|
self.cols_cssclasses[col] = value
|
|
|
|
def setColsCSSClass(self, values):
|
|
if len(values) != len(self.cols):
|
|
raise ValueError('Invalid values size')
|
|
|
|
self.cols_cssclasses = values
|
|
|
|
def _buildHTML(self):
|
|
html = '<table>'
|
|
if self.cols:
|
|
html += '<tr>'
|
|
for i in range (0, len(self.cols)):
|
|
title = self.cols[i]
|
|
style = self.getColCSSClass(i)
|
|
if style: style = ' class="%s"' % (style)
|
|
html += '<th%s>%s</th>' % (style, title)
|
|
html += '</tr>'
|
|
for i in range(0, len(self.rows)):
|
|
row = self.rows[i]
|
|
html += '<tr>'
|
|
for j in range(0, len(row)):
|
|
v = row[j]
|
|
style = self.getCellCSSClass(i, j)
|
|
if style: style = ' class="%s"' % (style)
|
|
html += '<td%s>%s</td>' % (style, v)
|
|
html += '</tr>'
|
|
html += '</table>'
|
|
|
|
self.html += html
|
|
|
|
super(DisplayHTMLBlockTable, self)._buildHTML()
|
|
|
|
class DisplayHTMLBlockTableWithGraph(DisplayHTMLBlockTable):
|
|
|
|
def __init__(self, title, cols, short_titles=[], nb_valid_rows=0):
|
|
super(DisplayHTMLBlockTableWithGraph, self).__init__(title=title, cols=cols)
|
|
self.short_titles = short_titles
|
|
self.nb_valid_rows = nb_valid_rows
|
|
# TOFIX
|
|
self.icon_path = '/resources/icon'
|
|
# self.icon_path = self.iwla.getConfValue('icon_path', '/')
|
|
self.raw_rows = []
|
|
self.maxes = [0 for c in cols]
|
|
|
|
def appendRow(self, row):
|
|
self.raw_rows.append(row)
|
|
super(DisplayHTMLBlockTableWithGraph, self).appendRow(row)
|
|
|
|
def appendShortTitle(self, short_title):
|
|
self.short_titles.append(short_title)
|
|
|
|
def setShortTitle(self, short_titles):
|
|
self.short_titles = short_titles
|
|
|
|
def setNbValidRows(self, nb_valid_rows):
|
|
self.nb_valid_rows = nb_valid_rows
|
|
|
|
def _computeMax(self):
|
|
for i in range(0, self.nb_valid_rows):
|
|
row = self.raw_rows[i]
|
|
for j in range(1, len(row)):
|
|
if row[j] > self.maxes[j]:
|
|
self.maxes[j] = row[j]
|
|
|
|
def _getIconFromStyle(self, style):
|
|
if style.startswith('iwla_page'): icon = 'vp.png'
|
|
elif style.startswith('iwla_hit'): icon = 'vh.png'
|
|
elif style.startswith('iwla_bandwidth'): icon = 'vk.png'
|
|
elif style.startswith('iwla_visit'): icon = 'vv.png'
|
|
elif style.startswith('iwla_search'): icon = 'vu.png'
|
|
else: return ''
|
|
|
|
return '%s/%s' % (self.icon_path, icon)
|
|
|
|
def _buildHTML(self):
|
|
self._computeMax()
|
|
|
|
html = '<table>'
|
|
html += '<tr>'
|
|
for i in range(0, self.nb_valid_rows):
|
|
row = self.rows[i]
|
|
html += '<td>'
|
|
for j in range(1, len(row)):
|
|
style = self.getColCSSClass(j)
|
|
icon = self._getIconFromStyle(style)
|
|
if not icon: continue
|
|
if style: style = ' class="%s"' % (style)
|
|
alt = '%s: %s' % (row[j], self.cols[j])
|
|
if self.maxes[j]:
|
|
height = int((self.raw_rows[i][j] * 100) / self.maxes[j])
|
|
else:
|
|
height = 0
|
|
html += '<img%s align="bottom" src="%s" height="%d" width="6" alt="%s" title="%s" />' % (style, icon, height, alt, alt)
|
|
html += '</td>'
|
|
html += '</tr>'
|
|
html += '<tr>'
|
|
for i in range(0, len(self.short_titles)):
|
|
style = self.getCellCSSClass(0, j)
|
|
if style: style = ' class="%s"' % (style)
|
|
html += '<td%s>%s</td>' % (style, self.short_titles[i])
|
|
html += '</tr>'
|
|
html += '</table>'
|
|
|
|
self.html += html
|
|
|
|
super(DisplayHTMLBlockTableWithGraph, self)._buildHTML()
|
|
|
|
class DisplayHTMLPage(object):
|
|
|
|
def __init__(self, title, filename, css_path):
|
|
self.title = title
|
|
self.filename = filename
|
|
self.blocks = []
|
|
self.css_path = css_path
|
|
|
|
def getFilename(self):
|
|
return self.filename;
|
|
|
|
def getBlock(self, title):
|
|
for b in self.blocks:
|
|
if title == b.getTitle():
|
|
return b
|
|
return None
|
|
|
|
def appendBlock(self, block):
|
|
self.blocks.append(block)
|
|
|
|
def build(self, root):
|
|
filename = root + self.filename
|
|
|
|
base = os.path.dirname(filename)
|
|
if not os.path.exists(base):
|
|
os.makedirs(base)
|
|
|
|
f = open(filename, 'w')
|
|
f.write('<!DOCTYPE html>')
|
|
f.write('<html>')
|
|
f.write('<head>')
|
|
f.write('<meta http-equiv="Content-type" content="text/html; charset=UTF-8" />')
|
|
for css in self.css_path:
|
|
f.write('<link rel="stylesheet" href="%s"/>' % (css))
|
|
if self.title:
|
|
f.write('<title>%s</title>' % (self.title))
|
|
f.write('</head>')
|
|
for block in self.blocks:
|
|
block.build(f)
|
|
f.write('</body></html>')
|
|
f.close()
|
|
|
|
class DisplayHTMLBuild(object):
|
|
|
|
def __init__(self, iwla):
|
|
self.pages = []
|
|
self.iwla = iwla
|
|
|
|
def getPage(self, filename):
|
|
for page in self.pages:
|
|
if page.getFilename() == filename:
|
|
return page
|
|
return None
|
|
|
|
def addPage(self, page):
|
|
self.pages.append(page)
|
|
|
|
def build(self, root):
|
|
display_root = self.iwla.getConfValue('DISPLAY_ROOT', '')
|
|
for res_path in self.iwla.getResourcesPath():
|
|
target = os.path.abspath(res_path)
|
|
link_name = os.path.join(display_root, res_path)
|
|
if not os.path.exists(link_name):
|
|
os.symlink(target, link_name)
|
|
|
|
for page in self.pages:
|
|
page.build(root)
|
|
|
|
def bytesToStr(bytes):
|
|
suffixes = ['', ' kB', ' MB', ' GB', ' TB']
|
|
|
|
for i in range(0, len(suffixes)):
|
|
if bytes < 1024: break
|
|
bytes /= 1024.0
|
|
|
|
if i:
|
|
return '%.02f%s' % (bytes, suffixes[i])
|
|
else:
|
|
return '%d%s' % (bytes, suffixes[i])
|
|
|
|
def _toStr(v):
|
|
if type(v) != str: return str(v)
|
|
else: return v
|
|
|
|
def listToStr(l): return map(lambda(v) : _toStr(v), l)
|