add project overview section

Author: legomushroom

src/interfaces/IDeveloperWithIssuesCount.ts

@@ -0,0 +1,5 @@
+export interface IDeveloperWithIssuesCount {
+  login: string;
+  issuesCount: number;
+  issueType: 'assigned';
+}

src/interfaces/IProjectData.ts

@@ -4,6 +4,7 @@ export interface IProjectData {
   inWorkIssues: IWrappedIssue[];
   doneOrDeployIssues: IWrappedIssue[];
   allPlannedIssues: IWrappedIssue[];
+  toSolveIssues: IWrappedIssue[];
   // raw:
   backlogIssues: IWrappedIssue[];
   committedIssues: IWrappedIssue[];

src/interfaces/IProjectStats.ts

@@ -1,5 +1,20 @@
+import { IDeveloperWithIssuesCount } from "./IDeveloperWithIssuesCount";
+
 export interface IProjectStats {
   doneRate: number;
   inWorkRate: number;
   committedRate: number;
+
+  issuesDeveloperRatio: number;
+  issuesDeveloperLeftRatio: number;
+
+  issuesDayRatio?: number;
+  issuesDayLeftRatio?: number;
+
+  issuesDeveloperDayRatio?: number;
+  issuesDeveloperDayLeftRatio?: number;
+
+  devWithMostAssignedIssues: IDeveloperWithIssuesCount;
+
+  developers: string[];
 }

src/interfaces/IProjectWithData.ts

@@ -0,0 +1,8 @@
+import { IProjectData } from '../interfaces/IProjectData';
+import { IProjectWithConfig } from '../interfaces/IProjectWithConfig';
+
+
+export interface IProjectWithData {
+  project: IProjectWithConfig;
+  data: IProjectData;
+}

src/main.ts

@@ -17,25 +17,27 @@ import { IConfig } from './interfaces/IConfig';
 const TOKEN_NAME = 'REPO_GITHUB_PAT';
 const CONFIG_PATH = 'CONFIG_PATH';
 
-const overwriteBoardIssue = async (issueContents: string, config: IConfig, projectKit: ProjectsOctoKit) => {
+const overwriteBoardIssue = async (
+  issueContents: string,
+  config: IConfig,
+  projectKit: ProjectsOctoKit,
+) => {
   const { status } = await projectKit.updateBoardIssue(
     config.boardIssue,
     issueContents,
   );
 
   if (status !== 200) {
-    throw new Error(
-      `Failed to update the issue ${config.boardIssue}`,
-    );
+    throw new Error(`Failed to update the issue ${config.boardIssue}`);
   }
 
   console.log(`Successfully updated the board issue ${config.boardIssue}`);
-}
+};
 
 const getRegex = (projectId?: number) => {
   const regex = /<!--\s*codespaces-board:start\s*-->([\W\w]*)<!--\s*codespaces-board:end\s*-->/gim;
   return regex;
-}
+};
 
 const wrapIssueText = (text: string, projectId?: number) => {
   return [
@@ -45,15 +47,15 @@ const wrapIssueText = (text: string, projectId?: number) => {
     text,
     `<!-- codespaces-board:end -->`,
   ].join('\n');
-}
+};
 
