def reportDetailsTable(self,
pageName,
container,
headers,
headersDescription,
details,
detailsTranslation,
thumb=None):
page = self.reportManager.createPage(self.__reportName, pageName)
reportTable = page.addDetailTable(pageName, headersDescription)
for record in container:
headersTable = ()
flag = None
for header in headers:
res = getattr(record, header)()
if res != None:
flag = 1
headersTable += (res, )
if not flag:
continue
tempTable = []
for idx in range(len(details)):
try:
res = getattr(record, details[idx])()
if res:
tempTable.append((
detailsTranslation[idx],
res,
))
except:
pass
thumbData = None
if thumb:
thumbData = ()
for f in thumb:
try:
res = getattr(record, f)()
if res:
thumbData += (res, )
except Exception as e:
pass
if len(thumbData) != len(thumb):
thumbData = None
detailsTable = TableFragment(
self.translator.translate("Details"),
self.translator.translate(['Description', "Value"]), tempTable)
reportTable.addRow(headersTable, detailsTable, thumbData)
self.reportManager.addPage(page)
def generateRow(self, proc):
tabFragment = TabFragment("")
if proc.args and len(proc.args) > 0:
argumentTable = []
for argname in proc.args.keys():
var = proc.args[argname]
if var.type() == typeId.List:
i = 1
vlist = var.value()
for vvar in vlist:
row = [argname + ' (' + str(i) + ')', str(vvar)]
argumentTable.append(row)
i += 1
else:
row = [argname, str(var)]
argumentTable.append(row)
tabFragment.addTab(
"Arguments",
TableFragment("", ["argument", "value"], argumentTable))
if len(proc.res):
resultTable = []
self.variantToTable("", Variant(proc.res), resultTable)
tabFragment.addTab(
"Result", TableFragment("", ["result", "value"], resultTable))
if proc.error_result != '':
tabFragment.addTab(
"Error",
TextFragment("", proc.error_result.replace('\n', '<br>')))
row = ([
str(proc.pid),
str(proc.name),
str(proc.state),
str(proc.stateinfo),
str(self.procDuration(proc)),
], tabFragment)
return row
def report(self, page):
headerProperties = ['ProductName', 'RegisteredOwner', 'InstallDate']
versionTable = page.addDetailTable(
self.translator.translate("Version"),
self.translator.translate(headerProperties))
for node, versions in self.__versions.iteritems():
for version in versions:
detailTable = TableFragment(
self.translator.translate("Details"),
self.translator.translate(["Description", "Value"]),
version.details())
versionTable.addRow(version.table(headerProperties),
detailTable)
def report(self, root):
self.reportManager = ReportManager()
self.translator = AccountTranslator()
for nodeID in self.__accountInfo.iterkeys():
node = VFS.Get().getNodeById(nodeID)
info = self.__accountInfo[nodeID]
categoryName = self.translator.translate(
"Operating system") + " " + root.name().translate(
None, "!@#$%^&'\/?")
page = self.reportManager.createPage(
categoryName,
self.translator.translate("Users") + " (" + node.name() + ')')
tableHeader = ["userName", "RID", "lastLoginDate", "logins"]
headerTranslation = []
translationMap = {}
translationMap.update(UserV.Translate().details())
translationMap.update(UserF.Translate().details())
for name in tableHeader:
headerTranslation.append(translationMap[name])
userTable = page.addDetailTable(
self.translator.translate("Accounts"), headerTranslation)
for user in info.users():
tempTable = []
for attr, description in user.details().iteritems():
try:
value = getattr(user, attr)()
if value:
tempTable.append((description, value))
except AttributeError:
pass
detailTable = TableFragment(
self.translator.translate("Details"), [
self.translator.translate('Key'),
self.translator.translate('Value')
], tempTable)
userTable.addRow((user.userName(), user.RID(),
user.lastLoginDate(), user.logins()),
detailTable)
groupTable = []
gtr = GroupC.Translate()
headerTranslation = []
for m in ["name", "ID", "members"]:
headerTranslation.append(gtr.translate(m))
for group in info.groups():
groupTable.append((group.name(), group.ID(), group.members()))
page.addTable(gtr.translate("groups"), headerTranslation,
groupTable)
self.reportManager.addPage(page)
def report(self, page):
translator = NetworkTranslator()
interfaceTable = page.addDetailTable(
translator.translate("Interface"),
translator.translate(
['Name', 'IPAddress', 'Mask', 'Gateway', 'DomainName']))
for node, interfaces in self.__interfaces.iteritems():
for interface in interfaces:
detailTable = TableFragment(translator.translate("Details"), [
translator.translate('Name'),
translator.translate('Value')
], interface.details())
ipConfig = interface.ipConfig()
name = interface.name()
if not (name == interface.guid()
and ipConfig == (None, None, None, None)):
interfaceTable.addRow((name, ) + ipConfig, detailTable)
def __init__(self, parent):
self.ppStateWidget = parent
self.tree = parent.tree
reportManager = ReportManager()
page = reportManager.createPage("Information", "Scanner")
page.addText("Duration", str(self.ppStateWidget.lastDuration))
tableHeader = [
"Root",
"Items",
]
detailTable = page.addDetailTable("Scanner", tableHeader)
for itemId in xrange(self.tree.topLevelItemCount()):
item = self.tree.topLevelItem(itemId)
modulesTable = []
moduleTableName = ""
moduleFragment = None
if item.childCount() <= 1:
for childID in xrange(item.childCount()):
child = item.child(childID)
moduleTableName = str(child.text(0).toUtf8()) + " (" + str(
child.text(1).toUtf8()) + ")"
if child.childCount() > 0:
for grandChildID in xrange(child.childCount()):
grandChild = child.child(grandChildID)
modulesTable.append([
str(grandChild.text(0).toUtf8()),
str(grandChild.text(1).toUtf8())
])
if moduleTableName != "":
moduleFragment = TableFragment(moduleTableName,
["Module", "Count"],
modulesTable)
row = [str(item.text(0).toUtf8()), str(item.text(1).toUtf8())]
detailTable.addRow(row, moduleFragment)
elif item.childCount() > 1: #Analyse
analyseTable = []
for childID in xrange(item.childCount()):
child = item.child(childID)
row = [str(child.text(0).toUtf8())]
analyseTable.append(row)
page.addTable("Analyse", ["Module"], analyseTable)
reportManager.addPage(page)
def report(self):
tables = []
ncount = 0
nodesHeader = set()
for key in self.__keys:
for node, time in key.times().iteritems():
nodesHeader.add(node.absolute())
nodesHeader = ['key'] + list(nodesHeader)
rows = []
for node, time in key.times().iteritems():
row = []
for x in range(len(nodesHeader)):
row.append(None)
idx = nodesHeader.index(node.absolute())
row.remove(idx)
row.insert(idx, time)
rows.append(row)
table = TableFragment('', nodesHeader, rows)
tables.append(table)
return tables
def report(self, page):
translator = NetworkTranslator()
if len(self.__networks) == 0:
return
header = translator.translate(
['Name', 'FirstConnection', 'LastConnection'])
networkTable = page.addDetailTable(translator.translate("Network"),
header)
for node, networks in self.__networks.iteritems():
for network in networks:
detailTable = TableFragment(
translator.translate("Details"),
translator.translate(
['DefaultGatewayMAC', 'DomainNameSuffix']), [(
network.defaultGatewayMac(),
network.dnsSuffix(),
)])
networkTable.addRow((
network.description(),
network.dateCreated(),
network.dateLastConnected(),
), detailTable)
def reportCalls(self):
page = self.reportManager.createPage(
self.__reportName, self.translator.translate("Calls"))
headersDescription = self.translator.translate(
["Members", "begin_timestamp", "is_incoming"])
reportTable = page.addDetailTable(self.translator.translate("Calls"),
headersDescription)
details = []
for call in self.__containers['Calls']:
callMembers = self.findCallMemberByName(call.name())
memberName = []
if callMembers:
for member in callMembers:
memberName.append(member.dispname())
headerTable = [
memberName,
call.begin_timestamp(),
call.is_incoming()
]
detailsTable = None
if callMembers:
tempTable = []
for member in callMembers:
tempTable.append(
(member.identity(), member.dispname(),
member.start_timestamp(), member.call_duration()), )
detailsHeaders = self.translator.translate([
"identity", "dispname", "start_timestamp", "call_duration"
])
detailsTable = TableFragment(
self.translator.translate("Details"), detailsHeaders,
tempTable)
reportTable.addRow(headerTable, detailsTable)
self.reportManager.addPage(page)
def addTable(self, title, head, data):
tableFragment = TableFragment(title, head, data)
tableFragment.connection(self)
self.fragments.append(tableFragment)
return tableFragment