From 5b00c048d3db42bbd9a9bab294f89f5680c0871a Mon Sep 17 00:00:00 2001 From: Shailja Khurana Date: Wed, 6 Sep 2023 00:21:15 +0000 Subject: [PATCH 1/2] bugfix for failed discussions triggeredByNewCommnt --- dist/index.js | 23 ++++++++++------- src/index.ts | 71 +++++++++++++++++++++++++++------------------------ 2 files changed, 52 insertions(+), 42 deletions(-) diff --git a/dist/index.js b/dist/index.js index 26eb3b6..62e48e5 100644 --- a/dist/index.js +++ b/dist/index.js @@ -46435,17 +46435,22 @@ const INSTRUCTIONS_TEXT = core.getInput('instructions-response-text', { required async function main() { const githubClient = new GithubDiscussionClient_1.GithubDiscussionClient(); await githubClient.initializeAttentionLabelId(); - if ((0, util_1.triggeredByNewComment)()) { - if (github.context.payload.comment?.body.indexOf(PROPOSED_ANSWER_KEYWORD) >= 0) { - core.info('Comment created with proposed answer keyword. Adding instuctions reply to comment'); - githubClient.addInstructionTextReply(INSTRUCTIONS_TEXT, github.context.payload.discussion.node_id, github.context.payload.comment.node_id); + try { + if ((0, util_1.triggeredByNewComment)()) { + if (github.context.payload.comment?.body.indexOf(PROPOSED_ANSWER_KEYWORD) >= 0) { + core.info('Comment created with proposed answer keyword. Adding instuctions reply to comment with id: ' + github.context.payload.discussion.node_id); + githubClient.addInstructionTextReply(INSTRUCTIONS_TEXT, github.context.payload.discussion.node_id, github.context.payload.comment.node_id); + } + else { + core.info('Comment created without proposed answer keyword. No action needed'); + } } else { - core.info('Comment created without proposed answer keyword. No action needed'); + await processDiscussions(githubClient); } } - else { - await processDiscussions(githubClient); + catch (e) { + core.info(e.message); } } async function processDiscussions(githubClient) { @@ -46470,7 +46475,7 @@ async function processDiscussions(githubClient) { continue; } else if (discussion?.node?.closed) { - core.debug(`Discussion ${discussionId} is closed, so no action needed.`); + core.info(`Discussion ${discussionId} is closed, so no action needed.`); continue; } else if (discussion?.node?.locked && CLOSE_LOCKED_DISCUSSIONS) { @@ -46557,7 +46562,7 @@ function closeAndMarkAsAnswered(comment, discussionId, githubClient) { githubClient.closeDiscussionAsResolved(discussionId); } main(); -//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"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","sourcesContent":["import * as octokit from '@octokit/graphql-schema';\nimport * as core from '@actions/core';\nimport * as github from '@actions/github';\nimport { GithubDiscussionClient } from \"./GithubDiscussionClient\";\nimport { containsKeyword, containsNegativeReaction, containsPositiveReaction, exceedsDaysUntilStale, hasReplies, triggeredByNewComment, hasNonBotReply } from './util';\nimport { DiscussionCommentEdge } from './generated/graphql';\n\nconst PAGE_SIZE = parseInt(core.getInput('page-size', { required: false })) || 50;\nconst GITHUB_BOT = core.getInput('github-bot', { required: false}) || 'github-actions';\nconst DAYS_UNTIL_STALE = parseFloat(core.getInput('days-until-stale', { required: false })) || 7;\nconst PROPOSED_ANSWER_KEYWORD = core.getInput('proposed-answer-keyword', { required: false }) || '@github-actions proposed-answer';\nconst closeLockedDiscussionsInput = core.getInput('close-locked-discussions', { required: false });\nconst CLOSE_LOCKED_DISCUSSIONS = closeLockedDiscussionsInput.toLowerCase() === 'false' ? false : true;\nconst closeAnsweredDiscussionsInput = core.getInput('close-answered-discussions', { required: false });\nconst CLOSE_ANSWERED_DISCUSSIONS = closeAnsweredDiscussionsInput.toLowerCase() === 'false' ? false : true;\nconst closeStaleAsAnsweredInput = core.getInput('close-stale-as-answered', { required: false });\nconst CLOSE_STALE_AS_ANSWERED = closeStaleAsAnsweredInput.toLowerCase() === 'false' ? false : true;\nconst CLOSE_FOR_STALENESS_RESPONSE_TEXT = core.getInput('stale-response-text', { required: false })\n  || 'Closing the discussion for staleness. Please open a new discussion if you have further concerns.';\nconst INSTRUCTIONS_TEXT = core.getInput('instructions-response-text', { required: false })\n  || 'Hello! A team member has marked the above comment as the likely answer to this discussion thread. '\n  + '\\n \\n * If you agree, please upvote that comment, or click on Mark as answer. I will automatically mark the comment as the answer next time I check. '\n  + '\\n \\n * If this answer does not help you, please downvote the answer instead and let us know why it was not helpful. '\n  + 'I will add a label to this discussion to gain attention from the team.';\n\nasync function main() {\n  const githubClient = new GithubDiscussionClient();\n  await githubClient.initializeAttentionLabelId();\n  if (triggeredByNewComment()) {\n    if (github.context.payload.comment?.body.indexOf(PROPOSED_ANSWER_KEYWORD) >= 0) {\n      core.info('Comment created with proposed answer keyword. Adding instuctions reply to comment');\n      githubClient.addInstructionTextReply(INSTRUCTIONS_TEXT, github.context.payload.discussion!.node_id, github.context.payload.comment!.node_id);\n    } else {\n      core.info('Comment created without proposed answer keyword. No action needed');\n    }\n  } else {\n    await processDiscussions(githubClient);\n  }\n}\n\nexport async function processDiscussions(githubClient: GithubDiscussionClient) {\n  const discussionCategoryIDList: string[] = await githubClient.getAnswerableDiscussionCategoryIDs();\n  if (discussionCategoryIDList.length === 0) {\n    core.info('No answerable discussions found. Exiting.');\n    return;\n  }\n\n  for (const discussionCategoryID of discussionCategoryIDList) {\n    let hasNextPage = true;\n    let afterCursor: string | null = null;\n\n    while (hasNextPage) {\n      const discussions = await githubClient.getDiscussionsMetaData(discussionCategoryID, PAGE_SIZE, afterCursor!);\n      hasNextPage = discussions.pageInfo.hasNextPage;\n      afterCursor = discussions.pageInfo.endCursor!;\n    \n      for (const discussion of discussions.edges!) {\n        var discussionId = discussion?.node?.id ? discussion?.node?.id : \"\";\n        var discussionNum = discussion?.node?.number ? discussion.node.number : 0;\n        core.debug(`Processing discussionId: ${discussionId} with number: ${discussionNum} and bodyText: ${discussion?.node?.bodyText}`);\n        if (discussionId === \"\" || discussionNum === 0) {\n          core.warning(`Can not proceed checking discussion, discussionId is null!`);\n          continue;\n        }\n        else if (discussion?.node?.closed) {\n          core.debug(`Discussion ${discussionId} is closed, so no action needed.`);\n          continue;\n        }\n        else if (discussion?.node?.locked && CLOSE_LOCKED_DISCUSSIONS) {\n          core.info(`Discussion ${discussionId} is locked, closing it as resolved`);\n          githubClient.closeDiscussionAsResolved(discussionId);\n          continue;\n        }\n        else if (discussion?.node?.answer != null && CLOSE_ANSWERED_DISCUSSIONS) {\n          core.info(`Discussion ${discussionId} is already answered, so closing it as resolved.`);\n          githubClient.closeDiscussionAsResolved(discussionId);\n          continue;\n        }\n        else {\n          await processComments(discussion!, githubClient);\n        }\n      }\n    }\n  }\n}\n\nexport async function processComments(discussion: octokit.DiscussionEdge, githubClient: GithubDiscussionClient) {\n  const discussionId = discussion.node?.id ? discussion.node?.id : \"\";\n  const discussionNum = discussion.node?.number ? discussion.node?.number : 0;\n  const commentCount = await githubClient.getDiscussionCommentCount(discussionNum);\n  const comments = await githubClient.getCommentsMetaData(discussionNum, commentCount);\n\n  if (commentCount !== 0) {\n    for (const comment of comments.edges!) {\n      const commentId = comment?.node?.id;\n      core.debug(`Processing comment ${commentId} with bodytext: ${comment?.node?.bodyText}`);\n      if (!comment?.node?.bodyText || !comment.node.id) {\n        core.warning(`Comment body or id is null in discussion ${discussionId}, skipping comment!`);\n        continue;\n      }\n      if (!containsKeyword(comment!, PROPOSED_ANSWER_KEYWORD)) {\n        core.debug(`No answer proposed on comment ${commentId}, no action needed!`);\n        continue;\n      }\n      else {\n        if (containsNegativeReaction(comment)) {\n          core.info(`Negative reaction received. Adding attention label to discussion ${discussionId} to receive further attention from a repository maintainer`);\n          githubClient.addAttentionLabelToDiscussion(discussionId);\n        }\n        else if (containsPositiveReaction(comment)) {\n          core.info(`Positive reaction received. Marking discussion ${discussionId} as answered, and editing answer to remove proposed answer keyword`);\n          closeAndMarkAsAnswered(comment, discussionId, githubClient);\n        }\n        else if (!hasReplies(comment)) {\n          core.info(`Since this has no reply, adding instructions reply to comment ${commentId} in discussion ${discussionId}`);\n          githubClient.addInstructionTextReply(INSTRUCTIONS_TEXT, discussionId, commentId!);\n        }\n        else if (hasNonBotReply(comment, GITHUB_BOT)) {\n          core.info(`Discussion ${discussionId} has a reply, but not an instructions reply. Adding attention label`);\n          githubClient.addAttentionLabelToDiscussion(discussionId);\n        }\n        else if (exceedsDaysUntilStale(comment, DAYS_UNTIL_STALE)) {\n          if (CLOSE_STALE_AS_ANSWERED) {\n            core.info(`No one has responded or provided a reaction, closing discussion ${discussionId} as answered`);\n            closeAndMarkAsAnswered(comment, discussionId, githubClient);\n          } else {\n            core.info(`No one has responded or provided a reaction, closing discussion ${discussionId} with a comment`);\n            closeDiscussionForStaleness(discussionId, githubClient);\n          }\n        }\n      }\n    };\n  }\n  else {\n    core.debug(`No comments found for discussion ${discussionId}, No action needed!`);\n  }\n}\n\nfunction closeDiscussionForStaleness(discussionId: string, githubClient: GithubDiscussionClient) {\n  githubClient.addCommentToDiscussion(discussionId, CLOSE_FOR_STALENESS_RESPONSE_TEXT);\n  githubClient.closeDiscussionAsOutdated(discussionId);\n}\n\nfunction closeAndMarkAsAnswered(comment: DiscussionCommentEdge, discussionId: string, githubClient: GithubDiscussionClient) {\n  const bodyText = comment?.node?.bodyText!;\n  const commentId = comment?.node?.id!;\n  const updatedAnswerText = bodyText.replace(PROPOSED_ANSWER_KEYWORD, 'Answer: ');\n  githubClient.updateDiscussionComment(commentId, updatedAnswerText);\n  githubClient.markDiscussionCommentAsAnswer(commentId);\n  githubClient.closeDiscussionAsResolved(discussionId);\n}\n\nmain();\n"]} +//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";;;AACA,sCAAsC;AACtC,0CAA0C;AAC1C,qEAAkE;AAClE,iCAAuK;AAGvK,MAAM,SAAS,GAAG,QAAQ,CAAC,IAAI,CAAC,QAAQ,CAAC,WAAW,EAAE,EAAE,QAAQ,EAAE,KAAK,EAAE,CAAC,CAAC,IAAI,EAAE,CAAC;AAClF,MAAM,UAAU,GAAG,IAAI,CAAC,QAAQ,CAAC,YAAY,EAAE,EAAE,QAAQ,EAAE,KAAK,EAAC,CAAC,IAAI,gBAAgB,CAAC;AACvF,MAAM,gBAAgB,GAAG,UAAU,CAAC,IAAI,CAAC,QAAQ,CAAC,kBAAkB,EAAE,EAAE,QAAQ,EAAE,KAAK,EAAE,CAAC,CAAC,IAAI,CAAC,CAAC;AACjG,MAAM,uBAAuB,GAAG,IAAI,CAAC,QAAQ,CAAC,yBAAyB,EAAE,EAAE,QAAQ,EAAE,KAAK,EAAE,CAAC,IAAI,iCAAiC,CAAC;AACnI,MAAM,2BAA2B,GAAG,IAAI,CAAC,QAAQ,CAAC,0BAA0B,EAAE,EAAE,QAAQ,EAAE,KAAK,EAAE,CAAC,CAAC;AACnG,MAAM,wBAAwB,GAAG,2BAA2B,CAAC,WAAW,EAAE,KAAK,OAAO,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,IAAI,CAAC;AACtG,MAAM,6BAA6B,GAAG,IAAI,CAAC,QAAQ,CAAC,4BAA4B,EAAE,EAAE,QAAQ,EAAE,KAAK,EAAE,CAAC,CAAC;AACvG,MAAM,0BAA0B,GAAG,6BAA6B,CAAC,WAAW,EAAE,KAAK,OAAO,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,IAAI,CAAC;AAC1G,MAAM,yBAAyB,GAAG,IAAI,CAAC,QAAQ,CAAC,yBAAyB,EAAE,EAAE,QAAQ,EAAE,KAAK,EAAE,CAAC,CAAC;AAChG,MAAM,uBAAuB,GAAG,yBAAyB,CAAC,WAAW,EAAE,KAAK,OAAO,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,IAAI,CAAC;AACnG,MAAM,iCAAiC,GAAG,IAAI,CAAC,QAAQ,CAAC,qBAAqB,EAAE,EAAE,QAAQ,EAAE,KAAK,EAAE,CAAC;OAC9F,kGAAkG,CAAC;AACxG,MAAM,iBAAiB,GAAG,IAAI,CAAC,QAAQ,CAAC,4BAA4B,EAAE,EAAE,QAAQ,EAAE,KAAK,EAAE,CAAC;OACrF,oGAAoG;UACrG,uJAAuJ;UACvJ,uHAAuH;UACvH,wEAAwE,CAAC;AAE7E,KAAK,UAAU,IAAI;IACjB,MAAM,YAAY,GAAG,IAAI,+CAAsB,EAAE,CAAC;IAClD,MAAM,YAAY,CAAC,0BAA0B,EAAE,CAAC;IAChD,IAAG;QACD,IAAI,IAAA,4BAAqB,GAAE,EAAE;YAC3B,IAAI,MAAM,CAAC,OAAO,CAAC,OAAO,CAAC,OAAO,EAAE,IAAI,CAAC,OAAO,CAAC,uBAAuB,CAAC,IAAI,CAAC,EAAE;gBAC9E,IAAI,CAAC,IAAI,CAAC,6FAA6F,GAAE,MAAM,CAAC,OAAO,CAAC,OAAO,CAAC,UAAW,CAAC,OAAO,CAAC,CAAC;gBACrJ,YAAY,CAAC,uBAAuB,CAAC,iBAAiB,EAAE,MAAM,CAAC,OAAO,CAAC,OAAO,CAAC,UAAW,CAAC,OAAO,EAAE,MAAM,CAAC,OAAO,CAAC,OAAO,CAAC,OAAQ,CAAC,OAAO,CAAC,CAAC;aAC9I;iBAAM;gBACL,IAAI,CAAC,IAAI,CAAC,mEAAmE,CAAC,CAAC;aAChF;SACF;aAAM;YACL,MAAM,kBAAkB,CAAC,YAAY,CAAC,CAAC;SACxC;KACF;IACD,OAAM,CAAC,EAAC;QACN,IAAI,CAAC,IAAI,CAAE,CAAW,CAAC,OAAO,CAAC,CAAC;KACjC;AACH,CAAC;AAEM,KAAK,UAAU,kBAAkB,CAAC,YAAoC;IAC3E,MAAM,wBAAwB,GAAa,MAAM,YAAY,CAAC,kCAAkC,EAAE,CAAC;IACnG,IAAI,wBAAwB,CAAC,MAAM,KAAK,CAAC,EAAE;QACzC,IAAI,CAAC,IAAI,CAAC,2CAA2C,CAAC,CAAC;QACvD,OAAO;KACR;IAED,KAAK,MAAM,oBAAoB,IAAI,wBAAwB,EAAE;QAC3D,IAAI,WAAW,GAAG,IAAI,CAAC;QACvB,IAAI,WAAW,GAAkB,IAAI,CAAC;QAEtC,OAAO,WAAW,EAAE;YAClB,MAAM,WAAW,GAAG,MAAM,YAAY,CAAC,sBAAsB,CAAC,oBAAoB,EAAE,SAAS,EAAE,WAAY,CAAC,CAAC;YAC7G,WAAW,GAAG,WAAW,CAAC,QAAQ,CAAC,WAAW,CAAC;YAC/C,WAAW,GAAG,WAAW,CAAC,QAAQ,CAAC,SAAU,CAAC;YAE5C,KAAK,MAAM,UAAU,IAAI,WAAW,CAAC,KAAM,EAAE;gBAC3C,IAAI,YAAY,GAAG,UAAU,EAAE,IAAI,EAAE,EAAE,CAAC,CAAC,CAAC,UAAU,EAAE,IAAI,EAAE,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;gBACpE,IAAI,aAAa,GAAG,UAAU,EAAE,IAAI,EAAE,MAAM,CAAC,CAAC,CAAC,UAAU,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC;gBAC1E,IAAI,CAAC,KAAK,CAAC,4BAA4B,YAAY,iBAAiB,aAAa,kBAAkB,UAAU,EAAE,IAAI,EAAE,QAAQ,EAAE,CAAC,CAAC;gBACjI,IAAI,YAAY,KAAK,EAAE,IAAI,aAAa,KAAK,CAAC,EAAE;oBAC9C,IAAI,CAAC,OAAO,CAAC,4DAA4D,CAAC,CAAC;oBAC3E,SAAS;iBACV;qBACI,IAAI,UAAU,EAAE,IAAI,EAAE,MAAM,EAAE;oBACjC,IAAI,CAAC,IAAI,CAAC,cAAc,YAAY,kCAAkC,CAAC,CAAC;oBACxE,SAAS;iBACV;qBACI,IAAI,UAAU,EAAE,IAAI,EAAE,MAAM,IAAI,wBAAwB,EAAE;oBAC7D,IAAI,CAAC,IAAI,CAAC,cAAc,YAAY,oCAAoC,CAAC,CAAC;oBAC1E,YAAY,CAAC,yBAAyB,CAAC,YAAY,CAAC,CAAC;oBACrD,SAAS;iBACV;qBACI,IAAI,UAAU,EAAE,IAAI,EAAE,MAAM,IAAI,IAAI,IAAI,0BAA0B,EAAE;oBACvE,IAAI,CAAC,IAAI,CAAC,cAAc,YAAY,kDAAkD,CAAC,CAAC;oBACxF,YAAY,CAAC,yBAAyB,CAAC,YAAY,CAAC,CAAC;oBACrD,SAAS;iBACV;qBACI;oBACH,MAAM,eAAe,CAAC,UAAW,EAAE,YAAY,CAAC,CAAC;iBAClD;aACF;SACF;KACF;AACH,CAAC;AA5CH,gDA4CG;AAEI,KAAK,UAAU,eAAe,CAAC,UAAkC,EAAE,YAAoC;IAC5G,MAAM,YAAY,GAAG,UAAU,CAAC,IAAI,EAAE,EAAE,CAAC,CAAC,CAAC,UAAU,CAAC,IAAI,EAAE,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;IACpE,MAAM,aAAa,GAAG,UAAU,CAAC,IAAI,EAAE,MAAM,CAAC,CAAC,CAAC,UAAU,CAAC,IAAI,EAAE,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC;IAC5E,MAAM,YAAY,GAAG,MAAM,YAAY,CAAC,yBAAyB,CAAC,aAAa,CAAC,CAAC;IACjF,MAAM,QAAQ,GAAG,MAAM,YAAY,CAAC,mBAAmB,CAAC,aAAa,EAAE,YAAY,CAAC,CAAC;IAErF,IAAI,YAAY,KAAK,CAAC,EAAE;QACtB,KAAK,MAAM,OAAO,IAAI,QAAQ,CAAC,KAAM,EAAE;YACrC,MAAM,SAAS,GAAG,OAAO,EAAE,IAAI,EAAE,EAAE,CAAC;YACpC,IAAI,CAAC,KAAK,CAAC,sBAAsB,SAAS,mBAAmB,OAAO,EAAE,IAAI,EAAE,QAAQ,EAAE,CAAC,CAAC;YACxF,IAAI,CAAC,OAAO,EAAE,IAAI,EAAE,QAAQ,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,EAAE,EAAE;gBAChD,IAAI,CAAC,OAAO,CAAC,4CAA4C,YAAY,qBAAqB,CAAC,CAAC;gBAC5F,SAAS;aACV;YACD,IAAI,CAAC,IAAA,sBAAe,EAAC,OAAQ,EAAE,uBAAuB,CAAC,EAAE;gBACvD,IAAI,CAAC,KAAK,CAAC,iCAAiC,SAAS,qBAAqB,CAAC,CAAC;gBAC5E,SAAS;aACV;iBACI;gBACH,IAAI,IAAA,+BAAwB,EAAC,OAAO,CAAC,EAAE;oBACrC,IAAI,CAAC,IAAI,CAAC,oEAAoE,YAAY,4DAA4D,CAAC,CAAC;oBACxJ,YAAY,CAAC,6BAA6B,CAAC,YAAY,CAAC,CAAC;iBAC1D;qBACI,IAAI,IAAA,+BAAwB,EAAC,OAAO,CAAC,EAAE;oBAC1C,IAAI,CAAC,IAAI,CAAC,kDAAkD,YAAY,oEAAoE,CAAC,CAAC;oBAC9I,sBAAsB,CAAC,OAAO,EAAE,YAAY,EAAE,YAAY,CAAC,CAAC;iBAC7D;qBACI,IAAI,CAAC,IAAA,iBAAU,EAAC,OAAO,CAAC,EAAE;oBAC7B,IAAI,CAAC,IAAI,CAAC,iEAAiE,SAAS,kBAAkB,YAAY,EAAE,CAAC,CAAC;oBACtH,YAAY,CAAC,uBAAuB,CAAC,iBAAiB,EAAE,YAAY,EAAE,SAAU,CAAC,CAAC;iBACnF;qBACI,IAAI,IAAA,qBAAc,EAAC,OAAO,EAAE,UAAU,CAAC,EAAE;oBAC5C,IAAI,CAAC,IAAI,CAAC,cAAc,YAAY,qEAAqE,CAAC,CAAC;oBAC3G,YAAY,CAAC,6BAA6B,CAAC,YAAY,CAAC,CAAC;iBAC1D;qBACI,IAAI,IAAA,4BAAqB,EAAC,OAAO,EAAE,gBAAgB,CAAC,EAAE;oBACzD,IAAI,uBAAuB,EAAE;wBAC3B,IAAI,CAAC,IAAI,CAAC,mEAAmE,YAAY,cAAc,CAAC,CAAC;wBACzG,sBAAsB,CAAC,OAAO,EAAE,YAAY,EAAE,YAAY,CAAC,CAAC;qBAC7D;yBAAM;wBACL,IAAI,CAAC,IAAI,CAAC,mEAAmE,YAAY,iBAAiB,CAAC,CAAC;wBAC5G,2BAA2B,CAAC,YAAY,EAAE,YAAY,CAAC,CAAC;qBACzD;iBACF;aACF;SACF;QAAA,CAAC;KACH;SACI;QACH,IAAI,CAAC,KAAK,CAAC,oCAAoC,YAAY,qBAAqB,CAAC,CAAC;KACnF;AACH,CAAC;AAlDD,0CAkDC;AAED,SAAS,2BAA2B,CAAC,YAAoB,EAAE,YAAoC;IAC7F,YAAY,CAAC,sBAAsB,CAAC,YAAY,EAAE,iCAAiC,CAAC,CAAC;IACrF,YAAY,CAAC,yBAAyB,CAAC,YAAY,CAAC,CAAC;AACvD,CAAC;AAED,SAAS,sBAAsB,CAAC,OAA8B,EAAE,YAAoB,EAAE,YAAoC;IACxH,MAAM,QAAQ,GAAG,OAAO,EAAE,IAAI,EAAE,QAAS,CAAC;IAC1C,MAAM,SAAS,GAAG,OAAO,EAAE,IAAI,EAAE,EAAG,CAAC;IACrC,MAAM,iBAAiB,GAAG,QAAQ,CAAC,OAAO,CAAC,uBAAuB,EAAE,UAAU,CAAC,CAAC;IAChF,YAAY,CAAC,uBAAuB,CAAC,SAAS,EAAE,iBAAiB,CAAC,CAAC;IACnE,YAAY,CAAC,6BAA6B,CAAC,SAAS,CAAC,CAAC;IACtD,YAAY,CAAC,yBAAyB,CAAC,YAAY,CAAC,CAAC;AACvD,CAAC;AAED,IAAI,EAAE,CAAC","sourcesContent":["import * as octokit from '@octokit/graphql-schema';\nimport * as core from '@actions/core';\nimport * as github from '@actions/github';\nimport { GithubDiscussionClient } from \"./GithubDiscussionClient\";\nimport { containsKeyword, containsNegativeReaction, containsPositiveReaction, exceedsDaysUntilStale, hasReplies, triggeredByNewComment, hasNonBotReply } from './util';\nimport { DiscussionCommentEdge } from './generated/graphql';\n\nconst PAGE_SIZE = parseInt(core.getInput('page-size', { required: false })) || 50;\nconst GITHUB_BOT = core.getInput('github-bot', { required: false}) || 'github-actions';\nconst DAYS_UNTIL_STALE = parseFloat(core.getInput('days-until-stale', { required: false })) || 7;\nconst PROPOSED_ANSWER_KEYWORD = core.getInput('proposed-answer-keyword', { required: false }) || '@github-actions proposed-answer';\nconst closeLockedDiscussionsInput = core.getInput('close-locked-discussions', { required: false });\nconst CLOSE_LOCKED_DISCUSSIONS = closeLockedDiscussionsInput.toLowerCase() === 'false' ? false : true;\nconst closeAnsweredDiscussionsInput = core.getInput('close-answered-discussions', { required: false });\nconst CLOSE_ANSWERED_DISCUSSIONS = closeAnsweredDiscussionsInput.toLowerCase() === 'false' ? false : true;\nconst closeStaleAsAnsweredInput = core.getInput('close-stale-as-answered', { required: false });\nconst CLOSE_STALE_AS_ANSWERED = closeStaleAsAnsweredInput.toLowerCase() === 'false' ? false : true;\nconst CLOSE_FOR_STALENESS_RESPONSE_TEXT = core.getInput('stale-response-text', { required: false })\n  || 'Closing the discussion for staleness. Please open a new discussion if you have further concerns.';\nconst INSTRUCTIONS_TEXT = core.getInput('instructions-response-text', { required: false })\n  || 'Hello! A team member has marked the above comment as the likely answer to this discussion thread. '\n  + '\\n \\n * If you agree, please upvote that comment, or click on Mark as answer. I will automatically mark the comment as the answer next time I check. '\n  + '\\n \\n * If this answer does not help you, please downvote the answer instead and let us know why it was not helpful. '\n  + 'I will add a label to this discussion to gain attention from the team.';\n\nasync function main() {\n  const githubClient = new GithubDiscussionClient();\n  await githubClient.initializeAttentionLabelId();\n  try{\n    if (triggeredByNewComment()) {\n      if (github.context.payload.comment?.body.indexOf(PROPOSED_ANSWER_KEYWORD) >= 0) {\n        core.info('Comment created with proposed answer keyword. Adding instuctions reply to comment with id: '+ github.context.payload.discussion!.node_id);\n        githubClient.addInstructionTextReply(INSTRUCTIONS_TEXT, github.context.payload.discussion!.node_id, github.context.payload.comment!.node_id);\n      } else {\n        core.info('Comment created without proposed answer keyword. No action needed');\n      }\n    } else {\n      await processDiscussions(githubClient);\n    }\n  }\n  catch(e){\n    core.info((e as Error).message);\n  }\n}\n\nexport async function processDiscussions(githubClient: GithubDiscussionClient) {\n  const discussionCategoryIDList: string[] = await githubClient.getAnswerableDiscussionCategoryIDs();\n  if (discussionCategoryIDList.length === 0) {\n    core.info('No answerable discussions found. Exiting.');\n    return;\n  }\n\n  for (const discussionCategoryID of discussionCategoryIDList) {\n    let hasNextPage = true;\n    let afterCursor: string | null = null;\n\n    while (hasNextPage) {\n      const discussions = await githubClient.getDiscussionsMetaData(discussionCategoryID, PAGE_SIZE, afterCursor!);\n      hasNextPage = discussions.pageInfo.hasNextPage;\n      afterCursor = discussions.pageInfo.endCursor!;\n\n        for (const discussion of discussions.edges!) {\n          var discussionId = discussion?.node?.id ? discussion?.node?.id : \"\";\n          var discussionNum = discussion?.node?.number ? discussion.node.number : 0;\n          core.debug(`Processing discussionId: ${discussionId} with number: ${discussionNum} and bodyText: ${discussion?.node?.bodyText}`);\n          if (discussionId === \"\" || discussionNum === 0) {\n            core.warning(`Can not proceed checking discussion, discussionId is null!`);\n            continue;\n          }\n          else if (discussion?.node?.closed) {\n            core.info(`Discussion ${discussionId} is closed, so no action needed.`);\n            continue;\n          }\n          else if (discussion?.node?.locked && CLOSE_LOCKED_DISCUSSIONS) {\n            core.info(`Discussion ${discussionId} is locked, closing it as resolved`);\n            githubClient.closeDiscussionAsResolved(discussionId);\n            continue;\n          }\n          else if (discussion?.node?.answer != null && CLOSE_ANSWERED_DISCUSSIONS) {\n            core.info(`Discussion ${discussionId} is already answered, so closing it as resolved.`);\n            githubClient.closeDiscussionAsResolved(discussionId);\n            continue;\n          }\n          else {\n            await processComments(discussion!, githubClient);\n          }\n        }\n      }\n    }\n  }\n\nexport async function processComments(discussion: octokit.DiscussionEdge, githubClient: GithubDiscussionClient) {\n  const discussionId = discussion.node?.id ? discussion.node?.id : \"\";\n  const discussionNum = discussion.node?.number ? discussion.node?.number : 0;\n  const commentCount = await githubClient.getDiscussionCommentCount(discussionNum);\n  const comments = await githubClient.getCommentsMetaData(discussionNum, commentCount);\n\n  if (commentCount !== 0) {\n    for (const comment of comments.edges!) {\n      const commentId = comment?.node?.id;\n      core.debug(`Processing comment ${commentId} with bodytext: ${comment?.node?.bodyText}`);\n      if (!comment?.node?.bodyText || !comment.node.id) {\n        core.warning(`Comment body or id is null in discussion ${discussionId}, skipping comment!`);\n        continue;\n      }\n      if (!containsKeyword(comment!, PROPOSED_ANSWER_KEYWORD)) {\n        core.debug(`No answer proposed on comment ${commentId}, no action needed!`);\n        continue;\n      }\n      else {\n        if (containsNegativeReaction(comment)) {\n          core.info(`Negative reaction received. Adding attention label to discussion ${discussionId} to receive further attention from a repository maintainer`);\n          githubClient.addAttentionLabelToDiscussion(discussionId);\n        }\n        else if (containsPositiveReaction(comment)) {\n          core.info(`Positive reaction received. Marking discussion ${discussionId} as answered, and editing answer to remove proposed answer keyword`);\n          closeAndMarkAsAnswered(comment, discussionId, githubClient);\n        }\n        else if (!hasReplies(comment)) {\n          core.info(`Since this has no reply, adding instructions reply to comment ${commentId} in discussion ${discussionId}`);\n          githubClient.addInstructionTextReply(INSTRUCTIONS_TEXT, discussionId, commentId!);\n        }\n        else if (hasNonBotReply(comment, GITHUB_BOT)) {\n          core.info(`Discussion ${discussionId} has a reply, but not an instructions reply. Adding attention label`);\n          githubClient.addAttentionLabelToDiscussion(discussionId);\n        }\n        else if (exceedsDaysUntilStale(comment, DAYS_UNTIL_STALE)) {\n          if (CLOSE_STALE_AS_ANSWERED) {\n            core.info(`No one has responded or provided a reaction, closing discussion ${discussionId} as answered`);\n            closeAndMarkAsAnswered(comment, discussionId, githubClient);\n          } else {\n            core.info(`No one has responded or provided a reaction, closing discussion ${discussionId} with a comment`);\n            closeDiscussionForStaleness(discussionId, githubClient);\n          }\n        }\n      }\n    };\n  }\n  else {\n    core.debug(`No comments found for discussion ${discussionId}, No action needed!`);\n  }\n}\n\nfunction closeDiscussionForStaleness(discussionId: string, githubClient: GithubDiscussionClient) {\n  githubClient.addCommentToDiscussion(discussionId, CLOSE_FOR_STALENESS_RESPONSE_TEXT);\n  githubClient.closeDiscussionAsOutdated(discussionId);\n}\n\nfunction closeAndMarkAsAnswered(comment: DiscussionCommentEdge, discussionId: string, githubClient: GithubDiscussionClient) {\n  const bodyText = comment?.node?.bodyText!;\n  const commentId = comment?.node?.id!;\n  const updatedAnswerText = bodyText.replace(PROPOSED_ANSWER_KEYWORD, 'Answer: ');\n  githubClient.updateDiscussionComment(commentId, updatedAnswerText);\n  githubClient.markDiscussionCommentAsAnswer(commentId);\n  githubClient.closeDiscussionAsResolved(discussionId);\n}\n\nmain();\n"]} })(); module.exports = __webpack_exports__; diff --git a/src/index.ts b/src/index.ts index f8cff4e..c96f9f8 100644 --- a/src/index.ts +++ b/src/index.ts @@ -26,15 +26,20 @@ const INSTRUCTIONS_TEXT = core.getInput('instructions-response-text', { required async function main() { const githubClient = new GithubDiscussionClient(); await githubClient.initializeAttentionLabelId(); - if (triggeredByNewComment()) { - if (github.context.payload.comment?.body.indexOf(PROPOSED_ANSWER_KEYWORD) >= 0) { - core.info('Comment created with proposed answer keyword. Adding instuctions reply to comment'); - githubClient.addInstructionTextReply(INSTRUCTIONS_TEXT, github.context.payload.discussion!.node_id, github.context.payload.comment!.node_id); + try{ + if (triggeredByNewComment()) { + if (github.context.payload.comment?.body.indexOf(PROPOSED_ANSWER_KEYWORD) >= 0) { + core.info('Comment created with proposed answer keyword. Adding instuctions reply to comment with id: '+ github.context.payload.discussion!.node_id); + githubClient.addInstructionTextReply(INSTRUCTIONS_TEXT, github.context.payload.discussion!.node_id, github.context.payload.comment!.node_id); + } else { + core.info('Comment created without proposed answer keyword. No action needed'); + } } else { - core.info('Comment created without proposed answer keyword. No action needed'); + await processDiscussions(githubClient); } - } else { - await processDiscussions(githubClient); + } + catch(e){ + core.info((e as Error).message); } } @@ -53,36 +58,36 @@ export async function processDiscussions(githubClient: GithubDiscussionClient) { const discussions = await githubClient.getDiscussionsMetaData(discussionCategoryID, PAGE_SIZE, afterCursor!); hasNextPage = discussions.pageInfo.hasNextPage; afterCursor = discussions.pageInfo.endCursor!; - - for (const discussion of discussions.edges!) { - var discussionId = discussion?.node?.id ? discussion?.node?.id : ""; - var discussionNum = discussion?.node?.number ? discussion.node.number : 0; - core.debug(`Processing discussionId: ${discussionId} with number: ${discussionNum} and bodyText: ${discussion?.node?.bodyText}`); - if (discussionId === "" || discussionNum === 0) { - core.warning(`Can not proceed checking discussion, discussionId is null!`); - continue; - } - else if (discussion?.node?.closed) { - core.debug(`Discussion ${discussionId} is closed, so no action needed.`); - continue; - } - else if (discussion?.node?.locked && CLOSE_LOCKED_DISCUSSIONS) { - core.info(`Discussion ${discussionId} is locked, closing it as resolved`); - githubClient.closeDiscussionAsResolved(discussionId); - continue; - } - else if (discussion?.node?.answer != null && CLOSE_ANSWERED_DISCUSSIONS) { - core.info(`Discussion ${discussionId} is already answered, so closing it as resolved.`); - githubClient.closeDiscussionAsResolved(discussionId); - continue; - } - else { - await processComments(discussion!, githubClient); + + for (const discussion of discussions.edges!) { + var discussionId = discussion?.node?.id ? discussion?.node?.id : ""; + var discussionNum = discussion?.node?.number ? discussion.node.number : 0; + core.debug(`Processing discussionId: ${discussionId} with number: ${discussionNum} and bodyText: ${discussion?.node?.bodyText}`); + if (discussionId === "" || discussionNum === 0) { + core.warning(`Can not proceed checking discussion, discussionId is null!`); + continue; + } + else if (discussion?.node?.closed) { + core.info(`Discussion ${discussionId} is closed, so no action needed.`); + continue; + } + else if (discussion?.node?.locked && CLOSE_LOCKED_DISCUSSIONS) { + core.info(`Discussion ${discussionId} is locked, closing it as resolved`); + githubClient.closeDiscussionAsResolved(discussionId); + continue; + } + else if (discussion?.node?.answer != null && CLOSE_ANSWERED_DISCUSSIONS) { + core.info(`Discussion ${discussionId} is already answered, so closing it as resolved.`); + githubClient.closeDiscussionAsResolved(discussionId); + continue; + } + else { + await processComments(discussion!, githubClient); + } } } } } -} export async function processComments(discussion: octokit.DiscussionEdge, githubClient: GithubDiscussionClient) { const discussionId = discussion.node?.id ? discussion.node?.id : ""; From 376392c33bba04a6e5a78b58c406cb3f32bffa5f Mon Sep 17 00:00:00 2001 From: Shailja Khurana Date: Thu, 7 Sep 2023 23:32:54 +0000 Subject: [PATCH 2/2] added try catch blocks --- src/GithubDiscussionClient.ts | 138 ++++++++++++++++++++-------------- 1 file changed, 82 insertions(+), 56 deletions(-) diff --git a/src/GithubDiscussionClient.ts b/src/GithubDiscussionClient.ts index f4ea480..a02b7ac 100644 --- a/src/GithubDiscussionClient.ts +++ b/src/GithubDiscussionClient.ts @@ -13,13 +13,19 @@ export class GithubDiscussionClient { private attentionLabelId: string; constructor() { - const githubToken = core.getInput('github-token', { required: false }) || process.env.GITHUB_TOKEN; - if (!githubToken) { - throw new Error('You must provide a GitHub token as an input to this action, or as a `GITHUB_TOKEN` env variable. See the README for more info.'); - } this.owner = github.context.repo.owner; this.repo = github.context.repo.repo; - this.githubToken = githubToken; + + try { + const githubToken = core.getInput('github-token', { required: false }) || process.env.GITHUB_TOKEN; + if (!githubToken) { + throw new Error('You must provide a GitHub token as an input to this action, or as a `GITHUB_TOKEN` env variable. See the README for more info.'); + } + this.githubToken = githubToken; + } + catch(error) { + core.info("Error reported in Provided Github Token"+ error); + } } public get githubClient(): ApolloClient { @@ -49,79 +55,99 @@ export class GithubDiscussionClient { } public async initializeAttentionLabelId() { - if (!this.attentionLabelId) { - const attentionLabel = core.getInput('attention-label', { required: false }) || 'attention'; - const result = await this.githubClient.query({ - query: GetLabelId, + try{ + if (!this.attentionLabelId) { + const attentionLabel = core.getInput('attention-label', { required: false }) || 'attention'; + const result = await this.githubClient.query({ + query: GetLabelId, + variables: { + owner: this.owner, + name: this.repo, + labelName: attentionLabel + } + }); + + if (!result.data.repository?.label?.id) { + throw new Error(`Couldn't find label ${attentionLabel} in repository. Please create this label and try again.`); + } + + this.attentionLabelId = result.data.repository?.label?.id; + } + } + catch(error) { + core.info("Error reported in getting the Attention label " +error); + } + } + + public async getTotalDiscussionCount(categoryID: string): Promise { + try { + const resultCountObject = await this.githubClient.query({ + query: GetDiscussionCount, variables: { owner: this.owner, name: this.repo, - labelName: attentionLabel - } + categoryId: categoryID + }, }); - if (!result.data.repository?.label?.id) { - throw new Error(`Couldn't find label ${attentionLabel} in repository. Please create this label and try again.`); + if (resultCountObject.error) { + core.warning(`Error in reading discussions count for discussions category ${categoryID}: ${resultCountObject.error}`); } - this.attentionLabelId = result.data.repository?.label?.id; + core.debug(`Total discussion count for Category ${categoryID}: ${resultCountObject.data.repository?.discussions.totalCount}`); + return resultCountObject.data.repository?.discussions.totalCount!; } - } - - public async getTotalDiscussionCount(categoryID: string): Promise { - const resultCountObject = await this.githubClient.query({ - query: GetDiscussionCount, - variables: { - owner: this.owner, - name: this.repo, - categoryId: categoryID - }, - }); - - if (resultCountObject.error) { - core.warning(`Error in reading discussions count for discussions category ${categoryID}: ${resultCountObject.error}`); + catch(error) { + core.info("Error reported in Getting total discussion count "+error); return 0; } - - core.debug(`Total discussion count for Category ${categoryID}: ${resultCountObject.data.repository?.discussions.totalCount}`); - return resultCountObject.data.repository?.discussions.totalCount!; } public async getDiscussionCommentCount(discussionNum: number): Promise { - const result = await this.githubClient.query({ - query: GetDiscussionCommentCount, - variables: { - owner: this.owner, - name: this.repo, - num: discussionNum - }, - }); + try { + const result = await this.githubClient.query({ + query: GetDiscussionCommentCount, + variables: { + owner: this.owner, + name: this.repo, + num: discussionNum + }, + }); - if (result.error) { - core.warning(`Error retrieving comment count for discussion ${discussionNum}: ${result.error}`); + if (result.error) { + core.warning(`Error retrieving comment count for discussion ${discussionNum}: ${result.error}`); + } + + return result.data.repository?.discussion?.comments.totalCount!; + } + catch(error) { + core.info(`Error ${error}reported in getting Discussion comment count for discussion number: ${discussionNum} `); return 0; } - - return result.data.repository?.discussion?.comments.totalCount!; } public async getCommentsMetaData(discussionNum: number, commentCount: number): Promise { - const result = await this.githubClient.query({ - query: GetCommentMetaData, - variables: { - owner: this.owner, - name: this.repo, - discussionNumber: discussionNum, - commentCount: commentCount, - }, - }) + try{ + const result = await this.githubClient.query({ + query: GetCommentMetaData, + variables: { + owner: this.owner, + name: this.repo, + discussionNumber: discussionNum, + commentCount: commentCount, + }, + }) - if (result.error) { - core.warning(`Error retrieving comment metadata for discussion ${discussionNum}: ${result.error}`); + if (result.error) { + core.warning(`Error retrieving comment metadata for discussion ${discussionNum}: ${result.error}`); + } + + return result.data.repository?.discussion?.comments as DiscussionCommentConnection; + } + catch(error) { + core.info(`Error ${error} reported in getting comments metadata for the discussion ${discussionNum} `); return {} as DiscussionCommentConnection; } - - return result.data.repository?.discussion?.comments as DiscussionCommentConnection; } public async getDiscussionsMetaData(categoryID: string, pageSize: number, afterCursor: string): Promise {