😕 👨‍🚀 👩🏻‍🤝‍👨🏼 संगम इनलाइन टिप्पणी आँकड़े 🤙🏾 🐊 🖐🏻

Confluence में पेज कमेंट के आँकड़े कैसे एकत्रित करें?

हाँ, और इसकी आवश्यकता क्यों हो सकती है?

क्यों और क्यों

जिस परियोजना में मैं काम करने के लिए हुआ, उसमें आवश्यकताओं की तैयारी और अनुमोदन की निम्नलिखित प्रक्रिया का जन्म हुआ:

प्रलेखन के लिए संघर्ष का उपयोग किया गया था।
आपूर्तिकर्ता टीम ने व्यावसायिक प्रक्रियाओं और टेम्पलेट के अनुसार अलग-अलग पृष्ठों के रूप में उनके चरणों का विवरण तैयार किया।
सप्ताह में एक बार, प्रूफरीडिंग के लिए तैयार विवरणों का एक बैच ग्राहक को सौंप दिया जाता था।
ग्राहक टीम ने सभी पृष्ठों पर निर्मित टिप्पणियों के रूप में सभी प्रश्नों और परिवर्धन को छोड़ दिया।
और आपूर्तिकर्ता की टीम ने सामग्री का पूरक किया, टिप्पणियों का जवाब दिया, अतिरिक्त अध्ययन के लिए निश्चित प्रश्न।
यदि प्रश्न का उत्तर दिया गया है और सामग्री अपडेट की गई है या अध्ययन के लिए कार्य तय है, तो ग्राहक टीम को टिप्पणी बंद करनी चाहिए।
मौजूदा सप्ताह से दस्तावेजों के एक बैच पर सवाल अगले सप्ताह अगले बैच को स्थानांतरित होने तक बंद कर दिया जाना चाहिए।

प्रत्येक सप्ताह, परियोजना प्रबंधकों को यह समझने का कार्य होता है कि दस्तावेजों के वितरित बैच ने कितना काम किया है, और इससे सशर्त रूप से तैयार क्या माना जा सकता है। और आपूर्तिकर्ता टीम के प्रतिभागियों को समय-समय पर अपने दस्तावेजों पर टिप्पणियों की स्थिति की जांच करने और बाकी के साथ उद्देश्यपूर्ण तरीके से काम करने की आवश्यकता होती है। लेकिन उन्हें कैसे पाया जाए? आप प्रत्येक पृष्ठ खोल सकते हैं, अपनी आंखों के साथ उस पर पहली टिप्पणी देख सकते हैं (या थोड़ी चाल की मदद से), फिर सभी टिप्पणियों पर क्लिक करें, क्योंकि ग्राहक की टीम उन्हें बंद करने, प्रत्येक के बारे में सोचने और जवाब के लिए जाँच करने की जल्दी में नहीं है।

साप्ताहिक बैच में 50-100 अलग-अलग पृष्ठ होते हैं, और अपने हाथों से ऐसा करना महत्वपूर्ण मात्रा में श्रम है। और अगर आप अभी भी दूसरे पक्ष को समझाने के लिए तर्क इकट्ठा करने की कोशिश करते हैं, तो यह बहुत दुखद है। और स्रोत के पाठ को गलती से हटा दिए जाने पर पृष्ठ के त्रुटिपूर्ण संपादन के परिणामस्वरूप लटकने वाली टिप्पणियां भी होती हैं। इस तरह की टिप्पणी हल किए गए लोगों में दिखाई देती है, लेकिन इसे फिर से खोला नहीं जा सकता है (यदि आप पृष्ठ के पाठ में एक अदृश्य मार्कर को फिर से बना सकते हैं)।

साधनों की खोज असफल रही। इसके अलावा, कंफ़्लुएंस को ग्राहक की ओर से तैनात किया जाता है, आप प्लगइन्स को स्थापित नहीं कर सकते, न कि खरीद का उल्लेख करें। कोई मैक्रो डेवलपमेंट विशेषज्ञता नहीं।

कुछ बिंदु पर, मुझे समान जीरा एपीआई का उपयोग करने के साथ कॉन्फ्लुएंस रीस्ट एपीआई और पिछले अनुभव को याद किया। ब्राउज़र से कॉलिंग फ़ंक्शन के साथ खोज और प्रयोगों से पता चला कि आप टिप्पणियों और उनके गुणों को प्राप्त कर सकते हैं। अगला, आपको स्वचालन के लिए एक उपकरण चुनना था, और आप हल करना शुरू कर सकते हैं। मेरे पास टूल्स पर स्क्रिप्ट बनाने का कुछ अनुभव है जो बैश, पर्ल, जेस्क्रिप्ट जैसे प्रशासकों के करीब होने की अधिक संभावना है। मैं कोई डेवलपर नहीं हूं, मेरे पास कोई परिचित या परिचित उपकरण नहीं था। मैं कुछ अधिक सामान्य या उपयुक्त कोशिश करना चाहता था। तब मैंने पायथन एपीआई के लिए एक रैपर की खोज की और इसके साथ प्रयास करने का फैसला किया।

