def generate_xmind(self):
        # merge sumamry data
        with open(self.input_fp) as summary_fh:
            summary_data = json.load(summary_fh)
        merged_summary_data = self.merge_summary_data(summary_data[DEFAULT_SUMMARY_KEY])

        # init xmind obj
        output_xmind_obj = xmind.load(self.output_fp)

        # create summary sheet
        summary_sheet = output_xmind_obj.getPrimarySheet()  # get the first sheet
        summary_sheet.setTitle(DEFAULT_SUMMARY_KEY)  # set its title
        summary_sheet.setAttribute(const.ATTR_THEME, DEFAULT_THEME)
        root_topic = summary_sheet.getRootTopic()  # get the root topic of this sheet
        summary_root_key = merged_summary_data.keys()[0]
        root_topic.setTitle(summary_root_key)  # set its title
        self.set_sub_key_element(merged_summary_data[summary_root_key], summary_sheet, root_topic)

        # create case sheet
        if DEFAULT_SUMMARY_KEY in summary_data:
            for case_name in summary_data[DEFAULT_SUMMARY_KEY]:
                case_sheet = output_xmind_obj.createSheet()
                case_sheet.setTitle(case_name)
                case_sheet.setAttribute(const.ATTR_THEME, DEFAULT_THEME)
                case_root_topic = case_sheet.getRootTopic()
                root_key = summary_data[DEFAULT_SUMMARY_KEY][case_name].keys()[0]
                case_root_topic.setTitle(root_key)
                self.set_sub_key_element(summary_data[DEFAULT_SUMMARY_KEY][case_name][root_key], case_sheet,
                                         case_root_topic)
                output_xmind_obj.addSheet(case_sheet)
        else:
            print "The summary json file[%s] format is not correct!" % self.input_fp
        xmind.save(output_xmind_obj, self.output_fp)
        self.append_xmind_style()
예제 #2
0
def update_xmind():
    workbook = xmind.load('demo.xmind')
    primary_sheet = workbook.getPrimarySheet()
    root_topic = primary_sheet.getRootTopic()
    root_topic.addMarker(MarkerId.starRed)

    # 1、save all content and save as xmind_update_demo.xmind(recommended)
    xmind.save(workbook=workbook, path='xmind_update_demo.xmind')

    # 2、only save the content.xml
    xmind.save(workbook=workbook,
               path='xmind_update_demo1.xmind',
               only_content=True)

    # 3、only save content.xml、comments.xml、styles.xml
    xmind.save(workbook=workbook,
               path='xmind_update_demo2.xmind',
               except_attachments=True)

    # 4、save everything except `Revisions` content to save space(also recommended)
    xmind.save(workbook=workbook,
               path='xmind_update_demo3.xmind',
               except_revisions=True)

    # 5、update and overwrite the original file directly.
    xmind.save(workbook)
예제 #3
0
def save_xmind_report(filename, username, results):
    if os.path.exists(filename):
        os.remove(filename)
    workbook = xmind.load(filename)
    sheet = workbook.getPrimarySheet()
    design_sheet(sheet, username, results)
    xmind.save(workbook, path=filename)
예제 #4
0
	def main(md_content, target_file_name, topic_name):
		# print('main {0}'.format(md_file))

		if '.xmind' not in target_file_name:
			target_file_name += '.xmind'

		# 如果目标文件存在则删除
		target_file_path = os.path.abspath(os.path.join(os.getcwd(), target_file_name))
		# print(target_file_path)
		if os.path.exists(target_file_path):
			print('\033[1;35m目标文件存在且已删除 \033[0m')
			os.remove(target_file_path)

		# 1、如果指定的XMind文件存在,则加载,否则创建一个新的
		workbook = xmind.load(target_file_name)

		# 2、获取第一个画布(Sheet),默认新建一个XMind文件时,自动创建一个空白的画布
		sheet1 = workbook.getPrimarySheet()

		# 3、在画布上生成思维导图
		Md2Xmind.handle_content(md_content, sheet1, topic_name)

		# 4、保存(如果指定path参数,另存为该文件名)
		xmind.save(workbook)

		print('\033[1;32m{0} created \033[0m'.format(target_file_name))
