github-issue-tower-defence-management 1.1.0

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

@@ -0,0 +1,40 @@
+import { calcrateDuration, totalDuration } from './utils';
+
+describe('utils', () => {
+  describe('calculateDuration', () => {
+    test.each`
+      start      | end       | expected
+      ${'0:50'}  | ${'1:30'} | ${'00:40'}
+      ${'23:50'} | ${'0:00'} | ${'00:10'}
+      ${'0:20'}  | ${'0:10'} | ${'23:50'}
+    `(
+      'should return $expected',
+      ({
+        start,
+        end,
+        expected,
+      }: {
+        start: string;
+        end: string;
+        expected: string;
+      }) => {
+        const result = calcrateDuration(start, end);
+        expect(result).toEqual(expected);
+      },
+    );
+  });
+  describe('totalDuration', () => {
+    test.each`
+      durations            | expected
+      ${['0:50', '1:30']}  | ${'02:20'}
+      ${['23:50', '0:00']} | ${'23:50'}
+      ${['0:20', '0:10']}  | ${'00:30'}
+    `(
+      'should return $expected',
+      ({ durations, expected }: { durations: string[]; expected: string }) => {
+        const result = totalDuration(durations);
+        expect(result).toEqual(expected);
+      },
+    );
+  });
+});

package/src/adapter/repositories/utils.ts

@@ -0,0 +1,50 @@
+// 0:50 , 1:10 = 0:20
+// 23:50 , 0:00 = 0:10
+// 0:20, 0:10 = 23:50
+export const calcrateDuration = (
+  start: string, // HH:mm
+  end: string, // HH:mm
+): string => {
+  const [startHour, startMinute] = start.split(':').map((s) => parseInt(s, 10));
+  const [endHour, endMinute] = end.split(':').map((s) => parseInt(s, 10));
+
+  let durationHour = endHour - startHour;
+  let durationMinute = endMinute - startMinute;
+
+  if (durationMinute < 0) {
+    durationHour -= 1;
+    durationMinute += 60;
+  }
+  if (durationHour < 0) {
+    durationHour += 24;
+  }
+  return `${String(durationHour).padStart(2, '0')}:${String(durationMinute).padStart(2, '0')}`;
+};
+export const totalDuration = (
+  durations: string[], // HH:mm
+): string => {
+  const total = durations.reduce(
+    (acc, cur) => {
+      const [hour, minute] = cur.split(':').map((s) => parseInt(s, 10));
+      return {
+        hour: acc.hour + hour,
+        minute: acc.minute + minute,
+      };
+    },
+    { hour: 0, minute: 0 },
+  );
+
+  const totalHour = total.hour + Math.floor(total.minute / 60);
+  const totalMinute = total.minute % 60;
+
+  return `${String(totalHour).padStart(2, '0')}:${String(totalMinute).padStart(2, '0')}`;
+};
+
+export const normalizeFieldName = (fieldName: string) => {
+  return fieldName
+    .toLowerCase()
+    .replace(' ', '')
+    .replace('-', '')
+    .replace(' ', '')
+    .replace(' ', '');
+};

package/src/domain/entities/Issue.ts

@@ -0,0 +1,23 @@
+import { WorkingTime } from './WorkingTime';
+import { Member } from './Member';
+export type Label = string;
+export type Issue = {
+  nameWithOwner: string;
+  number: number;
+  title: string;
+  state: 'OPEN' | 'CLOSED' | 'MERGED';
+  status: string | null;
+  story: string | null;
+  nextActionDate: Date | null;
+  nextActionHour: number | null;
+  estimationMinutes: number | null;
+  url: string;
+  assignees: Member['name'][];
+  workingTimeline: WorkingTime[];
+  labels: Label[];
+  org: string;
+  repo: string;
+  body: string;
+  itemId: string;
+  isPr: boolean;
+};

package/src/domain/entities/Member.ts

@@ -0,0 +1,3 @@
+export type Member = {
+  name: string;
+};

package/src/domain/entities/Project.ts

@@ -0,0 +1,29 @@
+export type Project = {
+  id: string;
+  name: string;
+  // fields: ProjectField[];
+  nextActionDate: {
+    name: string;
+    fieldId: string;
+  } | null;
+  nextActionHour: {
+    name: string;
+    fieldId: string;
+  } | null;
+  story: {
+    name: string;
+    fieldId: string;
+    stories: {
+      id: string;
+      name: string;
+    }[];
+    workflowManagementStory: {
+      id: string;
+      name: string;
+    };
+  } | null;
+  remainingEstimationMinutes: {
+    name: string;
+    fieldId: string;
+  } | null;
+};