-const updateBoardIssue = async (issueContents: string, config: IConfig, projectKit: ProjectsOctoKit) => {
+const updateBoardIssue = async (
+  issueContents: string,
+  config: IConfig,
+  projectKit: ProjectsOctoKit,
+) => {
   if (!config.isReplaceProjectMarkers) {
-    return await overwriteBoardIssue(
-      issueContents,
-      config,
-      projectKit,
-    );
+    return await overwriteBoardIssue(issueContents, config, projectKit);
   }
 
   const issue = await projectKit.getBoardIssue(
@@ -64,19 +66,22 @@ const updateBoardIssue = async (issueContents: string, config: IConfig, projectK
   const { body } = issue;
   const newBody = body.replace(getRegex(), wrapIssueText(issueContents));
 
-  await overwriteBoardIssue(
-    newBody,
-    config,
-    projectKit,
-  );
-}
+  await overwriteBoardIssue(newBody, config, projectKit);
+};
 
-const processConfigRecord = async (config: IConfig, projectKit: ProjectsOctoKit) => {
+const processConfigRecord = async (
+  config: IConfig,
+  projectKit: ProjectsOctoKit,
+) => {
   console.log('Processing config: \n', JSON.stringify(config, null, 2));
 
   const validationErrors = validateConfig(config);
   if (validationErrors.length) {
-    console.error(`\n\nNot valid config for the issue ${config.boardIssue}, skipping.. \n`, validationErrors, '\n\n');
+    console.error(
+      `\n\nNot valid config for the issue ${config.boardIssue}, skipping.. \n`,
+      validationErrors,
+      '\n\n',
+    );
     return;
   }
 
@@ -90,15 +95,14 @@ const processConfigRecord = async (config: IConfig, projectKit: ProjectsOctoKit)
         const data = await getProjectData(projectKit, repo, project);
         return {
           project,
-          data
+          data,
         };
       }),
     );
 
-    const result =
-      projectsWithData.map(({ project, data }) => {
-        return renderProject(data, project);
-      });
+    const result = projectsWithData.map(({ project, data }) => {
+      return renderProject(data, project, config);
+    });
 
     const issueBody = result.join('\n') + '\n';
     let header;
@@ -115,12 +119,12 @@ const processConfigRecord = async (config: IConfig, projectKit: ProjectsOctoKit)
       header,
       renderOverview(config, projectsWithData),
       issueBody,
-      footer
+      footer,
     ].join('\n');
 
     await updateBoardIssue(issueContents, config, projectKit);
   }