예제 #5
0
def create_xmind(dict_data, file):
    try:
        file_name = file if '.xlsx' not in file else file.split('.xlsx')[0]
        w = xmind.load(file_name + '.xmind')
        for i in range(len(dict_data)):
            s = w.getPrimarySheet() if i == 0 else w.createSheet()
            s.setTitle(dict_data[i][1][0])  # set its title
            global r  # 初始使用变量,需要在下面的方法中查找,提供全局
            r = s.getRootTopic()  # get the root topic of this sheet
            r.setTitle(dict_data[i][1][0])  # 设置主分支标题,同sheet都相同
            # 设置循环标签 不超过26位
            topic_list = list(map(chr, range(ord('a'), ord('z') + 1)))
            topic_list.pop(17)
            topic_list.pop(18)
            for item in enumerate(dict_data[i][0]):
                preview_ct = 1
                for dict_ct in range(len(item[1])):
                    if dict_ct == 0:
                        current_topic = item[1][dict_data[i][1][dict_ct + 1]]
                        key = dict_data[i][1][dict_ct + 1]
                        topic_name = topic_list[dict_ct]
                        prev_topic_name = 'r'
                        preview_ct = sort_liter(preview_ct, current_topic, key,
                                                topic_name, prev_topic_name)
                    else:
                        current_topic = item[1][dict_data[i][1][dict_ct + 1]]
                        key = dict_data[i][1][dict_ct + 1]
                        topic_name = topic_list[dict_ct]
                        prev_topic_name = topic_list[dict_ct - 1]
                        preview_ct = sort_liter(preview_ct, current_topic, key,
                                                topic_name, prev_topic_name)

        xmind.save(w, file_name + '.xmind')
    except Exception as err:
        print(err)
예제 #6
0
파일: create_xmind.py 프로젝트: spmdl/xmind
def gen_my_xmind_file():

    workbook = xmind.load("my.xmind")
    sheet1 = workbook.getPrimarySheet()
    time_name = basic_sheet(sheet1, workbook)
    # gen_sheet2(sheet1, workbook)

    xmind.save(workbook, path='minmap/{}.xmind'.format(time_name))
예제 #7
0
파일: map.py 프로젝트: Thooooor/AwesomeNote
 def draw(self):
     if os.path.exists(self.xmind_path):
         os.remove(self.xmind_path)
     mind_map = xmind.load(self.xmind_path)
     sheet = mind_map.getPrimarySheet()
     sheet.setTitle(self.title)
     self.note.transform(sheet)
     xmind.save(mind_map)
예제 #8
0
파일: report.py 프로젝트: sec-js/maigret
def genxmindfile(filename, username, results):
    print(f'Generating XMIND8 file for username {username}')
    if os.path.exists(filename):
        os.remove(filename)
    workbook = xmind.load(filename)
    sheet = workbook.getPrimarySheet()
    design_sheet(sheet, username, results)
    xmind.save(workbook, path=filename)
def gen_my_xmind_file():
    # load an existing file or create a new workbook if nothing is found
    workbook = xmind.load("my.xmind")
    # get the first sheet(a new workbook has a blank sheet by default)
    sheet1 = workbook.getPrimarySheet()
    design_sheet1(sheet1)
    # create sheet2
    # gen_sheet2(workbook, sheet1)
    # now we save as test.xmind
    xmind.save(workbook, path='my.xmind')
예제 #10
0
def json_2_xmind(json_file_path, xmind_name):
    workbook = xmind.load(xmind_name)
    sheet1 = workbook.getPrimarySheet()
    sheet1.setTitle(xmind_name)  # 设置画布名称
    root_topic1 = sheet1.getRootTopic()
    root_topic1.setTitle(xmind_name)
    with open(json_file_path) as f:
        dict_data = json.load(f)
        dfs(dict_data, root_topic1)
    xmind.save(workbook, path=xmind_name)