package/src/domain/entities/ProjectField.ts

@@ -0,0 +1,3 @@
+import { ProjectFieldSingleSelect } from './ProjectFieldSingleSelect';
+
+export type ProjectField = ProjectFieldSingleSelect;

package/src/domain/entities/ProjectFieldSingleSelect.ts

@@ -0,0 +1,8 @@
+import { ProjectFieldSingleSelectOption } from './ProjectFieldSingleSelectOption';
+
+export type ProjectFieldSingleSelect = {
+  id: string;
+  name: string;
+  projectFieldType: 'single_select';
+  options: ProjectFieldSingleSelectOption[];
+};

package/src/domain/entities/ProjectFieldSingleSelectOption.ts

@@ -0,0 +1,8 @@
+import { ProjectField } from './ProjectField';
+
+export type ProjectFieldSingleSelectOption = {
+  projectFieldId: ProjectField['id'];
+  id: string;
+  value: string;
+  description: string;
+};

package/src/domain/entities/WorkingTime.ts

@@ -0,0 +1,8 @@
+import { Member } from './Member';
+
+export type WorkingTime = {
+  author: Member['name'];
+  startedAt: Date;
+  endedAt: Date;
+  durationMinutes: number;
+};

package/src/domain/usecases/ActionAnnouncementUseCase.ts

@@ -0,0 +1,76 @@
+import { Issue } from '../entities/Issue';
+import { Member } from '../entities/Member';
+import { IssueRepository } from './adapter-interfaces/IssueRepository';
+import { Project } from '../entities/Project';
+
+export class ActionAnnouncementUseCase {
+  constructor(
+    readonly issueRepository: Pick<
+      IssueRepository,
+      'createNewIssue' | 'updateIssue'
+    >,
+  ) {}
+
+  run = async (input: {
+    targetDates: Date[];
+    project: Project;
+    issues: Issue[];
+    cacheUsed: boolean;
+    members: Member['name'][];
+    manager: Member['name'];
+  }): Promise<void> => {
+    if (input.cacheUsed || input.targetDates.length === 0) {
+      return;
+    }
+    const now = input.targetDates[input.targetDates.length - 1];
+    const isTargetIssue = (issue: Issue): boolean => {
+      return (
+        issue.labels.includes('action:announcement') &&
+        (issue.nextActionDate === null ||
+          issue.nextActionDate.getTime() <= now.getTime()) &&
+        issue.state === 'OPEN'
+      );
+    };
+    const actionAnnouncementIssues = input.issues.filter((issue) =>
+      isTargetIssue(issue),
+    );
+    for (const issue of actionAnnouncementIssues) {
+      for (const member of input.members) {
+        try {
+          await this.issueRepository.createNewIssue(
+            issue.org,
+            issue.repo,
+            `Announcement #${issue.number}: ${issue.title} / ${member}`,
+            `Hi @${member},
+
+Please take a look at the announcement in the issue ${issue.url} and take necessary actions :pray:
+`,
+            [member],
+            [
+              ...issue.labels.filter(
+                (label) => label !== 'action:announcement',
+              ),
+              'story:workflow-management',
+            ],
+          );
+        } catch (e) {
+          await this.issueRepository.createNewIssue(
+            issue.org,
+            issue.repo,
+            `Error occured while creating working report for ${member}`,
+            `${JSON.stringify(e)}`,
+            [input.manager],
+            ['bug'],
+          );
+        }
+        await new Promise((resolve) => setTimeout(resolve, 5000));
+      }
+      await this.issueRepository.updateIssue({
+        ...issue,
+        labels: issue.labels
+          .filter((label) => label !== 'action:announcement')
+          .concat('announcement'),
+      });
+    }
+  };
+}

package/src/domain/usecases/AnalyzeProblemByIssueUseCase.ts