-}
+};
 
 async function run(): Promise<void> {
   try {

src/utils/arrayUnique.ts

@@ -0,0 +1,5 @@
+export const arrayUnique = <T>(array: T[]): T[] => {
+    const set = new Set<T>(array);
+
+    return [...set];
+};

src/utils/flatternArray.ts

@@ -0,0 +1,9 @@
+export const flattenArray = <T>(
+  input: Array<any>,
+  output: Array<T> = [],
+): Array<T> => {
+  for (const value of input) {
+    Array.isArray(value) ? flattenArray(value, output) : output.push(value);
+  }
+  return output;
+};

src/utils/getProjectData.ts

@@ -58,12 +58,14 @@ export const getProjectData = async (
   const inWorkIssues = [...progressIssues, ...inReviewIssues];
   const doneOrDeployIssues = [...waitingToDeployIssues, ...doneIssues];
   const allPlannedIssues = [...blockedIssues, ...committedIssues, ...inWorkIssues, ...doneOrDeployIssues];
+  const toSolveIssues = [...inWorkIssues, ...blockedIssues, ...committedIssues];
 
   return {
     // combined
     inWorkIssues,
     doneOrDeployIssues,
     allPlannedIssues,
+    toSolveIssues,
     // plain
     backlogIssues,
     committedIssues,

src/utils/getProjectStats.ts

@@ -1,23 +1,123 @@
+import { IConfig } from '../interfaces/IConfig';
 import { IProjectData } from '../interfaces/IProjectData';
 import { IProjectStats } from '../interfaces/IProjectStats';
+import { IWrappedIssue } from '../interfaces/IWrappedIssue';
+import { TRepoIssue } from '../interfaces/TRepoIssue';
+import { getWorkDays } from '../views/renderDaysLeft';
+import { arrayUnique } from './arrayUnique';
+import { flattenArray } from './flatternArray';
+import { IDeveloperWithIssuesCount } from '../interfaces/IDeveloperWithIssuesCount';
+import { notEmpty } from './notEmpty';
+import { pluck } from './pluck';
 
-export const getProjectStats = (data: IProjectData): IProjectStats => {
+const getDevelopers = (issues: IWrappedIssue[]): string[] => {
+  const developersWithDuplicates = issues
+    .map(({ issue }) => {
+      return issue.assignees.map(pluck('login'));
+    })
+    .filter(notEmpty);
+
+  const developers = arrayUnique(flattenArray(developersWithDuplicates));
+
+  return developers as string[];
+};
+
+const asigneesToDevelopers = (assignees: TRepoIssue['assignees']) => {
+  return assignees.map((as) => {
+    return as.login;
+  });
+}
+
+const countAssignedIssues = (developer: string, issues: IWrappedIssue[]) => {
+  const result = issues.reduce((current, { issue }) => {
+    const { assignees } = issue;
+
+    if (!assignees || !assignees.length) {
+      return current;
+    }
+
+    const developers = asigneesToDevelopers(assignees);
+    return (developers.includes(developer))
+      ? current + 1
+      : current;
+  }, 0);
+
+  return result;
+}
+
+const getBusiestDeveloper = (issues: IWrappedIssue[]): IDeveloperWithIssuesCount => {
+  const developers = getDevelopers(issues)
+    .map<IDeveloperWithIssuesCount>((developer) => {
+      return {
+        login: developer,
+        issuesCount: countAssignedIssues(developer, issues),
+        issueType: 'assigned',
+      }
+    })
+    .sort((dev1, dev2) => {
+      return dev2.issuesCount - dev1.issuesCount;
+    });
+
+  return developers[0];
+};
+
+export const getProjectStats = (data: IProjectData, config: IConfig): IProjectStats => {
   const {
     // combined
     inWorkIssues,
     doneOrDeployIssues,
     allPlannedIssues,
+    toSolveIssues,
     // plain
     committedIssues,
   } = data;
 
+  const daysLeft = getWorkDays(config);
+
   const doneRate = doneOrDeployIssues.length / allPlannedIssues.length;
   const inWorkRate = inWorkIssues.length / allPlannedIssues.length;
   const committedRate = committedIssues.length / allPlannedIssues.length;
 
+  const developers = getDevelopers(allPlannedIssues);
+
+  const issuesDeveloperLeftRatio = toSolveIssues.length / developers.length;
+  const issuesDeveloperRatio = allPlannedIssues.length / developers.length;
+
+  const issuesDayLeftRatio = (daysLeft)
+    ? toSolveIssues.length / Math.max(daysLeft.businessDaysLeft, 1)
+    : undefined;
+
+  const issuesDayRatio = (daysLeft)
+    ? allPlannedIssues.length / daysLeft.totalBusinessDays
+    : undefined;
+
+  const issuesDeveloperDayLeftRatio = (issuesDayLeftRatio)
+    ? issuesDayLeftRatio / developers.length
+    : undefined;
+
+  const issuesDeveloperDayRatio = (issuesDayRatio)
+    ? issuesDayRatio / developers.length
+    : undefined;
+
   return {
     doneRate,
     inWorkRate,
     committedRate,
+    // number of developers on the board
+    developers,
+    // inital issues per developer load
+    issuesDeveloperRatio,
+    // how many issues per developer left to solve
+    issuesDeveloperLeftRatio,
+    // inital issues per day load
+    issuesDayRatio,
+    // how many issues per day left to solve
+    issuesDayLeftRatio,
+    // inital per day per developer ratio
+    issuesDeveloperDayRatio,
+    // how many issues per day per developer left to solve
+    issuesDeveloperDayLeftRatio,
+    // developer with most assigned issues
+    devWithMostAssignedIssues: getBusiestDeveloper(toSolveIssues),
   };
 };

src/utils/pluck.ts

@@ -0,0 +1,6 @@
+
+export const pluck = (propName: string) => {
+  return (obj: any) => {
+    return obj[propName];
+  };
+};