예제 #11
0
 def make(self):
     self.read_data()
     if os.path.exists(self.save_to):
         os.remove(self.save_to)
     workbook = xmind.load(self.save_to)
     sheet = workbook.getPrimarySheet()
     sheet.setTitle(self.title)
     root_topic = sheet.getRootTopic()
     root_topic.setTitle(self.title)
     self.add_sub(root_topic, 0)
     xmind.save(workbook, path=self.save_to)
 def create(self, user_id: str, title: str) -> bool:
     try:
         _xmind_workbook, _current_file = self.get_workbook(user_id)
         _new_sheet = _xmind_workbook.createSheet()
         _new_sheet.setTitle(title)
         _xmind_workbook.addSheet(_new_sheet)
         xmind.save(_xmind_workbook, self.get_full_file_path(user_id, \
             _current_file))
         return True
     except:
         return False
예제 #13
0
def gen_my_xmind_file():
    with open(json_file, 'rt') as f:
        jdata = json.loads(f.read(), object_pairs_hook=OrderedDict)

    for k1, v1 in jdata.items():
        xmind_file = os.path.join(root_path, "{}.xmind".format(k1))
        workbook = xmind.load(xmind_file)
        sheet1 = workbook.getPrimarySheet()
        design_sheet1(sheet1, k1, v1)

        xmind.save(workbook)
예제 #14
0
def gen_my_xmind_file():
    workbook = xmind.load("my.xmind")

    sheet1 = workbook.getPrimarySheet()
    # 对第一个画布进行设计完善,具体参照下一个函数
    design_sheet1(sheet1)

    # 3、创建第二个画布
    gen_sheet2(workbook, sheet1)

    # 4、保存(如果指定path参数,另存为该文件名)
    xmind.save(workbook, path='test.xmind')
예제 #15
0
파일: tools.py 프로젝트: yangyueguang/Study
 def save(self, name=None):
     if not self.is_zen:
         xmind.save(self.workbook, name or self.name)
     else:
         with ZipFile(name or self.name, 'w') as x:
             x.writestr(
                 'content.json',
                 json.dumps(self.content, ensure_ascii=False, indent=3))
             manifest = '{"file-entries":{"content.json":{},"metadata.json":{},"":{}}}'
             metadata = '{"creator":{"name":"Vana","version":"10.1.1.202003310622"}}'
             x.writestr('manifest.json', manifest)
             x.writestr('metadata.json', metadata)
 def create(self, user_id: str, title: str) -> bool:
     try:
         _path, _sheet, _wb, _current_file = self.get_sheet(user_id)
         _topic_element = self.get_topic_by_path(_sheet, _path)
         _new_topic = TopicElement(ownerWorkbook=_wb)
         _new_topic.setTitle(title)
         _topic_element.addSubTopic(_new_topic)
         xmind.save(_wb, self.get_full_file_path(user_id, \
             _current_file.file_name))
         return True
     except Exception as _ex:
         print(_ex)
         return False
예제 #17
0
def gen_my_xmind_file(name, post_form, form_items, file_dic):

    file_path = "./" + name + ".xmind"
    workbook = xmind.load(file_path)
    # get the first sheet(a new workbook has a blank sheet by default)
    sheet1 = workbook.getPrimarySheet()
    # design_sheet1(sheet1, name, number , address, flow)
    write_sheet(sheet1, name, post_form, form_items, file_dic)

    try:
        xmind.save(workbook, path=file_path)
        return True
    except Exception:
        return False
 def delete(self, user_id: str, virtual_index: int) -> bool:
     try:
         _xmind_workbook, _current_file = self.get_workbook(user_id)
         _sheets = [sheet.getTitle() for sheet in _xmind_workbook.getSheets()]
         _response_container = ResponseContainer(_sheets)
         _sheet_to_use = \
             _response_container.get_title_by_index(virtual_index)
         _old_index = _sheets.index(_sheet_to_use)
         _xmind_workbook.removeSheet(_xmind_workbook.getSheets()[_old_index])
         xmind.save(_xmind_workbook, self.get_full_file_path(user_id, \
             _current_file))
         return True
     except:
         return False
예제 #19
0
def get_wiki_page(url):
    r = requests.get(url, auth=(wiki_user, wiki_password))
    body = r.text
    w = xmind.load('test.xmind')
    s1 = w.getPrimarySheet()
    r1 = s1.getRootTopic()
    # r1.setTitle('SRS')
    feature = r1.addSubTopic()
    feature.setTitle('Some Feature')
    Parser(feature, body).html_to_xmind()
    xmind.save(w, "test.xmind")


# test_xmind_file("srs")
# parse_html()
# get_wiki_page(test_url)
    def delete(self, user_id: str, virtual_index: int) -> bool:
        _path_item, _sheet, _wb, _current_file = self.get_sheet(user_id)
        _topic_element = self.get_topic_by_path(_sheet, _path_item)
        _childs = _topic_element.getFirstChildNodeByTagName(const.TAG_CHILDREN)

        # Direct maninupation with DOM -- Begin --
        _first_child = _childs.firstChild
        if len(_first_child.childNodes) <= virtual_index:
            return False

        _first_child.removeChild(_first_child.childNodes[virtual_index])
        # Direct maninupation with DOM -- End --

        xmind.save(_wb, self.get_full_file_path(user_id, \
                _current_file.file_name))
        return True
예제 #21
0
    def genTree(self):
        topicList = []
        max = 0
        targetPath = './target'
        isExists = os.path.exists(targetPath)
        if not isExists:
            os.mkdir(targetPath)
        w = xmind.load(
            self.xFileName
        )  # load an existing file or create a new workbook if nothing is found
        s1 = w.getPrimarySheet()  # get the first sheet
        s1.setTitle(self.mainTitle)  # set its title
        r1 = s1.getRootTopic()  # get the root topic of this sheet
        r1.setTitle(mainTitle)  # set its title
        for key in self.lineDic.keys():
            keyLen = len(key)
            if (keyLen > max):
                max = keyLen
        print('max len tags')
        print(max)
        for i in range(1, max + 1, 2):
            if (i == 1):
                oneList = [x for x in self.lineDic.keys() if len(x) == i]
                for onekey in oneList:
                    topTopic = r1.addSubTopic()
                    topTopic.setTitle(self.lineDic[onekey][0])
                    topTopic.setPlainNotes(self.lineDic[onekey][1])
                    topicList.append(topTopic)

            else:
                moreList = [x for x in self.lineDic.keys() if len(x) == i]
                for morekey in moreList:
                    supKey = morekey[0:i - 2]
                    print('process key------')
                    #print(str(supKey))
                    for findr in topicList:
                        findkey = findr.getTitle().split()[0]
                        if findkey == supKey:
                            subTopic = findr.addSubTopic()
                            subTopic.setTitle(self.lineDic[morekey][0])
                            subTopic.setPlainNotes(self.lineDic[morekey][1])
                            topicList.append(subTopic)
                            break
                        else:
                            continue
        xmind.save(w, self.xFileName)
        print('Process Success-------')
예제 #22
0
def toc_to_xmind(outfp, pdf_filename):
    """
    Convert table of contents of given PDF file to XMind document.
    """
    out_str = io.StringIO()
    dumppdf.dumpoutline(out_str, pdf_filename, [], set())

    # Parse XML
    toc_xml = out_str.getvalue()
    out_str.close()  # no 'with' statement possible
    root_elem = etree.fromstring(toc_xml)

    # Convert XML to XMind document
    xwb = xmind.load(
        outfp
    )  # load an existing file or create a new workbook if nothing is found

    # Create XMind workbook
    s1 = xwb.getPrimarySheet()
    s1.setTitle(os.path.split(pdf_filename)[-1])
    root_topic = s1.getRootTopic()
    root_topic.setTitle("Contents")

    # Transform each XML node into a mindmap node
    topic_stack = [root_topic
                   ]  # length will always equal depth/level during traversal
    prev_level = 0
    for node in root_elem.iter():  # depth-first traversal
        if 'level' not in node.attrib:
            continue  # irrelevant node
        node_level = int(node.attrib['level'])

        # Create topic for this node
        topic = TopicElement(ownerWorkbook=xwb)
        title = re.sub(r"^[a-zA-Z]'(.*)'$", r'\1', node.attrib['title'])
        topic.setTitle(title)

        # Add it to the topic tree
        level_difference = node_level - prev_level
        for _ in range(-level_difference + 1):  # negative yields empty list
            topic_stack.pop()
        topic_stack[-1].addSubTopic(topic)
        topic_stack.append(topic)
        prev_level = node_level

    xmind.save(xwb)
예제 #23
0
파일: xmind_parser.py 프로젝트: zmhtest/ATP
def export_xmind_api(xmind_dic):
    for projectName, json_value in xmind_dic.items():
        file_name = projectName
        unix_time = int(time.time())
        new_filename = str(unix_time)
        if not os.path.exists(CONFIG.DOWNLOADS_DIR):
            os.makedirs(CONFIG.DOWNLOADS_DIR)
        file_dir = CONFIG.DOWNLOADS_DIR + "{0}{1}.xmind".format(
            file_name, new_filename)
        workbook = xmind.load(file_dir)

        sheet1 = workbook.getPrimarySheet()
        sheet1.setTitle(projectName)
        rootTop1 = sheet1.getRootTopic()
        rootTop1.setTitle(projectName)
        for systemName, json_value in json_value.items():
            # system_topic = rootTop1.addSubTopic(topics_type = TOPIC_DETACHED)
            system_topic = rootTop1.addSubTopic()
            # system_topic.setTopicHyperlink(sheet1.getID())
            system_topic.setTitle(systemName)
            for moudleName, json_value in json_value.items():
                moudle_topic = system_topic.addSubTopic()
                moudle_topic.setTitle(moudleName)
                for typeName, json_value in json_value.items():
                    type_topic = moudle_topic.addSubTopic()
                    type_topic.setTitle(typeName)
                    for suiteName, json_value in json_value.items():
                        suite_topic = type_topic.addSubTopic()
                        suite_topic.setTitle(suiteName)
                        for sceneType, json_value in json_value.items():
                            scene_topic = suite_topic.addSubTopic()
                            scene_topic.setTitle(sceneType)
                            for testcaseName, json_value in json_value.items():
                                testcase_topic = scene_topic.addSubTopic()
                                testcase_topic.setTitle(testcaseName)
                                for expect, json_value in json_value.items():
                                    expect_topic = testcase_topic.addSubTopic()
                                    expect_topic.setTitle(expect)
                                    for expectResult, json_value in json_value.items(
                                    ):
                                        expectResult_topic = expect_topic.addSubTopic(
                                        )
                                        expectResult_topic.setTitle(
                                            expectResult)
        xmind.save(workbook)
        return file_name + new_filename + '.xmind'
예제 #24
0
def dict2xmind(dicts, filename, path):
    file_path = os.path.join(os.path.abspath(path), filename + ".xmind")
    if os.path.exists(file_path):
        os.remove(file_path)
    workbook = xmind.load(file_path)

    sheet = workbook.getPrimarySheet()
    sheet.setTitle(dicts['name'])
    root_topic = sheet.getRootTopic()
    root_topic.setTitle(dicts['name'])

    dict_ite(dicts['scene'], root_topic, {})

    for next_ in nextRequestName:
        if next_ in requestName:
            sheet.createRelationship(nextRequestName[next_],
                                     requestName[next_], '')
    xmind.save(workbook, file_path)