सामान्य सिद्धांत

समस्या निम्नानुसार तैयार की गई थी। आपको एक विशिष्ट साप्ताहिक वितरण से संबंधित सभी पृष्ठ खोजने की आवश्यकता है। उन पर एक सूची में टिप्पणियां एकत्र करें: पृष्ठ, टिप्पणी के लिए लिंक, लेखक और टिप्पणी की तिथि, पृष्ठ पर स्रोत पाठ, टिप्पणी और उत्तर, लेखक और अंतिम उत्तर की तिथि, टिप्पणी की स्थिति। इसके अतिरिक्त, प्रत्येक पृष्ठ के लिए आंकड़े एकत्र करें, कुल कितनी टिप्पणियां, कितने खतरे, कितने खुले। यह सब एक विशेष आँकड़े पृष्ठ पर सहेजें।

मैंने पायथन को रखा, इसके साथ काम करने की मूल बातें देखें, और चलें। सबसे पहले, एक कनेक्शन बनाएँ:

from atlassian import Confluence UserLogin = 'xxxxxx' # input("Login: ") UserPwd = 'xxxxxx' # input("Password: ") confluenceURL = 'http://wiki.xxxxxx' confluence = Confluence( url=confluenceURL, username=UserLogin, password=UserPwd)

एक साप्ताहिक बैच से पृष्ठों की खोज करने के लिए मैंने टैग का उपयोग करने का निर्णय लिया। कैसे उन्हें वितरित करने के लिए एक अलग काम है।

 page_label = 'week123' cql = 'space.key={} and label = "{}" and type = page ' 'ORDER BY title '.format('YYY', page_label) pages = confluence.cql(cql, expand=None, start=0, limit=200)

इसलिए हमें जांचने के लिए पृष्ठों की एक सूची मिली। अगला, हम प्रत्येक व्यक्तिगत पेज को संसाधित करना शुरू करते हैं। हम उनके मापदंडों के साथ टिप्पणियों पर उसके डेटा से एकत्र करते हैं। इन आंकड़ों के आधार पर, हम आँकड़े बनाते हैं कि पृष्ठ पर कितनी टिप्पणियां हैं और किन स्थितियों में हैं। इसके बाद, हम सभी पृष्ठों के लिए परिणाम बाहर खटखटाते हैं और परिणाम को प्रारूपित करना शुरू करते हैं। हम परिणाम तालिका के साथ पृष्ठ का मुख्य भाग बनाते हैं और खुली टिप्पणियों की एक विस्तृत सूची बनाते हैं।

पेज सूची प्रसंस्करण

 statistics = [] open_comments = [] #  - ? if pages is not None: #    ? if pages['size'] > 0: for page in pages['results']: print(page['title']) #       , #  page_comments = page_comments_data(page['content']['id']) #     statistics.append(page_statistics(page_comments)) #        #    . for comment in page_comments: if comment['Result'] not in ['resolved', 'nocomment']: if not (comment['Result'] == 'dangling' and comment['Author'] in excludeNames): open_comments.append(comment) #       . statistics.append(total_statistics(statistics)) #     page_id = confluence.get_page_id(space='YYY', title=page_title) #     ,    . page_body = ('<p><ac:structured-macro ac:name="toc" ac:schema-version="1"' '/></p>' '<h1>Comments Statistics</h1>{}' '<h1>Open Comments List</h1>{}' ).format(create_table(statistics), create_table(open_comments)) #  if page_id is not None: status = confluence.update_page( page_id=page_id, title=page_title, body=page_body, representation='storage' )

एपीआई सुविधाएँ

अब आइए जानें कि पेज को कैसे प्रोसेस करना है। डिफ़ॉल्ट रूप से, एपीआई केवल मूल जानकारी देता है, जैसे कि एक पहचानकर्ता या पृष्ठ का नाम। सभी अतिरिक्त गुणों को स्पष्ट रूप से निर्दिष्ट किया जाना चाहिए। कॉल के परिणाम का विश्लेषण करके उन्हें देखा जा सकता है। अतिरिक्त डेटा _expandable के वर्गों या उपखंडों में पाया जा सकता है। जब तक आवश्यक डेटा नहीं मिल जाता तब तक हम विस्तार करने के लिए वांछित आइटम जोड़ते हैं और आगे देखते हैं।

