class ConfluenceManager: def __init__(self, credentials, path): self.remote = Confluence(url=credentials[0], username=credentials[1], password=credentials[2]) def converter_to_local_key(key): if isinstance(key, tuple): return 'name_' + key[0] + key[1] else: return 'id_' + key self.cached = CachedDataProvider( self, path, converter_to_local_key=converter_to_local_key) self.simplified = CachedDataProvider( ConfluenceSimplifiedTextProvider(self.cached), path + '.simplified', converter_to_local_key=converter_to_local_key) def extract_url(self, raw_page): return self.remote.url + raw_page['_links']['webui'] def extract_title(self, raw_page): return raw_page['title'] def __get_page_id(self, id_): if isinstance(id_, tuple): id_ = self.remote.get_page_id(id_[0], id_[1]) return id_ def get_page(self, id_, full_info=True): id_ = self.__get_page_id(id_) expand = 'children.page.id' if full_info: expand = 'version,body.storage,children.page.id' raw = self.remote.get_page_by_id(id_, expand=expand) return raw def get_simple_text(self, id_): return self.simplified[id_] def get_page_tree_ids(self, id_): page = self.get_page(id_, full_info=False) ret = [page['id']] children_ids = [r['id'] for r in page['children']['page']['results']] for id_ in children_ids: ret += self.get_page_tree_ids(id_) return ret def __getitem__(self, key): if isinstance(key, tuple): remote_key = self.remote.get_page_id(key[0], key[1]) else: remote_key = key ret = self.remote.get_page_by_id( remote_key, expand='version,body.storage,children.page.id') return ret
# coding=utf-8 from atlassian import Confluence """This example shows how to export pages""" confluence = Confluence( url="https://test.atlassian.net/wiki", username="******", password="******", api_version="cloud", ) if __name__ == "__main__": space = "TEST" page_title = "Test" page_id = confluence.get_page_id(space, page_title) content = confluence.export_page(page_id) with open(page_title + ".pdf", "wb") as pdf_file: pdf_file.write(content) pdf_file.close() print("Completed")
"""<table> <tr> <th>Project Key</th> <th>Project Name</th> <th>Leader</th> <th>Email</th> </tr>""" ] for data in jira.project_leaders(): log.info( "{project_key} leader is {lead_name} <{lead_email}>".format(**data)) row = """<tr> <td>{project_key}</td> <td>{project_name}</td> <td>{lead_name}</td> <td><a href="mailto:{lead_email}">{lead_email}</a></td> </tr>""" html.append(row.format(**data)) html.append("</table><p></p><p></p>") status = confluence.create_page( space="DEMO", parent_id=confluence.get_page_id("DEMO", "demo"), title="Jira Administrators", body="\r\n".join(html), ) print(status)
password='******') html = ["""<table> <tr> <th>Project Key</th> <th>Project Name</th> <th>Leader</th> <th>Email</th> </tr>"""] for data in jira.project_leaders(): log.info('{project_key} leader is {lead_name} <{lead_email}>'.format(**data)) row = """<tr> <td>{project_key}</td> <td>{project_name}</td> <td>{lead_name}</td> <td><a href="mailto:{lead_email}">{lead_email}</a></td> </tr>""" html.append(row.format(**data)) html.append('</table><p></p><p></p>') status = confluence.create_page( space='DEMO', parent_id=confluence.get_page_id('DEMO', 'demo'), title='Jira Administrators', body='\r\n'.join(html)) print(status)
from atlassian import Confluence # połączenie z confluence confluence = Confluence(url='http://conflenecobawroc.corp.capgemini.com', username='******', password='******') # status = confluence.create_page( # space='Coba', # title='147', # body='TESTOWY', # parent_id=3702829, # type='page') # # print(status) page_id = confluence.get_page_id('COBA', 'OneNote') print(page_id)
# coding: utf8 from atlassian import Confluence """This example shows how to export pages""" confluence = Confluence( url='https://test.atlassian.net/wiki', username='******', password='******', api_version='cloud' ) if __name__ == '__main__': space = 'TEST' page_title = 'Test' page_id = confluence.get_page_id(space, page_title) content = confluence.export_page(page_id) with open(page_title + ".pdf", 'wb') as pdf_file: pdf_file.write(content) pdf_file.close() print("Completed")
confluenceSpace = c["space"] confluencePage = c["page"] try: confluence = Confluence(url=confluenceURL, username=confluenceUser, password=confluencePass) except Exception as e: print("Uh oh, can't connect to confluence at " + confluenceURL) print(e) print( "########################################################################") print("Looking for page \"" + confluencePage + "\" in space " + confluenceSpace) pageID = confluence.get_page_id(confluenceSpace, confluencePage) if pageID is None: print("Page not found: " + confluencePage + " in space " + confluenceSpace) exit() else: print("Found page : " + confluencePage + " pageID: " + str(pageID)) print( "########################################################################") print("Getting page by ID: " + str(pageID)) contents = confluence.get_page_by_id(pageID, expand="body.storage,version", status="current") print("ID : " + str(contents["id"])) print("Status : " + contents["status"]) print("Title : " + contents["title"])
class ConfluencePublisher(): def __init__( self, url, username, apiToken, pageTitlePrefix, markdownDir, dbPath, space, parentPageId, forceUpdate=False, forceDelete=False, skipUpdate=False, ): self.api = Confluence(url=url, username=username, password=apiToken) self.pageTitlePrefix = pageTitlePrefix self.markdownDir = markdownDir self.kv = KeyValue(dbPath) self.space = space self.parentPageId = parentPageId self.forceUpdate = forceUpdate self.forceDelete = forceDelete self.skipUpdate = skipUpdate self.confluenceRenderer = ConfluenceRenderer(url) self.metadataPlugin = MetadataPlugin() self.renderer = mistune.create_markdown( renderer=self.confluenceRenderer, plugins=[ 'strikethrough', 'footnotes', 'table', 'url', self.metadataPlugin.plugin_metadata ]) # Hack to allow metadata plugin to work (See mistune/block_parser.py) self.renderer.block.rules.remove('thematic_break') def __getFileContent(self, filepath): file = open(filepath, mode='r') content = file.read() file.close() return content def __updatePage(self, space, parentId, filepath, autoindex=False): if autoindex: markdown = '' else: markdown = self.__getFileContent(filepath) metadata = self.kv.load(filepath) currentTitle = metadata['title'] currentHash = metadata['sha256'] hash = self.kv.sha256(markdown) # --- Render (BEGIN) self.metadataPlugin.stack['title'] = None if autoindex: body = self.confluenceRenderer.generate_autoindex() else: body = self.renderer(markdown) if self.metadataPlugin.stack['title'] is None: if autoindex: title = 'Folder ' + os.path.basename(os.path.dirname(filepath)) else: title = os.path.basename(filepath) else: title = self.metadataPlugin.stack['title'] title = self.pageTitlePrefix + title # >>> Removed: + " [" + self.kv.sha256(filepath)[-6:] + "]" # --- Render (END) if currentTitle and currentTitle != title: print('REN => Title: ' + title) pageId = self.api.get_page_id(space, currentTitle) self.api.update_page(pageId, title, body) if currentHash != hash or self.forceUpdate: if autoindex: print('IDX => Title: ' + title) else: print('UPD => Title: ' + title) if self.api.update_or_create(parent_id=parentId, title=title, body=body, representation='storage'): id = self.api.get_page_id(space, title) self.kv.save(filepath, { 'id': id, 'title': title, 'sha256': hash }) return id else: return None else: print('SKP => Title: ' + title) return self.api.get_page_id(space, title) def __deleteAttachment(self, filepath): metadata = self.kv.load(filepath) filename = os.path.basename(filepath) if metadata['id']: try: print('DEL Att. => Title: ' + filename) # https://confluence.atlassian.com/confkb/confluence-rest-api-lacks-delete-method-for-attachments-715361922.html # self.api.delete_attachment_by_id(metadata['id'], 1) self.api.remove_content(metadata['id']) except (HTTPError, ApiError): pass def __updateAttachment(self, space, pageId, filepath): filename = os.path.basename(filepath) print('UPD Att. => Title: ' + filename) results = self.api.attach_file(filepath, name=filename, page_id=pageId, space=space) id = results['id'] if 'id' in results else results['results'][0]['id'] self.kv.save(filepath, {'id': id, 'title': filename, 'sha256': None}) return id def __publishRecursive(self, space, parentId, path): # File: _index.md indexParentId = parentId indexPath = path + os.sep + '_index.md' if os.path.isfile(indexPath): # Use local _index.md file indexParentId = self.__updatePage(space, parentId, indexPath) else: # Autoindex simulate _index.md in Confluence if missing locally # Except for (root) parentPageId because missing in markdownDir! if parentId != self.parentPageId: indexParentId = self.__updatePage(space, parentId, indexPath, True) # Directories: */ for f in os.scandir(path): if f.is_dir(): self.__publishRecursive(space, indexParentId, f.path) # Files: *.* (Except _index.md) for f in os.scandir(path): if f.is_file(): if f.path.endswith(".md"): if not f.path.endswith(os.sep + '_index.md'): self.__updatePage(space, indexParentId, f.path) else: self.__deleteAttachment(f.path) self.__updateAttachment(space, indexParentId, f.path) def delete(self): for filepath in sorted(self.kv.keys()): metadata = self.kv.load(filepath) # Page has Sub-pages (Childs)? indexWithChilds = False if filepath.endswith('_index.md'): childs = 0 if os.path.isdir(os.path.dirname(filepath)): for f in os.scandir(os.path.dirname(filepath)): if f.path.endswith(".md") and \ not f.path.endswith('_index.md'): childs = childs + 1 indexWithChilds = childs > 0 if self.forceDelete \ or (not os.path.isfile(filepath) and not indexWithChilds): print('DEL => Id: ' + metadata['id'] + ', Title: ' + metadata['title']) if filepath.endswith(".md"): try: if self.api.get_page_by_id(metadata['id']): self.api.remove_page(metadata['id']) except HTTPError as ex: code = ex.response.status_code if code != 404: print("DEL Pag. (Error):" + str(code)) else: pass else: self.__deleteAttachment(filepath) self.kv.remove(filepath) def publish(self): self.__publishRecursive(self.space, self.parentPageId, self.markdownDir)
class Readme2Confluence: """ Main class that will create the Confluence page from Markdown """ def __init__(self, url, username, password, space): self.confluence = Confluence(url, username=username, password=password) spaces = self.confluence.get_all_spaces(start=0, limit=500) if any(s for s in spaces if s["name"] == space): self.space = space else: raise ValueError("{} is not valid Confluence Space".format(space)) def get_page_id(self, title): """ Retrieve the ID of a page using it's title This is basically a small wrapper around confluence.get_page_id(). The main reason for the wrapper is to better handle pages that aren't found by raising an exception """ page_id = self.confluence.get_page_id(self.space, title) if page_id is None: raise ValueError("{} is not a valid page title in {}".format( title, self.space)) return page_id def get_page_html(self, title): """ Retrieve a confluence page and return it as a HTML (string) """ page_id = self.get_page_id(title) return self.confluence.get_page_by_id(page_id) def send2confluence(self, title, parent_title=None, md_file=None, md_text=""): """ Method that creates the confluence page. Page will either be created or updated depending on what is required. """ if md_file is None: body = md2html(md_text) else: body = md2html(get_md_text(md_file)) parent_id = None if parent_title is None else self.get_page_id( parent_title) page_id = self.confluence.get_page_id(self.space, title) if page_id is None: ret = self.confluence.create_page(self.space, title, body, parent_id=parent_id, type='page', representation='storage') else: ret = self.confluence.update_page(page_id, title, body, parent_id=parent_id, type='page', representation='storage') return ret
class ConfluencePage: dre = re.compile(r'(\d+)') def __init__(self, config_file, timestamp): self.timestamp = timestamp self.page = None config = configparser.ConfigParser() config.read(config_file) if "confluence" not in config.sections(): print("No section 'confluence' found") exit(1) self.url = config.get("confluence", "url") self.username = config.get("confluence", "username") self.password = config.get("confluence", "password") self.page_id = config.get("confluence", "pageId") self.templateFile = config.get("confluence", "templateFile") title = config.get("confluence", "title") space = config.get("confluence", "space") if self.url is None or self.username is None or self.password is None: print("Config file missing configurations") exit(1) if self.page_id is None and (title is None or space is None): print("pageId or title and space missing") exit(1) self.confluence = Confluence(url=self.url, username=self.username, password=self.password) if self.page_id is None: if not self.confluence.page_exists(space, title): print(("Page Space: '%s' Title: '%s' does not exist" % (space, title))) exit(1) self.page_id = self.confluence.get_page_id(space, title) def generate_page(self, library, projects): # Generate page - latest version on develop project_versions_body = self.confluence_generate_last_versions( projects, library) # Generate page - which project depends on each library version lib_versions_body = self.confluence_generate_library_versions(library) template = open(self.templateFile, "r").read() self.page = template.format(timestamp=self.timestamp, lib_versions_body=lib_versions_body, app_versions_body=project_versions_body) def confluence_generate_last_versions(self, projects, library): app_versions_body = "" for project in projects: project_versions_sorted = sorted( project.versions, key=lambda version: [ int(s) if s.isdigit() else s.lower() for s in re.split(self.dre, version.name) ], reverse=True) if len(project_versions_sorted) <= 0: project_version = "Unknown" library_version = "Not using %s" % library.name else: latest_version = project_versions_sorted[0] project_version = latest_version.name library_version = latest_version.library_version if latest_version.library_version is not None else "Not using %s" % library.name app_versions_body += "<tr><td>{project_name}</td><td style=\"text-align: center;\"><strong>{project_version}</strong></td><td style=\"text-align: center;\"><strong>{library_version}</strong></td></tr>" \ .format(project_name=project.name, project_version=project_version, library_version=library_version) return app_versions_body def confluence_generate_library_versions(self, library): sorted_versions = sorted(library.versions, key=lambda version: [ int(s) if s.isdigit() else s.lower() for s in re.split(self.dre, version.name) ], reverse=True) # TODO add links to release notes versions_body = "" for version in sorted_versions: if len(version.dependency_in) == 0: versions_body += "<tr><th><strong>{lib_name}</strong></th><td><strong>Not in use</strong></td><td></td></tr>\n" \ .format(lib_name=version.name) else: versions_body += "<tr><th rowspan=\"{num_of_dep}\"><strong>{lib_name}</strong></th><td>{dep_name}</td><td colspan=\"1\" style=\"text-align: center;\">{dep_rev}</td></tr>\n" \ .format(lib_name=version.name, num_of_dep=len(version.dependency_in), dep_name=version.dependency_in[0][0], dep_rev=version.dependency_in[0][1].name) for dep in version.dependency_in[1:]: versions_body += "<tr><td>{dep_name}</td><td colspan=\"1\" style=\"text-align: center;\">{dep_rev}</td></tr>" \ .format(dep_name=dep[0], dep_rev=dep[1].name) return versions_body def publish_page(self): if self.page is not None: print((self.confluence.update_page(self.page_id, "Test", self.page, type='page', representation='storage')))
class ConfluencePublisher(): def __init__( self, url, username, api_token, page_title_prefix, markdown_dir, db_path, space, parent_pageid, force_update=False, force_delete=False, skip_update=False, verbose=False): self.api = Confluence(url=url, username=username, password=api_token) self.page_title_prefix = page_title_prefix self.markdown_dir = markdown_dir self.kv = KeyValue(db_path) self.space = space self.parent_pageid = parent_pageid self.force_update = force_update self.force_delete = force_delete self.skip_update = skip_update self.confluence_renderer = ConfluenceRenderer(verbose) self.renderer = mistune.create_markdown( renderer=self.confluence_renderer, plugins=[ plugin_front_matter, DirectiveInclude(), HugoRefLinkPlugin(self.markdown_dir), 'strikethrough', 'footnotes', 'table', 'url', Admonition(), plugin_html_comment, ] ) def __update_page(self, space, parentid, filepath, autoindex=False): metadata = self.kv.load(filepath) current_title = metadata['title'] current_hash = metadata['sha256'] sha_hash = get_file_sha256(filepath) # --- Render (BEGIN) body = '' state = {'front_matter': {}} if autoindex: body = generate_autoindex() state['front_matter']['title'] = \ os.path.basename(os.path.dirname(filepath)).title() else: if filepath.endswith("_index.md"): body = generate_autoindex() body += self.renderer.read(filepath, state) title = '{}{}'.format(self.page_title_prefix, state['front_matter']['title']) # --- Render (END) if current_title and current_title != title: print('REN => Title: ' + title) confluence_page_id = self.api.get_page_id(space, current_title) self.api.update_page(confluence_page_id, title, body) if current_hash != sha_hash or self.force_update: if autoindex: print('IDX => Title: ' + title) else: print('UPD => Title: ' + title) if self.api.update_or_create( parent_id=parentid, title=title, body=body, representation='storage' ): confluence_page_id = self.api.get_page_id(space, title) self.kv.save(filepath, {'id': confluence_page_id, 'title': title, 'sha256': sha_hash}) return confluence_page_id return None else: print('SKP => Title: ' + title) return self.api.get_page_id(space, title) def __delete_attachment(self, filepath): metadata = self.kv.load(filepath) filename = os.path.basename(filepath) if metadata['id']: try: print('DEL Att. => Title: ' + filename) # https://confluence.atlassian.com/confkb/confluence-rest-api-lacks-delete-method-for-attachments-715361922.html # self.api.delete_attachment_by_id(metadata['id'], 1) self.api.remove_content(metadata['id']) except (HTTPError, ApiError): pass def __update_attachment(self, space, pageid, filepath): filename = os.path.basename(filepath) print('UPD Att. => Title: ' + filename) results = self.api.attach_file(filepath, name=filename, page_id=pageid, space=space) confluence_page_id = results['id'] if 'id' in results else results['results'][0]['id'] self.kv.save(filepath, {'id': confluence_page_id, 'title': filename, 'sha256': None}) return confluence_page_id def __publish_recursive(self, space, parentid, path, root=False): # File: _index.md index_parentid = parentid index_path = path + os.sep + '_index.md' if not root: if os.path.isfile(index_path): # Use local _index.md file index_parentid = self.__update_page( space, parentid, index_path) else: # Autoindex simulate _index.md in Confluence if missing locally index_parentid = self.__update_page( space, parentid, index_path, True) # Directories: */ for f in os.scandir(path): if f.is_dir(): self.__publish_recursive(space, index_parentid, f.path) # Files: *.* (Except _index.md) for f in os.scandir(path): if f.is_file(): if f.path.endswith(".md"): if not f.path.endswith(os.sep + '_index.md'): self.__update_page(space, index_parentid, f.path) else: self.__delete_attachment(f.path) self.__update_attachment(space, index_parentid, f.path) def delete(self): for filepath in sorted(self.kv.keys()): metadata = self.kv.load(filepath) # Page has Sub-pages (Childs)? index_with_childs = False if filepath.endswith('_index.md'): childs = 0 if os.path.isdir(os.path.dirname(filepath)): for f in os.scandir(os.path.dirname(filepath)): if f.path.endswith(".md") and \ not f.path.endswith('_index.md'): childs = childs + 1 index_with_childs = childs > 0 if self.force_delete \ or (not os.path.isfile(filepath) and not index_with_childs): print('DEL => Id: ' + metadata['id'] + ', Title: ' + metadata['title']) if filepath.endswith(".md"): try: if self.api.get_page_by_id(metadata['id']): self.api.remove_page(metadata['id']) except HTTPError as ex: code = ex.response.status_code if code != 404: print("DEL Pag. (Error):" + str(code)) else: pass else: self.__delete_attachment(filepath) self.kv.remove(filepath) def publish(self): self.__publish_recursive( self.space, self.parent_pageid, self.markdown_dir, root=True)
def main(): # create logging file handler logger = logging.getLogger("Perf_reporter") logger.setLevel(logging.INFO) fh = logging.FileHandler("perf_report.log") sh = logging.StreamHandler(sys.stdout) formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s') fh.setFormatter(formatter) sh.setFormatter(formatter) logger.addHandler(fh) logger.addHandler(sh) logger.info("Reporter started") settings_path = 'settings.ini' bank_list = [] # creating settings.ini if not exists, reading all settings if os.path.exists(settings_path): db_host = config.get_setting(settings_path, 'Settings', 'db_host') db_port = config.get_setting(settings_path, 'Settings', 'db_port') db_name = config.get_setting(settings_path, 'Settings', 'db_name') db_start = config.get_setting(settings_path, 'Settings', 'db_start') db_end = config.get_setting(settings_path, 'Settings', 'db_end') db_info = config.get_setting(settings_path, 'Settings', 'db_info') confluence_auth = (config.get_setting(settings_path, 'Settings', 'confluence_user'), config.get_setting(settings_path, 'Settings', 'confluence_password')) confluence_url = config.get_setting(settings_path, 'Settings', 'confluence_url') confluence_space = config.get_setting(settings_path, 'Settings', 'confluence_space') confluence_page_id = config.get_setting(settings_path, 'Settings', 'confluence_page_id') confluence_html_to_post = config.get_setting(settings_path, 'Settings', 'confluence_html_to_post') confluence_path_to_post = config.get_setting(settings_path, 'Settings', 'confluence_path_to_post') grafana_url = config.get_setting(settings_path, 'Settings', 'grafana_url') garafana_dashboard_uri = config.get_setting(settings_path, 'Settings', 'garafana_dashboard_uri') grafana_org_id = config.get_setting(settings_path, 'Settings', 'grafana_org_id') grafana_panel_id_list = config.get_setting(settings_path, 'Settings', 'grafana_panel_id_list') grafana_panel_width = config.get_setting(settings_path, 'Settings', 'grafana_panel_width') grafana_panel_height = config.get_setting(settings_path, 'Settings', 'grafana_panel_height') logger.info(db_info) else: config.create_config('settings.ini') db_host = config.get_setting(settings_path, 'Settings', 'db_host') db_port = config.get_setting(settings_path, 'Settings', 'db_port') db_name = config.get_setting(settings_path, 'Settings', 'db_name') db_start = config.get_setting(settings_path, 'Settings', 'db_start') db_end = config.get_setting(settings_path, 'Settings', 'db_end') db_info = config.get_setting(settings_path, 'Settings', 'db_info') confluence_auth = (config.get_setting(settings_path, 'Settings', 'confluence_user'), config.get_setting(settings_path, 'Settings', 'confluence_password')) confluence_url = config.get_setting(settings_path, 'Settings', 'confluence_url') confluence_space = config.get_setting(settings_path, 'Settings', 'confluence_space') confluence_page_id = config.get_setting(settings_path, 'Settings', 'confluence_page_id') confluence_html_to_post = config.get_setting(settings_path, 'Settings', 'confluence_html_to_post') confluence_path_to_post = config.get_setting(settings_path, 'Settings', 'confluence_path_to_post') grafana_url = config.get_setting(settings_path, 'Settings', 'grafana_url') garafana_dashboard_uri = config.get_setting(settings_path, 'Settings', 'garafana_dashboard_uri') grafana_org_id = config.get_setting(settings_path, 'Settings', 'grafana_org_id') grafana_panel_id_list = config.get_setting(settings_path, 'Settings', 'grafana_panel_id_list') grafana_panel_width = config.get_setting(settings_path, 'Settings', 'grafana_panel_width') grafana_panel_height = config.get_setting(settings_path, 'Settings', 'grafana_panel_height') logger.info(db_info) # command line arguments parser settings parser = argparse.ArgumentParser(description='Report builder requires relative template path for ' 'report generation.') parser.add_argument( "template_path", metavar='1', type=str, help='file name or template file path') args = parser.parse_args() logger.debug(parser.parse_args()) template_path = parser.parse_args().template_path db_connection_string = db_query.set_db_connection_string(host=db_host, port=db_port, name=db_name) logger.debug("db_connection_string = " + db_connection_string) test_time = db_query.set_time_string(start=db_start, end=db_end) logger.debug("test_time = " + test_time) all_bank_list = db_query.get_bank_list(db_conn=db_connection_string, test_time=test_time) for b in all_bank_list: if db_query.check_bank_query(db_conn=db_connection_string, test_time=test_time, bank=b): bank_list.append(b) else: continue logger.debug(bank_list) last_line_list = csv_processing.csv_read_last_line(read_path=template_path) csv_report_file_name = csv_processing.csv_file_name(template_path=template_path) html_report_file_name = html_processing.html_file_name(template_path=template_path) csv_headers = csv_processing.csv_read(read_path=template_path) csv_processing.csv_add(data=csv_headers, start_index=0, end_index=1, write_path=csv_report_file_name) logger.info("Start info retrieving") for bank in sorted(bank_list): service_list = [] target_service_list = [] found_t_service = [] all_service_list = db_query.get_service_list(db_conn=db_connection_string, test_time=test_time, bank=bank) for s in all_service_list: if db_query.check_service_query(db_conn=db_connection_string, test_time=test_time, service=s, bank=bank): service_list.append(s) else: continue all_target_service_list = db_query.get_target_service_list(db_conn=db_connection_string, test_time=test_time, bank=bank) for ts in all_target_service_list: if db_query.check_target_service_query(db_conn=db_connection_string, test_time=test_time, t_service=ts, bank=bank): target_service_list.append(ts) else: continue logger.debug(bank_list, service_list, target_service_list) for service in sorted(service_list): calculated_list = [] logger.info("BANK: " + bank) logger.info("SERVICE: " + service) db_query_list = csv_processing.csv_read(read_path=template_path) service_result_list = db_query.query_db(db_conn=db_connection_string, q_list=db_query_list, service=service, test_time=test_time) for target_service in sorted(target_service_list): if service in target_service: found_t_service.append(target_service) for t in found_t_service: target_service_result_list = db_query.query_db_with_target_services( db_conn=db_connection_string, q_ts_list=last_line_list, bank=bank, service=service, target_service=t, test_time=test_time) logger.debug(target_service_result_list) service_result_list.append(target_service_result_list) logger.debug("OVERALL RESULTS" + str(service_result_list)) calculated_list = process_table_data(list_to_p=service_result_list, bank=bank, service=service, target_service=target_service) logger.debug(calculated_list) # service_result_list = [] found_t_service = [] csv_processing.csv_add(data=calculated_list, start_index=1, end_index=len(calculated_list), write_path=csv_report_file_name) html_processing.html_add(calculated_list, html_report_file_name) list_for_html = csv_processing.csv_read(read_path=csv_report_file_name) html_processing.html_write(html_data=list_for_html, report_file_name=html_report_file_name) # image retrieving logger.info("Image retrieving started") time_for_url_grafana = images_processing.set_time_string(start=db_start, end=db_end) grafana_panel_width = ast.literal_eval(grafana_panel_width) grafana_panel_height = ast.literal_eval(grafana_panel_height) grafana_panel_id_list = grafana_panel_id_list.split(',') i_count = 99 for i in range(len(grafana_panel_id_list)): images_processing.retrieve_pics(url=grafana_url, uri=garafana_dashboard_uri, org_id=grafana_org_id, test_time=time_for_url_grafana, id=grafana_panel_id_list[i], width=grafana_panel_width[grafana_panel_id_list[i]], height=grafana_panel_height[grafana_panel_id_list[i]], template_path=template_path, i_count=i_count) i_count -= 1 logger.info("Image retrieving done!") # confluence posting confluence = Confluence(url=confluence_url, username=confluence_auth[0], password=confluence_auth[1]) descr = os.path.splitext(template_path)[0].split('/')[1] test_start = db_start.strip('\'') test_end_time = db_end.strip('\'').split(" ")[1] page_title = "{} {} - {}".format(descr, test_start, test_end_time) files = [] confluence.create_page(space=confluence_space, title=page_title, body=confluence_html_to_post, parent_id=confluence_page_id) new_page_id = confluence.get_page_id(space=confluence_space, title=page_title) for (dirpath, dirnames, filenames) in walk(confluence_path_to_post): files.extend(filenames) break description = "<p> TEST SUMMARY" + confluence_html_to_post + "</p>" page_body = description test_duration = "<p> Test duration: " + str(datetime.strptime(db_end, "'%Y-%m-%d %H:%M:%S'") - datetime.strptime(db_start, "'%Y-%m-%d %H:%M:%S'")) + "</p>" page_body += test_duration logger.info("Start confluence report attachment") for file in sorted(files, reverse=True): if str(os.path.splitext(file)[1]) == '.png': response = confluence_processing.upload_attachment(auth=confluence_auth, page_id=new_page_id, file_path=confluence_path_to_post+file) base_url, filename, container_id, modification_date, attachment_id = confluence_processing.\ get_attachments_info(response) image_tag = confluence_processing.prepare_html_for_image(base_url=base_url, filename=filename, container_id=container_id, modification_date=modification_date, attachment_id=attachment_id, height="300", width="825") image_tag = "<p>" + image_tag + "</p>" page_body += image_tag elif str(os.path.splitext(file)[1]) == '.html': with open(confluence_path_to_post + file, 'r') as fr: html_table = fr.read() page_body += html_table else: continue logger.info("Start confluence update") # confluence.update_page(new_page_id, title=page_title, body=page_body, minor_edit=True) confluence_processing.write_data_storage(auth=confluence_auth, html=page_body, page_id=new_page_id) logger.info("Report completed")
execute_command() exit() elif comp == False: print("There's been change in reporev, proceeding code") command = "rm -fr " + file_to_cmp execute_command() # first run elif len(all_files) == 0: print("No files detected,proceeding to update the code") confluence = Confluence(url="https://confluence.waves.com:8443", username=username, password=password) pageid = confluence.get_page_id('SWDO', env) final = [ ['Revision', 'Date', 'Description'], ] mylist = list() myDict = dict() tree = ET.parse(new_file) root = tree.getroot() for elem in root.iter(): if elem.tag == "logentry": revision = elem.attrib['revision'] myDict['revision'] = revision
expand='description.plain,homepage') if "statusCode" in status: if status["statusCode"] == 404: print("Space not found: " + confluenceSpace) else: print("Unknown error: " + status["statusCode"]) print(status) exit(8) else: print("Found Space : " + confluenceSpace + " Name: " + status["name"]) print( "########################################################################") pageTitle = "My Test Page" print("Looking for page \"" + pageTitle + "\" in space " + confluenceSpace) pageID = confluence.get_page_id(confluenceSpace, pageTitle) if pageID is None: print("Page not found: " + pageTitle + " in space " + confluenceSpace) else: print("Found page : " + pageTitle + " pageID: " + str(pageID)) print( "########################################################################") pageTitle = "My New Page " + str(random.randint(0, 100)) print("Looking for page \"" + pageTitle + "\" in space " + confluenceSpace) pageID = confluence.get_page_id(confluenceSpace, pageTitle) if pageID is None: print("Page not found: " + pageTitle + " in space " + confluenceSpace) status = confluence.create_page(space=confluenceSpace,title=pageTitle, \ body='Hello<strong>World</strong>!') if "id" in status: