github-issue-tower-defence-management 1.1.0 → 1.2.0

package/src/adapter/repositories/issue/GraphqlProjectItemRepository.ts

@@ -1,5 +1,7 @@
 import axios from 'axios';
 import { BaseGitHubRepository } from '../BaseGitHubRepository';
+import { Project } from '../../../domain/entities/Project';
+import { Issue } from '../../../domain/entities/Issue';
 export type ProjectItem = {
   id: string;
   nameWithOwner: string;
@@ -429,6 +431,7 @@ query GetProjectFields($owner: String!, $repository: String!, $issueNumber: Int!
           issue: {
             projectItems: {
               nodes: {
+                id: string;
                 fieldValues: {
                   nodes: {
                     __typename: string;
@@ -509,6 +512,7 @@ query GetProjectFields($owner: String!, $repository: String!, $issueNumber: Int!
       }
       projectItems(first: 10) {
         nodes {
+          id
           fieldValues(first: 10) {
             nodes {
               ... on ProjectV2ItemFieldTextValue {
@@ -624,6 +628,9 @@ query GetProjectFields($owner: String!, $repository: String!, $issueNumber: Int!
       };
     }[] = data.repository.issue.projectItems.nodes;
     const item = projectItems[0];
+    if (!item) {
+      throw new Error(`No project item found for issue ${issueUrl}`);
+    }
     return {
       id: item.id,
       nameWithOwner: data.repository.issue.repository.nameWithOwner,
@@ -742,4 +749,12 @@ query GetProjectFields($owner: String!, $repository: String!, $issueNumber: Int!
       throw new Error(res.data.errors.map((e) => e.message).join('\n'));
     }
   };
+  updateProjectTextField = async (
+    project: Project['id'],
+    fieldId: string,
+    issue: Issue['itemId'],
+    text: string,
+  ): Promise<void> => {
+    await this.updateProjectField(project, fieldId, issue, { text });
+  };
 }

package/src/adapter/repositories/issue/InternalGraphqlIssueRepository.test.ts

@@ -1,8 +1,10 @@
 import { InternalGraphqlIssueRepository } from './InternalGraphqlIssueRepository';
+import { LocalStorageRepository } from '../LocalStorageRepository';
 
 describe('InternalGraphqlIssueRepository', () => {
   jest.setTimeout(30 * 1000);
-  const repository = new InternalGraphqlIssueRepository();
+  const localStorageRepository = new LocalStorageRepository();
+  const repository = new InternalGraphqlIssueRepository(localStorageRepository);
 
   const testIssueUrl =
     'https://github.com/HiromiShikata/test-repository/issues/38';
@@ -10,6 +12,10 @@ describe('InternalGraphqlIssueRepository', () => {
   const testIssueId = 'I_kwDOCNXcUc6GaFia';
   const testCount = 10;
 
+  beforeAll(async () => {
+    await repository.getCookie();
+  });
+
   test('getFrontTimelineItems returns timeline with proper types', async () => {
     const result = await repository.getFrontTimelineItems(
       testIssueUrl,

package/src/adapter/repositories/issue/RestIssueRepository.test.ts

@@ -1,7 +1,10 @@
 import { RestIssueRepository } from './RestIssueRepository';
+import { LocalStorageRepository } from '../LocalStorageRepository';
 
 describe('RestIssueRepository', () => {
+  const localStorageRepository = new LocalStorageRepository();
   const restIssueRepository: RestIssueRepository = new RestIssueRepository(
+    localStorageRepository,
     '',
     process.env.GH_TOKEN || 'dummy',
   );

package/src/adapter/repositories/issue/RestIssueRepository.ts

@@ -28,8 +28,10 @@ export class RestIssueRepository extends BaseGitHubRepository {
     body: string,
     assignees: string[],
     labels: string[],
-  ) => {
-    const response = await axios.post(
+  ): Promise<number> => {
+    const response = await axios.post<{
+      number: number;
+    }>(
       `https://api.github.com/repos/${owner}/${repo}/issues`,
       {
         title,
@@ -47,6 +49,7 @@ export class RestIssueRepository extends BaseGitHubRepository {
     if (response.status !== 201) {
       throw new Error(`Failed to create issue: ${response.status}`);
     }
+    return response.data.number;
   };
   getIssue = async (
     issueUrl: string,

package/src/adapter/repositories/utils.test.ts

@@ -1,4 +1,4 @@
-import { calcrateDuration, totalDuration } from './utils';
+import { calcrateDuration, normalizeFieldName, totalDuration } from './utils';
 
 describe('utils', () => {
   describe('calculateDuration', () => {
@@ -37,4 +37,19 @@ describe('utils', () => {
       },
     );
   });
+  describe('normalizeFieldName', () => {
+    test.each`
+      fieldName                                  | expected
+      ${'Field Name'}                            | ${'fieldname'}
+      ${'Field-Name'}                            | ${'fieldname'}
+      ${'Field Name (with) ()'}                  | ${'fieldnamewith'}
+      ${'Depended Issue URL separated by comma'} | ${'dependedissueurlseparatedbycomma'}
+    `(
+      'should return $expected',
+      ({ fieldName, expected }: { fieldName: string; expected: string }) => {
+        const result = normalizeFieldName(fieldName);
+        expect(result).toEqual(expected);
+      },
+    );
+  });
 });

package/src/adapter/repositories/utils.ts

@@ -41,10 +41,5 @@ export const totalDuration = (
 };
 
 export const normalizeFieldName = (fieldName: string) => {
-  return fieldName
-    .toLowerCase()
-    .replace(' ', '')
-    .replace('-', '')
-    .replace(' ', '')
-    .replace(' ', '');
+  return fieldName.toLowerCase().replace(/[\s-()]/g, '');
 };

package/src/domain/entities/Issue.ts

@@ -11,6 +11,8 @@ export type Issue = {
   nextActionDate: Date | null;
   nextActionHour: number | null;
   estimationMinutes: number | null;
+  dependedIssueUrls: string[];
+  completionDate50PercentConfidence: Date | null;
   url: string;
   assignees: Member['name'][];
   workingTimeline: WorkingTime[];
@@ -20,4 +22,6 @@ export type Issue = {
   body: string;
   itemId: string;
   isPr: boolean;
+  isInProgress: boolean;
+  isClosed: boolean;
 };

package/src/domain/entities/Project.ts

@@ -1,3 +1,9 @@
+export type StoryOption = {
+  id: string;
+  name: string;
+  color: string;
+  description: string;
+};
 export type Project = {
   id: string;
   name: string;
@@ -13,10 +19,7 @@ export type Project = {
   story: {
     name: string;
     fieldId: string;
-    stories: {
-      id: string;
-      name: string;
-    }[];
+    stories: StoryOption[];
     workflowManagementStory: {
       id: string;
       name: string;
@@ -26,4 +29,12 @@ export type Project = {
     name: string;
     fieldId: string;
   } | null;
+  dependedIssueUrlSeparatedByComma: {
+    name: string;
+    fieldId: string;
+  } | null;
+  completionDate50PercentConfidence: {
+    name: string;
+    fieldId: string;
+  } | null;
 };

package/src/domain/usecases/AnalyzeProblemByIssueUseCase.ts

@@ -3,11 +3,22 @@ import { IssueRepository } from './adapter-interfaces/IssueRepository';
 import { Project } from '../entities/Project';
 import { Member } from '../entities/Member';
 import { DateRepository } from './adapter-interfaces/DateRepository';
+import { StoryObject, StoryObjectMap } from './HandleScheduledEventUseCase';
+import { isVisibleIssue } from './utils';
 
 export class AnalyzeProblemByIssueUseCase {
   constructor(
-    readonly issueRepository: Pick<IssueRepository, 'createNewIssue'>,
-    readonly dateRepository: Pick<DateRepository, 'formatDurationToHHMM'>,
+    readonly issueRepository: Pick<
+      IssueRepository,
+      'createNewIssue' | 'createComment'
+    >,
+    readonly dateRepository: Pick<
+      DateRepository,
+      | 'formatDurationToHHMM'
+      | 'formatDateTimeWithDayOfWeek'
+      | 'formatStartEnd'
+      | 'formatDateWithDayOfWeek'
+    >,
   ) {}
 
   run = async (input: {
@@ -16,140 +27,185 @@ export class AnalyzeProblemByIssueUseCase {
     issues: Issue[];
     cacheUsed: boolean;
     manager: Member['name'];
+    members: Member['name'][];
     org: string;
     repo: string;
+    storyObjectMap: StoryObjectMap;
+    disabledStatus: string;
   }): Promise<void> => {
     const story = input.project.story;
     if (
       !story ||
       !input.targetDates.find(
         (targetDate) =>
-          targetDate.getHours() === 7 && targetDate.getMinutes() === 0,
+          targetDate.getHours() === 0 && targetDate.getMinutes() === 0,
       )
     ) {
       return;
     }
-    const isTargetIssue = (issue: Issue): boolean => {
-      return (
-        !issue.isPr &&
-        (issue.nextActionDate === null ||
-          issue.nextActionDate.getTime() <= input.targetDates[0].getTime()) &&
-        issue.nextActionHour === null
+    const targetDate = input.targetDates[input.targetDates.length - 1];
+    if (!targetDate) {
+      return;
+    }
+    await this.checkInProgress({ ...input, targetDate });
+    for (const storyObject of input.storyObjectMap.values()) {
+      const storyIssue = storyObject.storyIssue;
+      if (!storyIssue) {
+        continue;
+      }
+      await this.issueRepository.createComment(
+        storyIssue,
+        this.createSummaryCommentBody({ ...storyObject, storyIssue }),
       );
-    };
-    const summaryStoryIssue = new Map<
-      string,
-      Map<
-        Issue,
-        {
-          totalWorkingTime: number;
-          totalWorkingTimeByAssignee: Map<string, number>;
-        }
-      >
-    >();
-    const targetStory = input.project.story?.stories.slice(0, 12) || [];
-    for (const story of targetStory) {
-      summaryStoryIssue.set(story.name, new Map());
-      for (const issue of input.issues) {
-        if (issue.story !== story.name || !isTargetIssue(issue)) {
+      await new Promise((resolve) => setTimeout(resolve, 5000));
+    }
+  };
+  checkInProgress = async (
+    input: Parameters<AnalyzeProblemByIssueUseCase['run']>[0] & {
+      targetDate: Date;
+    },
+  ) => {
+    const assigneeToNotify: Member['name'][] = [];
+    for (const member of input.members) {
+      let topIssue: Issue | null = null;
+      for (const story of input.storyObjectMap.values()) {
+        const storyIssueObject = input.storyObjectMap.get(story.story.name);
+        if (!storyIssueObject) {
           continue;
+        } else if (assigneeToNotify.includes(member)) {
+          break;
+        }
+        for (const issue of storyIssueObject.issues) {
+          if (
+            !isVisibleIssue(
+              issue,
+              member,
+              input.targetDate,
+              input.disabledStatus,
+            ) ||
+            issue.status?.toLowerCase().includes('review') ||
+            issue.title.toLowerCase().includes('review') ||
+            issue.isPr
+          ) {
+            continue;
+          }
+          if (topIssue === null) {
+            topIssue = issue;
+            break;
+          }
+          if (!issue.isInProgress) {
+            continue;
+          }
+          assigneeToNotify.push(member);
+          break;
         }
-        const totalWorkingTimeByAssignee =
-          this.calculateTotalWorkingMinutesByAssignee(issue);
-        const totalWorkingTime = Math.round(
-          Array.from(totalWorkingTimeByAssignee.values()).reduce(
-            (a, b) => a + b,
-            0,
-          ),
-        );
-        const issueSummary: {
-          totalWorkingTime: number;
-          totalWorkingTimeByAssignee: Map<string, number>;
-        } = {
-          totalWorkingTime,
-          totalWorkingTimeByAssignee,
-        };
-        summaryStoryIssue.get(story.name)?.set(issue, issueSummary);
-        // if (totalWorkingTime < 240 || totalWorkingTime > 1440) {
-        //   continue;
-        // }
-        // await this.issueRepository.createNewIssue(
-        //   issue.org,
-        //   issue.repo,
-        //   `Please share the situation about #${issue.number} (${issue.title}) / total working time: ${totalWorkingTime} minutes`,
-        //   this.createQuestionIssueBody(
-        //     issue,
-        //     totalWorkingTime,
-        //     totalWorkingTimeByAssignee,
-        //   ),
-        //
-        //   [input.manager],
-        //   ['story:workflow-management'],
-        // );
       }
     }
+    if (assigneeToNotify.length === 0) {
+      return;
+    }
     await this.issueRepository.createNewIssue(
       input.org,
       input.repo,
-      `Summary of story issues`,
-      this.createSummaryIssueBody(summaryStoryIssue),
-
+      'Check in progress',
+      `${assigneeToNotify.join('\n')}`,
       [input.manager],
       ['story:workflow-management'],
     );
   };
-  createSummaryIssueBody = (
-    summaryStoryIssue: Map<
-      string,
-      Map<
-        Issue,
-        {
-          totalWorkingTime: number;
-          totalWorkingTimeByAssignee: Map<string, number>;
-        }
-      >
-    >,
+  createSummaryCommentBody = (
+    storyObject: StoryObject & {
+      storyIssue: NonNullable<StoryObject['storyIssue']>;
+    },
   ): string => {
-    let noMultipleNewLineBody = `${Array.from(summaryStoryIssue)
+    const getFlowchartIdFromUrl = (url: string) => {
+      return url.split('/').slice(-3).join('/');
+    };
+    const issueTitleForFlowchart = (title: string) => {
+      return title.replace('"', "'");
+    };
+    const flowChart = `
+\`\`\`mermaid
+
+flowchart TD
+${storyObject.issues
+  .map(
+    (issue) =>
+      `    ${getFlowchartIdFromUrl(issue.url)}["${issue.isClosed ? '🟣' : '🟢'}#${issue.number} ${issue.isClosed ? 'Closed' : 'Open'}<br/>${issue.assignees.map((a) => `${a}`).join('<br/>')}<br/>${issueTitleForFlowchart(issue.title)}"]`,
+  )
+  .join('\n')}
+${storyObject.issues
+  .map((issue) =>
+    Array.from(issue.dependedIssueUrls)
+      .map((dependedIssueUrl) => {
+        if (issue.isClosed) {
+          issue.totalWorkingTimeByAssignee;
+          return `    ${getFlowchartIdFromUrl(dependedIssueUrl)} -->|total: ${this.dateRepository.formatDurationToHHMM(issue.totalWorkingTime)}<br/>${Array.from(
+            issue.totalWorkingTimeByAssignee,
+          )
+            .map(
+              ([author, workingMinutes]) =>
+                `@${author} ${this.dateRepository.formatDurationToHHMM(workingMinutes)}`,
+            )
+            .join('<br/>')}| ${getFlowchartIdFromUrl(issue.url)}`;
+        }
+        return `    ${getFlowchartIdFromUrl(dependedIssueUrl)} -->|${
+          issue.estimationMinutes
+            ? `Estimation: ${this.dateRepository.formatDurationToHHMM(issue.estimationMinutes)}<br/>`
+            : ''
+        }<br/>by ${
+          issue.completionDate50PercentConfidence
+            ? this.dateRepository.formatDateWithDayOfWeek(
+                issue.completionDate50PercentConfidence,
+              )
+            : 'Unknown'
+        }| ${getFlowchartIdFromUrl(issue.url)}`;
+      })
+      .join('\n'),
+  )
+  .join('\n')}
+    %% click event 
+    ${storyObject.issues
       .map(
-        ([story, issues]) =>
-          `## ${this.dateRepository.formatDurationToHHMM(Array.from(issues.values()).reduce((a, b) => a + b.totalWorkingTime, 0))} ${story}
-${Array.from(issues)
+        (issue) => `click ${getFlowchartIdFromUrl(issue.url)} "${issue.url}"`,
+      )
+      .join('\n')}
+    
+\`\`\``;
+    let noMultipleNewLineBody = `
+Total: ${this.dateRepository.formatDurationToHHMM(Array.from(storyObject.issues.values()).reduce((a, b) => a + b.totalWorkingTime, 0))}
+
+${storyObject.issues
   .map(
-    ([issue, { totalWorkingTime, totalWorkingTimeByAssignee }]) =>
-      `- ${this.dateRepository.formatDurationToHHMM(totalWorkingTime)} ${totalWorkingTime > 300 ? ':warning: over 300min' : ''} ${issue.url} ${issue.assignees.map((a) => `@${a}`).join(' ')} ${issue.labels
-        .map(
-          (label) =>
-            `https://github.com/${issue.nameWithOwner}/labels/${encodeURI(label).replace(/:/g, '%3A')}`,
-        )
-        .join(' ')}
-${issue.workingTimeline.length > 0 ? `  - Total` : ''}
-${Array.from(totalWorkingTimeByAssignee)
+    (
+      issue,
+    ) => `- ${this.dateRepository.formatDurationToHHMM(issue.totalWorkingTime)} ${issue.url}
+  - Total
+${Array.from(issue.totalWorkingTimeByAssignee)
   .map(
     ([author, workingMinutes]) =>
-      `    - ${this.dateRepository.formatDurationToHHMM(workingMinutes)}, @${author}`,
+      `    - ${this.dateRepository.formatDurationToHHMM(workingMinutes)}, ${author}`,
   )
   .join('\n')}
-${issue.workingTimeline.length > 0 ? `  - Timeline` : ''}
+  - Timeline
 ${issue.workingTimeline
   .map(
     ({ startedAt, endedAt, durationMinutes, author }) =>
-      `    - ${this.dateRepository.formatDurationToHHMM(
-        startedAt.getMinutes(),
-      )}, ${this.dateRepository.formatDurationToHHMM(
-        endedAt.getMinutes(),
-      )}, ${this.dateRepository.formatDurationToHHMM(durationMinutes)}, @${author}`,
+      `    - ${this.dateRepository.formatDurationToHHMM(durationMinutes)}, ${this.dateRepository.formatStartEnd(startedAt, endedAt)}}, ${author}`,
   )
   .join('\n')}`,
   )
-  .join('\n')}`,
-      )
-      .join('\n')}`;
+  .join('\n')}`;
+
     while (noMultipleNewLineBody.includes('\n\n')) {
       noMultipleNewLineBody = noMultipleNewLineBody.replace('\n\n', '\n');
     }
-    return noMultipleNewLineBody;
+    return `${flowChart}
+
+${noMultipleNewLineBody}
+`;
   };
+
   createQuestionIssueBody = (
     issue: Issue,
     totalWorkingTime: number,
@@ -186,24 +242,4 @@ ${issue.workingTimeline
   .join('\n')}
 `;
   };
-
-  calculateTotalWorkingMinutesByAssignee = (
-    issue: Issue,
-  ): Map<string, number> => {
-    const workingTimeLine = issue.workingTimeline;
-    const mapWorkingTimeByAssignee: Map<string, number> = new Map();
-    for (const workingTime of workingTimeLine) {
-      const author = workingTime.author;
-      const workingMinutes = workingTime.durationMinutes;
-      if (!mapWorkingTimeByAssignee.has(author)) {
-        mapWorkingTimeByAssignee.set(author, 0);
-      }
-      const currentWorkingMinutes = mapWorkingTimeByAssignee.get(author) || 0;
-      mapWorkingTimeByAssignee.set(
-        author,
-        currentWorkingMinutes + workingMinutes,
-      );
-    }
-    return mapWorkingTimeByAssignee;
-  };
 }

package/src/domain/usecases/AnalyzeStoriesUseCase.ts

@@ -0,0 +1,167 @@
+import { Issue } from '../entities/Issue';
+import { IssueRepository } from './adapter-interfaces/IssueRepository';
+import { Project } from '../entities/Project';
+import { Member } from '../entities/Member';
+import { DateRepository } from './adapter-interfaces/DateRepository';
+import { StoryObjectMap } from './HandleScheduledEventUseCase';
+import { encodeForURI } from './utils';
+
+export class AnalyzeStoriesUseCase {
+  constructor(
+    readonly issueRepository: Pick<IssueRepository, 'createNewIssue'>,
+    readonly dateRepository: Pick<DateRepository, 'formatDurationToHHMM'>,
+  ) {}
+
+  run = async (input: {
+    targetDates: Date[];
+    project: Project;
+    issues: Issue[];
+    cacheUsed: boolean;
+    manager: Member['name'];
+    org: string;
+    repo: string;
+    urlOfStoryView: string;
+    disabledStatus: string;
+    storyObjectMap: StoryObjectMap;
+  }): Promise<void> => {
+    const story = input.project.story;
+    if (
+      !story ||
+      !input.targetDates.find(
+        (targetDate) =>
+          targetDate.getHours() === 7 && targetDate.getMinutes() === 0,
+      )
+    ) {
+      return;
+    }
+
+    const phases = new Map<
+      string,
+      (Issue & {
+        name: string;
+        color: string;
+        description: string;
+      })[]
+    >();
+
+    phases.set('story:phase:requirement:opened', []);
+    phases.set('story:phase:requirement:finished-prd', []);
+    phases.set('story:phase:requirement:finished-figma', []);
+    phases.set('story:phase:requirement:finished-testcase', []);
+    phases.set('story:phase:requirement:finished-deviding-task', []);
+    phases.set('story:phase:implementation-finished', []);
+    phases.set('story:phase:finished-qa', []);
+    phases.set('others', []);
+
+    for (const story of input.project.story?.stories || []) {
+      const storyIssue = input.issues.find((issue) =>
+        story.name.startsWith(issue.title),
+      );
+      if (story.name.startsWith('regular / ')) {
+        continue;
+      } else if (!storyIssue) {
+        throw new Error(`Story issue not found: ${story.name}`);
+      }
+      const storyIssueObject = {
+        ...storyIssue,
+        ...story,
+      };
+
+      if (storyIssue.status === input.disabledStatus) {
+        phases.get('others')?.push(storyIssueObject);
+      } else if (storyIssue.labels.includes('story:phase:finished-qa')) {
+        phases.get('story:phase:finished-qa')?.push(storyIssueObject);
+      } else if (
+        storyIssue.labels.includes('story:phase:implementation-finished')
+      ) {
+        phases
+          .get('story:phase:implementation-finished')
+          ?.push(storyIssueObject);
+      } else if (
+        storyIssue.labels.includes(
+          'story:phase:requirement:finished-deviding-task',
+        )
+      ) {
+        phases
+          .get('story:phase:requirement:finished-deviding-task')
+          ?.push(storyIssueObject);
+      } else if (
+        storyIssue.labels.includes('story:phase:requirement:finished-testcase')
+      ) {
+        phases
+          .get('story:phase:requirement:finished-testcase')
+          ?.push(storyIssueObject);
+      } else if (
+        storyIssue.labels.includes('story:phase:requirement:finished-figma')
+      ) {
+        phases
+          .get('story:phase:requirement:finished-figma')
+          ?.push(storyIssueObject);
+      } else if (
+        storyIssue.labels.includes('story:phase:requirement:finished-prd')
+      ) {
+        phases
+          .get('story:phase:requirement:finished-prd')
+          ?.push(storyIssueObject);
+      } else if (storyIssue.labels.includes('story:phase:requirement:opened')) {
+        phases.get('story:phase:requirement:opened')?.push(storyIssueObject);
+      } else {
+        phases.get('others')?.push(storyIssueObject);
+      }
+    }
+    await this.issueRepository.createNewIssue(
+      input.org,
+      input.repo,
+      `Story progress`,
+      this.createSummaryIssueBody(phases, input.urlOfStoryView),
+      [input.manager],
+      ['story:workflow-management'],
+    );
+  };
+  createSummaryIssueBody = (
+    summaryStoryIssue: Map<
+      string,
+      (Issue & {
+        name: string;
+        color: string;
+        description: string;
+      })[]
+    >,
+    urlOfStoryView: string,
+  ): string => {
+    return `
+
+${Array.from(summaryStoryIssue.keys())
+  .map((key) => {
+    return `
+## ${key}
+${summaryStoryIssue
+  .get(key)
+  ?.map((issue) => {
+    const storyColor = `:${issue.color === 'BLUE' ? 'large_' : ''}${issue.color === 'GRAY' ? 'black' : issue.color === 'PINK' ? 'red' : issue.color.toLowerCase()}_circle:`;
+    const stakeHolder = issue.labels.find(
+      (label) => label === 'story:stakeholder:user',
+    )
+      ? `:bust_in_silhouette:`
+      : issue.labels.find((label) => label === 'story:stakeholder:engineer')
+        ? `:gear:`
+        : issue.labels.find((label) => label === 'story:stakeholder:cs-team')
+          ? `:headphones:`
+          : issue.labels.find(
+                (label) => label === 'story:stakeholder:potential-user',
+              )
+            ? ':busts_in_silhouette:'
+            : issue.labels.find(
+                  (label) => label === 'story:stakeholder:sales-team',
+                )
+              ? ':briefcase:'
+              : ':question:';
+    const boardUrl = `${urlOfStoryView}?filterQuery=story%3A%22${encodeForURI(issue.story)}%22+is%3Aopen`;
+
+    return `- ${storyColor} ${stakeHolder} ${issue.url} [:memo:](${boardUrl})`;
+  })
+  .join('\n')}`;
+  })
+  .join('\n')}`;
+  };
+}