예제 #25
0
 def create(self, user_id: str, title: str) -> bool:
     _user: UserObject = self.create_user_object(user_id)
     _file_operations: FileOperations = FileOperations(_user)
     try:
         _file_operations.create(title)
         _, _meta_json = self.read_meta_file(user_id)
         _current_file = _meta_json.current_file.file_name
         _xmind_workbook = xmind.load(self.get_full_file_path(user_id, \
             _current_file))
         _sheet = _xmind_workbook.getPrimarySheet()
         _sheet.setTitle('NewSheet')
         _topic = _sheet.getRootTopic()
         _topic.setTitle('NewTopic')
         xmind.save(_xmind_workbook, self.get_full_file_path(user_id, \
             _current_file))
     except Exception as ex:
         print(ex)
         return False
     return True
예제 #26
0
def parse_html():
    path = Path.cwd().joinpath("output")
    # Load xmind file to write
    w = xmind.load('test.xmind')
    s1 = w.createSheet()
    r1 = s1.getRootTopic()
    r1.setTitle('SRS')
    for s in path.iterdir():
        path_section = s
        # Set a section in map
        section = r1.addSubTopic()
        section.setTitle(s.name)
        for l in path_section.iterdir():
            # Set a feature in map
            feature = section.addSubTopic()
            feature.setTitle(l.stem)
            with l.open() as f:
                content = f.read()
            Parser(feature, content).html_to_xmind()
    xmind.save(w, "test.xmind")
예제 #27
0
    def dictToXmind(self, dictslist, filename, startnodemessage, path):
        file_str = path + "/" + filename + ".xmind"
        # 先删除文件
        if os.path.exists(file_str):
            os.remove(file_str)
        workbook = xmind.load(
            file_str
        )  # load an existing file or create a new workbook if nothing is found

        sheet = workbook.getPrimarySheet()  # get the first sheet
        sheet.setTitle(filename)  # set its title
        rtopic_sheet = sheet.getRootTopic()  # get the root topic of this sheet
        #中心
        rtopic_sheet.setTitle(startnodemessage)  # set its title

        if self.dict_ite(dictslist, rtopic_sheet):
            xmind.save(workbook, file_str)
            pass
            return True
        else:
            return False
 def transExcel(self):
     outFileName, outFiltr = QtGui.QFileDialog.getSaveFileName(self,self.tr(u"保存Xmind文件"), os.getcwd(), self.tr("Xmind Files (*.xmind )")) 
     if not outFileName:
         return False
     
     sheet,sheetName = self.loadExcel(self.orinFile)
     caseList = self.readSheet(sheet)
     if not caseList:
         return False 
     workbook = self.generateXmind(caseList,sheetName)
     if workbook is not None:
         line1 = "转换Excel至Xmind成功:"+"\n"
         line2 = "需求名称: " +sheetName + "\n"
         line3 = "共%d条用例" %(len(caseList)) + "\n"
         line4 = "输出文件地址:" + outFileName + "\n"
         self.ui.textBrowser.insertPlainText(line1+line2+line3+line4)  
         xmind.save(workbook, outFileName)    
         self.initProgressDialog(1)
         self.updateProgressDialog() 
     else:
         return False
예제 #29
0
파일: test2.py 프로젝트: WolfOrHare/Or
def creatXmindFile(data):
    module=[]
    for item in data:
        module.append(item['module'])
    module=list(set(module))
    print(module)
    w = xmind.load("test3.xmind") # load an existing file or create a new workbook if nothing is found
    s2=w.createSheet() # create a new sheet
    s2.setTitle("框架")
    r2=s2.getRootTopic()
    r2.setTitle("框架")

    for i in range(len(module)):
        t=TopicElement()
        t.setTitle(module[i])
        r2.addSubTopic(t)
    w.addSheet(s2) # the second sheet is now added to the workbook
    r2_topics=r2.getSubTopics() # to loop on the subTopics
    for topic in r2_topics:
        topic_name=topic.getTitle()
        print (topic_name)
        for item in data:
            if topic_name == item['module'] :
                index=topic.getIndex()
                t=TopicElement()
                content=item['caseId']+" "+'\n'+item['summary']
                t.setTitle(content)
                r2_topics[index].addSubTopic(t)

                summary=t.getTitle()
                for item in data:
                    if item['summary'] in summary:
                        t1=TopicElement()
                        content1=item['name']
                        t1.setTitle(content1)
                        t.addSubTopic(t1)

    xmind.save(w,"test3.xmind") # and we save