मुद्दा उदाहरण

 http://wiki.xxxxxx/rest/api/content/101743895?expand=body,children.comment { "id": "97517865", "type": "page", "status": "current", "title": "w2019-47 comments status", "children": { "comment": { "results": [], "start": 0, "limit": 25, "size": 25, "_links": {} }, "_links": {}, "_expandable": { "attachment": "/rest/api/content/97517865/child/attachment", "page": "/rest/api/content/97517865/child/page" } }, "body": { "_expandable": { "editor": "", "view": "", "export_view": "", "styled_view": "", "storage": "", "anonymous_export_view": "" } }, "extensions": { "position": "none" }, "_links": {}, "_expandable": { "metadata": "", "operations": "", "restrictions": "/rest/api/content/97517865/restriction/byOperation", "history": "/rest/api/content/97517865/history", "ancestors": "", "version": "", "descendants": "/rest/api/content/97517865/descendant", } }

और जारी किए गए परिणामों की संख्या पर भी प्रतिबंध है, पृष्ठ पर अंक लगाना। यह सर्वर साइड (एपीआई?) पर कॉन्फ़िगर किया गया है और हमारे मामले में यह 25 है। कुछ अनुरोधों के लिए इसे स्पष्ट रूप से निर्दिष्ट करके बदला जा सकता है, लेकिन यह केवल शीर्ष स्तर के लिए काम करेगा। और पृष्ठ पर टिप्पणियों का खुलासा करते हुए, हम सभी को केवल 25 ही मिलते हैं, जबकि आकार भी नकली है। उदाहरण में वास्तविकता में 29 थे। हम पृष्ठ आकार को निर्दिष्ट करने की क्षमता के साथ get_page_comments - कंफ्लुएंस मॉड्यूल में एक अलग फ़ंक्शन का उपयोग करके टिप्पणियों के पृष्ठ पर अंकुश लगाने में कामयाब रहे।

 #    import re #      XML def replace_chars2(in_text): text = re.sub(r'&', '&', in_text) text = re.sub(r'\'', ''', text) text = re.sub(r'<', '<', text) text = re.sub(r'>', '>', text) text = re.sub(r'"', '"', text) return text

अगला नुकसान विशेष पात्रों के संरक्षण और जारी करने की सुविधाओं में था। एक पृष्ठ या टिप्पणी का मुख्य भाग कई दृश्यों में प्राप्त किया जा सकता है: आंतरिक XML - संग्रहण, मैक्रो आउटपुट के बिना मध्यवर्ती HTML - मैक्रो आउटपुट के साथ दृश्य और HTML - Export_view। लेकिन पृष्ठ का शीर्षक और मूल टिप्पणी मूल पाठ हमेशा पढ़ने के लिए उपयुक्त रूप में जारी की जाती है। क्योंकि भविष्य में, ये आंकड़े आंकड़ों के साथ पृष्ठ के शरीर में आते हैं, फिर कुछ पात्रों ने रूपांतरण त्रुटियों का नेतृत्व किया। मुझे ऊपर एक प्रतिस्थापन प्रक्रिया लिखनी थी।

पेज टिप्पणियाँ

अब पेज को पार्स करने के लिए। यह एक प्रक्रिया है जो एक पृष्ठ को लोड करती है, अपना डेटा एकत्र करती है, फिर उत्तरों के साथ टिप्पणियों की एक सूची निकालती है और उन्हें पत्राचार में एकत्र करती है। परिणाम शब्दकोशों की एक सूची है, जहां सूची का प्रत्येक तत्व उत्तर के साथ एक टिप्पणी से मेल खाता है। और इस टिप्पणी की सभी विशेषताएँ शब्दकोश के संबंधित क्षेत्रों में निहित हैं।

