def __init__(self, headless=True):
self.web_page = '/vivagraph/simple.html'
self.web_root = Files.path_combine(Files.parent_folder(__file__),
'../web_root')
self.api_browser = API_Browser(headless=headless).sync__setup_browser()
self.web_server = Web_Server(self.web_root)
self.render_page = Render_Page(api_browser=self.api_browser,
web_server=self.web_server)
def __init__(self,
api_browser=None,
headless=True,
web_root=None,
web_server=None):
if web_server:
self.web_server = web_server
else:
self.web_server = Web_Server(web_root)
if api_browser:
self.api_browser = api_browser
else:
self.api_browser = API_Browser(headless=headless)
def create_graph_and_send_screenshot_to_slack(self,
nodes,
edges,
graph_name=None,
screenshot=True,
team_id=None,
channel=None):
with Web_Server(
self.web_root) as web_server: # handle server start and stop
self.web_server = web_server
try:
message = f":point_right: Creating `{graph_name}` using VivaGraph JS engine with: *nodes* `{len(nodes)}` *edges* `{len(edges)}` *width* `{self.browser_width}` and *render_wait* `{self.render_wait}`\n"
slack_message(message, [], channel, team_id)
#slack_message(f':point_right: Creating graph in viva_graph with {len(nodes)} nodes', [], channel)
self.create_graph(nodes, edges)
#slack_message(f':point_right: Created graph in viva_graph with {len(nodes)} nodes', [], channel)
if screenshot:
self.calculate_browser_width_and_wait(nodes)
png_data = self.send_screenshot_to_slack(team_id, channel)
return png_data
else:
return self
except Exception as error:
message = f':red_circle: error in create_graph_and_send_screenshot_to_slack :{error}'
return slack_message(message, [], channel)
async def test_screenshot_jira(self):
chrome = Chrome()
browser = await chrome.browser()
page = (await browser.pages()).pop()
with Web_Server() as web_server:
await page.goto(web_server.url())
self.png_data = await page.screenshot()
def __init__(self, web_page, headless=True):
self.web_page = web_page
self.title = 'browser view'
self.web_root = Files.path_combine(Files.parent_folder(__file__),
'../web_root')
self.api_browser = API_Browser(headless=headless).sync__setup_browser()
self.web_server = Web_Server(self.web_root)
self.render_page = Render_Page(api_browser=self.api_browser,
web_server=self.web_server)
class Render_Page:
def __init__(self,
api_browser=None,
headless=True,
web_root=None,
web_server=None):
if web_server:
self.web_server = web_server
else:
self.web_server = Web_Server(web_root)
if api_browser:
self.api_browser = api_browser
else:
self.api_browser = API_Browser(headless=headless)
def render_file(self, html_file):
return self.render_html(Files.contents(html_file))
def render_folder(self, web_root):
with self.web_server.set_web_root(web_root):
return self.get_page_html_via_browser(self.web_server.url())
def render_html(self, html):
temp_file = Web_Server_Temp_File(self.web_server, html)
with self.web_server:
with temp_file:
result = self.get_page_html_via_browser(temp_file.url())
return result
def screenshot_html(self, html, img_file=None, clip=None):
with self.web_server:
with Web_Server_Temp_File(self.web_server, html) as temp_file:
return self.get_screenshot_via_browser(temp_file.url(),
img_file,
clip=clip)
def screenshot_file(self, html_file, img_file=None, clip=None):
return self.screenshot_html(Files.contents(html_file), img_file, clip)
def screenshot_folder(self, web_root, png_file=None, clip=None):
with self.web_server.set_web_root(web_root):
return self.get_screenshot_via_browser(png_file=png_file,
clip=clip)
def screenshot_file_in_folder(self,
web_root,
html_file,
png_file=None,
clip=None):
with self.web_server.set_web_root(web_root):
url = self.web_server.url(html_file)
return self.get_screenshot_via_browser(url=url,
png_file=png_file,
clip=clip)
def screenshot_url(self, url, img_file, clip=None):
return self.get_screenshot_via_browser(url, img_file, clip=clip)
# Sync Helper method (to allow calls to the Async methods to feel like Sync calls)
@sync
async def get_page_html_via_browser(self, url, js_code=None):
await self.api_browser.browser() # make sure browser is connected
await self.api_browser.open(url) # open url
await self.api_browser.js_execute(js_code) # execute Javascript
return await self.api_browser.html() # return raw Html
@sync
async def get_screenshot_via_browser(self,
url=None,
png_file=None,
full_page=True,
clip=None,
viewport=None,
js_code=None,
delay=None):
if clip is not None: full_page = False
if png_file is None: png_file = Files.temp_file('.png')
if url is None: url = self.web_server.url()
await self.api_browser.browser()
return await self.api_browser.screenshot(url,
full_page=full_page,
file_screenshot=png_file,
clip=clip,
viewport=viewport,
js_code=js_code,
delay=delay)
def open_file_in_browser(self, path, js_code=None):
with self.web_server as web_server:
url = web_server.url(path)
return self.get_page_html_via_browser(url, js_code)
def setUp(self):
self.web_server = Web_Server()
self.web_server.start()
class Test_Web_Server(TestCase):
def setUp(self):
self.web_server = Web_Server()
self.web_server.start()
def tearDown(self):
self.web_server.stop()
def test_path_to_file(self):
assert self.web_server.path_to_file('') == '/tmp/temp_web_server/html'
assert self.web_server.path_to_file(
'/123456') == '/tmp/temp_web_server/html/123456'
assert self.web_server.path_to_file(
'bbbb.html') == '/tmp/temp_web_server/html/bbbb.html'
assert self.web_server.path_to_file(
'aaa/bbb/ccc.html') == '/tmp/temp_web_server/html/aaa/bbb/ccc.html'
assert self.web_server.path_to_file(
'../../abc.html'
) == '/tmp/abc.html' # path traversal vulnerability
assert self.web_server.path_to_file(
'..\\..\\abc.html') == '/tmp/temp_web_server/html/..\\..\\abc.html'
def test_start_server(self):
html = self.web_server.html('')
assert '</html>' in html
class VivaGraph_Js:
def __init__(self, headless=True):
self.web_page = '/vivagraph/simple.html'
self.web_root = Files.path_combine(Files.parent_folder(__file__),
'../web_root')
self.api_browser = API_Browser(headless=headless).sync__setup_browser()
self.web_server = Web_Server(self.web_root)
self.render_page = Render_Page(api_browser=self.api_browser,
web_server=self.web_server)
# #self.base_html_file = '/vis-js/empty.html'
# self.base_html_file = '/vis-js/simple.html'
# #window.api_visjs
# self.headless = False
# self.browser = None
# common methods (move to base class)
def browser(self):
return self.api_browser
def browser_width(self, value):
self.browser().sync__browser_width(value)
return self
def load_page(self, reload=False):
if reload or self.web_page not in self.browser().sync__url():
self.render_page.open_file_in_browser(self.web_page)
return self
def create_dashboard_screenshot(self):
#clip = {'x': 1, 'y': 1, 'width': 945, 'height': 465}
clip = None
return self.browser().sync__screenshot(clip=clip)
def send_screenshot_to_slack(self, team_id, channel):
png_file = self.create_dashboard_screenshot()
return Browser_Lamdba_Helper().send_png_file_to_slack(
team_id, channel, 'risk dashboard', png_file)
def get_graph_data(self, graph_name):
params = {'params': ['raw_data', graph_name, 'details'], 'data': {}}
data = Lambda('lambdas.gsbot.gsbot_graph').invoke(params)
if type(data) is str:
s3_key = data
s3_bucket = 'gs-lambda-tests'
tmp_file = S3().file_download_and_delete(s3_bucket, s3_key)
data = Json.load_json_and_delete(tmp_file)
return data
return data
def exec_js(self, js_code):
return self.browser().sync__js_execute(js_code)
def invoke_js(self, name, params):
return self.browser().sync_js_invoke_function(name, params)
def create_graph_and_send_screenshot_to_slack(self,
nodes,
edges,
options=None,
team_id=None,
channel=None):
if len(nodes) > 0:
self.create_graph(nodes, edges, options)
if len(nodes) < 20: sleep(1)
elif 20 < len(nodes) < 100:
self.browser().sync__browser_width(1500)
sleep(2)
elif 100 < len(nodes) < 200:
self.browser().sync__browser_width(2000)
sleep(5)
elif len(nodes) > 200:
self.browser().sync__browser_width(3000)
sleep(10)
return self.send_screenshot_to_slack(team_id, channel)
#self.create_graph(nodes, edges,options,graph_name)
#return self.send_screenshot_to_slack(t§eam_id, channel)
# main methods
def create_graph(self, nodes, edges, options=None):
self.web_server.start()
url = self.web_server.url(self.web_page)
self.render_page.get_page_html_via_browser(url)
self.load_page(True)
layout = {
"springLength": 100,
"springCoeff": 0.0008,
"dragCoeff": 0.02,
"gravity": -10.2
}
self.invoke_js("set_layout", layout)
js_code = ""
#for key,issue in nodes.items():
for node in nodes:
key = node.get('key')
label = node.get('label')
img_url = node.get('img_url')
img_size = node.get('img_size')
params = {"label": label, "img_url": img_url, 'img_size': img_size}
js_code += 'graph.addNode("{0}",{1});'.format(
key, Misc.json_dumps(params))
for edge in edges:
js_code += 'graph.addLink("{0}","{1}");\n'.format(edge[0], edge[2])
js_code += "run_graph()"
self.exec_js(js_code)
self.web_server.stop()
return 42
def resolve_icon_from_issue_type(self, issue, key):
label = key
img_size = 20
none_icon = 'icons/none.jpg'
mappings = {
'Risk': 'icons/risk_theme.svg',
'Risk Theme': 'icons/risk_theme.svg',
'Vulnerability': 'icons/vuln.png',
'GS-Project': 'icons/gs_project.svg',
'Business entity': 'icons/business_entity.svg',
'GS Service ': 'icons/gs_service.svg',
'IT Asset': 'icons/it_asset.svg',
'IT System': 'icons/it_asset.svg',
'People': 'icons/people.svg',
'Programme': 'icons/programme.svg',
'Threat Model': 'icons/threat_model.svg',
'Key Result': 'icons/key-result.svg',
'Objective': 'icons/objective.svg',
'Task': 'icons/task.svg',
'Epic': 'icons/epic.svg',
'Data Journey': 'icons/data_journey.svg',
'Project': 'icons/project.svg',
'Fact': 'icons/fact.svg',
'Incident': 'icons/incident.png',
'Incident Task': 'icons/incident_task.png',
'User Access': 'icons/user_access.svg',
'Security Event': 'icons/security_event.svg',
}
if issue and issue.get("Issue Type"):
issue_type = issue.get("Issue Type")
icon = mappings.get(issue_type, none_icon)
#if icon == none_icon:
# Dev.pprint(key + ' ' + issue_type)
else:
icon = 'icons/none.jpg'
#icon = 'https://dummyimage.com/100x40/2c2f87/FFFFFF&text={0}'.format(key)
#img_size = 10
return label, img_size, icon