예제 #30
0
    def draw(self):
        try:
            os.remove(self.res_file)
        except FileNotFoundError:
            pass

        # 创建 sheet
        workbook = xmind.load(self.res_file)
        sheet = workbook.createSheet()

        # 创建根节点
        root = self._get_top(
            1,
            None,
        )[0]
        sheet.setTitle(root)
        rt = sheet.getRootTopic()
        rt.setTitle(root)

        # 创建子节点
        self.ignore_topics = {root}
        self._add_child_topic(rt, root, 0)

        xmind.save(workbook)
예제 #31
0
파일: xmind_parser.py 프로젝트: zmhtest/ATP
def export_xmind_base(xmind_dic):
    for projectName, json_value in xmind_dic.items():
        file_name = projectName
        unix_time = int(time.time())
        new_filename = str(unix_time)
        if not os.path.exists(CONFIG.DOWNLOADS_DIR):
            os.makedirs(CONFIG.DOWNLOADS_DIR)
        file_dir = CONFIG.DOWNLOADS_DIR + "{0}{1}.xmind".format(
            file_name, new_filename)
        workbook = xmind.load(file_dir)
        sheet1 = workbook.getPrimarySheet()
        sheet1.setTitle(projectName)
        rootTop1 = sheet1.getRootTopic()
        rootTop1.setTitle(projectName)
        for systemName, json_value in json_value.items():
            system_topic = rootTop1.addSubTopic()
            system_topic.setTitle(systemName)
            for moudleName, json_value in json_value.items():
                moudle_topic = system_topic.addSubTopic()
                moudle_topic.setTitle(moudleName)
                '''模块最后一级'''
                Multi_layer_module(json_value, moudle_topic)
        xmind.save(workbook)
        return file_name + new_filename + '.xmind'
예제 #32
0
from xmind.core.topic import TopicElement
from xmind.core import workbook,saver

import xmind

myWorkbook = xmind.load("please-always-overwrite-the-output.xmind") # load an existing file or create a new workbook if nothing is found

mainSheet=myWorkbook.getPrimarySheet()
mainSheet.setTitle("first sheet")
rootTopic=mainSheet.getRootTopic()
rootTopic.setTitle("root node")

topics = ["first", "second", "third", "fourth", "fifth"]

for topic in topics:
    newTopic = TopicElement() # Initialize topic object
    newTopic.setTitle(topic) # Set node text
    rootTopic.addSubTopic(newTopic) # Attach the topic to the root topic

myWorkbook.addSheet(mainSheet) # the second sheet is now added to the workbook

xmind.save(myWorkbook,"test.xmind") # and we save

예제 #33
0
def get_testcase_list(topic):
    testcase_list = []
    testcase_list_init(topic ,testcase_list)

    return testcase_list

get_LSubTopics(w.getSheets()[2].getRootTopic())
print '------------------'
#终点节点的个数
print LSubTopics
print LSubTopics.__len__()

print getParentTopicByID_Dic
print getParentTopicByID_Dic.__len__()

print getTopicByID_Dic
print getTopicByID_Dic.__len__()

print '=============================='
#获取第一条用例的结尾部分
print LSubTopics[0].getTitle()
print LSubTopics[0].addMarker("yes")
#获取第一条用例的用例情况
print get_testcase_list(LSubTopics[0])


print '+++++++++++++++++++++++++++++'

xmind.save(w, "test3.xmind")
예제 #34
0
def getCommentsByID(issue_id):
    comments = ''
    for i in connection.getIssue(issue_id).getComments():
        comments += "[" + i.authorFullName + "]" + "\n" + i.text + '\n\n' 
    return comments.encode('utf-8')