सिंगल पेज प्रोसेसिंग

 def page_comments_data(page_identifier): #,      ,  , #   , #  ,    ,    #   (). expand_text = ('body.storage,extensions.inlineProperties' ',extensions.resolution,version,children.comment' ',children.comment.version,children.comment.body.storage' ) #    .     . conf_page = confluence.get_page_by_id(page_identifier, expand='body.storage') page_title = replace_chars2(conf_page['title']) #   . link_base = conf_page['_links']['base'] page_link = link_base + conf_page['_links']['webui'] page_code = '<a href="{}">{}</a>'.format(page_link, page_title) #   page_comments = confluence.get_page_comments(content_id=page_identifier, start=0, limit=1000, comments = [] #    for comment in page_comments['results']: #      - . if comment['extensions']['location'] == 'footer': continue #  comment_text = comment['body']['storage']['value'] comment_result = comment['extensions']['resolution']['status'] comment_link = '<a href="{}">{}</a>'\ .format(link_base + comment['_links']['webui'], 'link') #  comment_link = re.sub(r'&focusedCommentId=', '&focusedCommentId=', comment_link) #  created_when = re.sub(r'\.000\+', ' GMT+', re.sub(r'T', ' ', comment['version']['when'])) created_by = comment['version']['by']['displayName'] orig_text = replace_chars2(comment['extensions'] ['inlineProperties']['originalSelection']) #    /. thread = '<b>To text: </b>{}<br/><b>At: </b>{}<br/><b>By: ' '</b>{}<br/>{}'.format(orig_text, created_when, created_by, comment_text) last_by = '' last_when = '' #  answers = comment['children']['comment']['size'] if answers > 0: for message in comment['children']['comment']['results']: #  last_when = re.sub(r'\.000\+', ' GMT+', re.sub(r'T', ' ', message['version']['when'])) last_by = message['version']['by']['displayName'] #  thread += ('<br/>===next===<br/><b>At: </b>{}<br/><b>By: ' '</b>{}<br/>{}'.format(last_when, last_by, message['body']['storage']['value']) ) #  . row_comm = {"Page": page_code, "Comment": comment_link, "Thread": thread, "Result": comment_result, "Answers count": answers, "Creation Date": created_when, "Author": created_by, "Last Date": last_when, "Last Author": last_by} comments.append(row_comm) #   ,   , #     . if len(comments) == 0: row_comm = {"Page": page_code, "Comment": 'nolink', "Thread": 'nocomment', "Result": 'nocomment', "Answers count": 0, "Creation Date": 'never', "Author": 'nobody', "Last Date": 'never', "Last Author": 'nobody'} comments.append(row_comm) return comments

सांख्यिकी और टेबल

डेटा प्रस्तुति की स्पष्टता के लिए, हम उन पर आंकड़े एकत्र करते हैं और उन्हें तालिकाओं के रूप में व्यवस्थित करते हैं।

हम आंकड़ों की प्रक्रिया करते हैं

 def page_statistics(comments_data): open_count = 0 dang_count = 0 comment_count = len(comments_data) if comment_count > 0: for comment in comments_data: #     if comment['Result'] not in ['resolved', 'nocomment']: if comment['Result'] in ['open', 'reopened']: open_count += 1 if comment['Result'] == 'dangling' and comment['Author'] not in excludeNames: dang_count += 1 res_dict = {'Page': comments_data[0]['Page'], 'Total': comment_count, 'Resolved': comment_count - open_count - dang_count, 'Dangling': dang_count, 'Open': open_count} return res_dict #   def total_statistics(stat_data): total_comment = 0 total_resolved = 0 total_open = 0 total_dangling = 0 for statRow in stat_data: total_comment += statRow['Total'] total_resolved += statRow['Resolved'] total_open += statRow['Open'] total_dangling += statRow['Dangling'] res_dict = {'Page': 'All Pages Total', 'Type': '', 'Jira': '', 'Status': '', 'Total': total_comment, 'Resolved': total_resolved, 'Dangling': total_dangling, 'Open': total_open} return res_dict

तालिकाओं के रूप में डेटा बनाने के लिए, हम एक और प्रक्रिया करेंगे। यह शब्दकोशों की सूची से तालिका का HTML कोड बनाता है, शीर्षकों के रूप में यह शब्दकोश कुंजियों के नाम से एक पंक्ति जोड़ता है और पंक्ति संख्याओं के साथ एक स्तंभ जोड़ता है।

 def create_table(tab_data): tab_start = '<table style="width: 100.00%;"><colgroup><col />' '<col /></colgroup><tbody>' tab_end = '</tbody></table>' tab_code = tab_start + '<tr>' row_num = 1 if len(tab_data) > 0: tab_code += '<th>Num</th>' for key in tab_data[0].keys(): tab_code += '<th>{}</th>'.format(key) tab_code += '</tr>' for row in tab_data: tab_code += '<tr><td>{}</td>'.format(row_num) row_num += 1 for field in row.values(): tab_code += '<td>{}</td>'.format(field) tab_code += '</tr>' tab_code += tab_end + '\n' return tab_code

अब सब कुछ तैयार है। स्क्रिप्ट को लेबल करने और चलाने के बाद, हमें एक पेज मिलता है जो कुछ इस तरह दिखता है:

पुनश्च

बेशक, यह सब नहीं है जो अंत में निकला। पृष्ठों की पार्सिंग और जीरा में टास्क नंबर के साथ मैक्रो की खोज थी। जीरा में टास्क नंबरों द्वारा एक स्वचालित लेबलिंग थी और उनसे कॉन्फ्लुएंस के लिंक थे। साप्ताहिक वितरण सूचियों की तुलना और सत्यापन किया गया था। एक्सेल में टिप्पणियों की बचत और कई साप्ताहिक एक्सेल फाइलों से आम डेटा का संग्रह था। और हाल ही में Word से पार्सिंग टिप्पणियाँ जोड़ी गई हैं।