@@ -0,0 +1,209 @@
+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';
+
+export class AnalyzeProblemByIssueUseCase {
+  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;
+  }): Promise<void> => {
+    const story = input.project.story;
+    if (
+      !story ||
+      !input.targetDates.find(
+        (targetDate) =>
+          targetDate.getHours() === 7 && 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 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)) {
+          continue;
+        }
+        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'],
+        // );
+      }
+    }
+    await this.issueRepository.createNewIssue(
+      input.org,
+      input.repo,
+      `Summary of story issues`,
+      this.createSummaryIssueBody(summaryStoryIssue),
+
+      [input.manager],
+      ['story:workflow-management'],
+    );
+  };
+  createSummaryIssueBody = (
+    summaryStoryIssue: Map<
+      string,
+      Map<
+        Issue,
+        {
+          totalWorkingTime: number;
+          totalWorkingTimeByAssignee: Map<string, number>;
+        }
+      >
+    >,
+  ): string => {
+    let noMultipleNewLineBody = `${Array.from(summaryStoryIssue)
+      .map(
+        ([story, issues]) =>
+          `## ${this.dateRepository.formatDurationToHHMM(Array.from(issues.values()).reduce((a, b) => a + b.totalWorkingTime, 0))} ${story}
+${Array.from(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)
+  .map(
+    ([author, workingMinutes]) =>
+      `    - ${this.dateRepository.formatDurationToHHMM(workingMinutes)}, @${author}`,
+  )
+  .join('\n')}
+${issue.workingTimeline.length > 0 ? `  - Timeline` : ''}
+${issue.workingTimeline
+  .map(
+    ({ startedAt, endedAt, durationMinutes, author }) =>
+      `    - ${this.dateRepository.formatDurationToHHMM(
+        startedAt.getMinutes(),
+      )}, ${this.dateRepository.formatDurationToHHMM(
+        endedAt.getMinutes(),
+      )}, ${this.dateRepository.formatDurationToHHMM(durationMinutes)}, @${author}`,
+  )
+  .join('\n')}`,
+  )
+  .join('\n')}`,
+      )
+      .join('\n')}`;
+    while (noMultipleNewLineBody.includes('\n\n')) {
+      noMultipleNewLineBody = noMultipleNewLineBody.replace('\n\n', '\n');
+    }
+    return noMultipleNewLineBody;
+  };
+  createQuestionIssueBody = (
+    issue: Issue,
+    totalWorkingTime: number,
+    totalWorkingTimeByAssignee: Map<string, number>,
+  ): string => {
+    return `Hi,
+I worry about the situation of #${issue.number} (${issue.title}) because the total working time is over 120 minutes.
+Could you please share the situation? :pray:
+
+## Total
+${this.dateRepository.formatDurationToHHMM(totalWorkingTime)}
+
+## From the record
+Working Minutes, Author, 
+${Array.from(totalWorkingTimeByAssignee)
+  .map(
+    ([author, workingMinutes]) =>
+      `${this.dateRepository.formatDurationToHHMM(workingMinutes)}, ${author}`,
+  )
+  .join('\n')}
+
+
+## Timeline
+Start, End, Duration, Author
+${issue.workingTimeline
+  .map(
+    ({ startedAt, endedAt, durationMinutes, author }) =>
+      `${this.dateRepository.formatDurationToHHMM(
+        startedAt.getMinutes(),
+      )}, ${this.dateRepository.formatDurationToHHMM(
+        endedAt.getMinutes(),
+      )}, ${this.dateRepository.formatDurationToHHMM(durationMinutes)}, ${author}`,
+  )
+  .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/ClearNextActionHourUseCase.ts

@@ -0,0 +1,51 @@
+import { Issue } from '../entities/Issue';
+import { IssueRepository } from './adapter-interfaces/IssueRepository';
+import { Project } from '../entities/Project';
+
+export class ClearNextActionHourUseCase {
+  constructor(
+    readonly issueRepository: Pick<IssueRepository, 'clearProjectField'>,
+  ) {}
+
+  run = async (input: {
+    targetDates: Date[];
+    project: Project;
+    issues: Issue[];
+    cacheUsed: boolean;
+  }): Promise<void> => {
+    const nextActionHour = input.project.nextActionHour;
+    if (!nextActionHour || input.cacheUsed) {
+      return;
+    }
+    const targetDates = input.targetDates
+      .filter((targetDate) => targetDate.getMinutes() === 45)
+      .reverse();
+    if (targetDates.length === 0) {
+      return;
+    }
+    const targetDate = new Date(
+      targetDates[targetDates.length - 1].getTime() + 5 * 60 * 1000,
+    );
+    const targetHour = targetDate.getHours();
+    const isTargetIssue = (issue: Issue): boolean => {
+      return (
+        issue.nextActionHour !== null &&
+        issue.nextActionHour <= targetHour &&
+        (issue.nextActionDate === null ||
+          issue.nextActionDate.getTime() <= targetDate.getTime()) &&
+        issue.state === 'OPEN'
+      );
+    };
+    for (const issue of input.issues) {
+      if (!isTargetIssue(issue)) {
+        continue;
+      }
+      await this.issueRepository.clearProjectField(
+        input.project,
+        nextActionHour.fieldId,
+        issue,
+      );
+      await new Promise((resolve) => setTimeout(resolve, 5000));
+    }
+  };
+}