def getChild(issue_id, level, t):
    # print level, Id
    top = TopicElement()
    # Split on '->' due to issue title on TRAR project
    top.setTitle(connection.getIssue(issue_id).summary.split('->')[-1])
    top.addMarker(setImpStatus(issue_id))
    top.addMarker(setPriority(issue_id))
    top.addMarker(setState(issue_id))
    top.setURLHyperlink(server + 'issue/' + issue_id)
    comments = getCommentsByID(issue_id)
    if len(comments) > 0:
        top.setPlainNotes(comments)
    t.addSubTopic(top)
    for i in getSubtasks(issue_id):
        getChild(i.id, level+1, top)

for parent in getSuperParents(issues_list):
    getChild(parent, 0, root_primary)

xmind.save(issue_map, category + ".xmind")

print category + '.xmind' + ' created'
예제 #35
0
    items = {}
    root_items = []
    # Create all the items
    for i in tree.iter('item'):
        key = i.find('key').text
        summary = i.find('summary').text
        status = i.find('status').text
        description = i.find('description').text
        url = i.find('link').text
        children = [k.text for k in i.findall("issuelinks/issuelinktype[@id='10000']/inwardlinks/issuelink/issuekey")]
        parents = [k.text for k in i.findall("issuelinks/issuelinktype[@id='10000']/outwardlinks/issuelink/issuekey")]
        items[key] = {
            'summary': summary,
            'status': status,
            'url': url,
            'description': description,
            'children': children,
            'parents': parents
        }
        if len(parents) == 0:
            root_items.append(key)
    # Display the Tree
    w = xmind.load('new.xmind')
    s1 = w.getPrimarySheet()
    s1.setTitle("SPHERES Jira tickets")
    r1 = s1.getRootTopic()
    r1.setTitle("SPHERES")
    for k in root_items:
        add_item(items, k, r1)
    xmind.save(w, args.destination)
예제 #36
0
t2=TopicElement()
t2.setTitle("second node")
t2.setURLHyperlink("https://xmind.net") # set an hyperlink

t3=TopicElement()
t3.setTitle("third node")
t3.setPlainNotes("notes for this topic") # set notes (F4 in XMind)
t3.setTitle("topic with \n notes")

t4=TopicElement()
t4.setFileHyperlink("logo.jpeg") # set a file hyperlink
t4.setTitle("topic with a file")


# then the topics must be added to the root element

r2.addSubTopic(t1)
r2.addSubTopic(t2)
r2.addSubTopic(t3)
r2.addSubTopic(t4)

topics=r2.getSubTopics() # to loop on the subTopics
for topic in topics:
    topic.addMarker("yes")

w.addSheet(s2) # the second sheet is now added to the workbook
rel=s2.createRelationship(t1.getID(),t2.getID(),"test") # create a relationship
s2.addRelationship(rel) # and add to the sheet

xmind.save(w,"test2.xmind") # and we save
예제 #37
0
t3 = r2.addSubTopic()
t3.setTitle("third node")
t3.setPlainNotes("notes for this topic") 
t3.setTitle("topic with \n notes")

# Create a topic with a file hyperlink
t4 = r2.addSubTopic()
t4.setFileHyperlink("logo.jpeg") 
t4.setTitle("topic with a file")

# Create topic that is a subtopic of another topic
t41 = t4.addSubTopic()
t41.setTitle("a subtopic")

# create a detached topic whose (invisible) parent is the root
d1 = r2.addSubTopic(topics_type = TOPIC_DETACHED)
d1.setTitle("detached topic")
d1.setPosition(0,20)

# loop on the (attached) subTopics
topics=r2.getSubTopics()
# Demonstrate creating a marker
for topic in topics:
    topic.addMarker(MarkerId.starBlue)
    
# create a relationship    
rel=s2.createRelationship(t1.getID(),t2.getID(),"test") 

# and we save
xmind.save(w,"test2.xmind")