feature: adapt command to use environment variables

src/commands/TeamsCommandLineOptions.ts

@@ -0,0 +1,4 @@
+export interface TeamsCommandLineOptions {
+  platform: string
+  projectName: string
+}

src/commands/TeamsDevelopMessaging.ts

@@ -1,14 +1,14 @@
 import axios from "axios"
-import yargs from "yargs"
+import { TeamsCommandLineOptions } from "./TeamsCommandLineOptions"
 
 export interface TeamsDevelopMessagingOptions {
   projectName: string
-  platform: string
+  webhook: string
+  artifactUrl: string
   buildUrl: string
+  buildWasSuccessful: boolean
+  platform: string
   buildNumber: number
-  wasBuildSuccessful: boolean
-  artifactUrl: string
-  webhook: string
 }
 
 export class TeamsDevelopMessaging {
@@ -28,19 +28,21 @@ export class TeamsDevelopMessaging {
       process.exit(1)
     }
 
-    const statusIdentifier = options.wasBuildSuccessful ? "Successful" : "Failed"
+    const statusIdentifier = options.buildWasSuccessful ? "Successful" : "Failed"
     const platformIdentifier = options.platform.toUpperCase()
 
     const messageContents = {
-      title: `New successful ${options.platform} debug build for the "${options.projectName}" App`,
+      title: `New ${statusIdentifier.toLowerCase()} ${options.platform} debug build for the "${
+        options.projectName
+      }" App`,
       summary: `${options.projectName}: ${statusIdentifier} build - ${platformIdentifier}`,
-      text: options.wasBuildSuccessful
-        ? `Build ${options.buildNumber}: The latest version did build and is now available as an artifact.`
-        : `Build ${options.buildNumber}: A problem occurred while building the newly released version. The corresponding logs are available.`,
+      text: options.buildWasSuccessful
+        ? `New Build: #${options.buildNumber} - ${platformIdentifier} <br/> The latest version build successfully and is now available as an artifact.`
+        : `New Build: #${options.buildNumber} - ${platformIdentifier} <br/> A problem occurred while building the newly released version. The corresponding logs are available.`,
       potentialAction: [
         {
           "@type": "OpenUri",
-          name: options.wasBuildSuccessful ? `Download ${options.platform}-App` : "Open Logs",
+          name: options.buildWasSuccessful ? `Download ${options.platform}-App` : "Download Flutter Logs",
           targets: [{ os: "default", uri: options.artifactUrl }]
         },
         {
@@ -57,15 +59,6 @@ export class TeamsDevelopMessaging {
     })
   }
 
-  public parseCLIOptions(argv: yargs.Argv<{}>): { platform: string } | Promise<{ platform: string }> {
-    return argv.option("platform", {
-      description: "identifier of the platform for which the build was created",
-      required: true,
-      type: "string",
-      choices: ["ios", "android"]
-    }).argv
-  }
-
   private isUrlValid(url: string): boolean {
     try {
       // eslint-disable-next-line no-new
@@ -75,4 +68,31 @@ export class TeamsDevelopMessaging {
       return false
     }
   }
+
+  public extractArguments(
+    webhook: string,
+    buildWasSuccessful: boolean,
+    buildNumber: number,
+    projectId: string,
+    buildId: string,
+    commandLineOptions: TeamsCommandLineOptions,
+    cmArtifactLink?: string
+  ): TeamsDevelopMessagingOptions {
+    if (cmArtifactLink === undefined && buildWasSuccessful) {
+      console.log("variable CM_ARTIFACT_LINKS must be present in the system, if the build was successful")
+      process.exit(1)
+    }
+
+    const teamsDevelopMessagingOptions: TeamsDevelopMessagingOptions = {
+      projectName: commandLineOptions.projectName,
+      webhook: webhook,
+      artifactUrl: buildWasSuccessful ? cmArtifactLink! : `https://codemagic.io/app/${projectId}/build/${buildId}`,
+      buildUrl: `https://codemagic.io/app/${projectId}/build/${buildId}`,
+      buildWasSuccessful,
+      platform: commandLineOptions.platform,
+      buildNumber: buildNumber
+    }
+
+    return teamsDevelopMessagingOptions
+  }
 }

src/commands/TeamsProductionMessaging.ts

@@ -1,5 +1,6 @@
 import axios from "axios"
 import yargs from "yargs"
+import { TeamsCommandLineOptions } from "./TeamsCommandLineOptions"
 
 export interface TeamsProductionMessagingOptions {
   projectName: string
@@ -43,9 +44,7 @@ export class TeamsProductionMessaging {
     })
   }
 
-  public parseCLIOptions(
-    argv: yargs.Argv<{}>
-  ): TeamsProductionMessagingOptions | Promise<TeamsProductionMessagingOptions> {
+  public parseCLIOptions(argv: yargs.Argv<{}>): TeamsCommandLineOptions | Promise<TeamsCommandLineOptions> {
     return argv
       .option("projectName", {
         description: "Name of the project",
@@ -57,21 +56,6 @@ export class TeamsProductionMessaging {
         required: true,
         type: "string",
         choices: ["ios", "android"]
-      })
-      .option("buildUrl", {
-        description: "a link to the build page",
-        required: true,
-        type: "string"
-      })
-      .option("buildNumber", {
-        description: "the number of the run build",
-        required: true,
-        type: "number"
-      })
-      .option("webhook", {
-        description: "the webhook of the teams channel, that should receive the message",
-        required: true,
-        type: "string"
       }).argv
   }
 
@@ -84,4 +68,22 @@ export class TeamsProductionMessaging {
       return false
     }
   }
+
+  public extractArguments(
+    webhook: string,
+    buildNumber: number,
+    projectId: string,
+    buildId: string,
+    commandLineOptions: TeamsCommandLineOptions
+  ): TeamsProductionMessagingOptions {
+    const teamsDevelopMessagingOptions: TeamsProductionMessagingOptions = {
+      projectName: commandLineOptions.projectName,
+      platform: commandLineOptions.platform,
+      buildUrl: `https://codemagic.io/app/${projectId}/build/${buildId}`,
+      buildNumber: buildNumber,
+      webhook: webhook
+    }
+
+    return teamsDevelopMessagingOptions
+  }
 }

src/index.ts

@@ -5,45 +5,111 @@ import yargs from "yargs"
 import { CmArtifactLink } from "./CmArtifactLink"
 import { TeamsDevelopMessaging } from "./commands/TeamsDevelopMessaging"
 import { TeamsProductionMessaging } from "./commands/TeamsProductionMessaging"
+import { TeamsCommandLineOptions } from "./commands/TeamsCommandLineOptions"
 
 async function run() {
-  const isSuccess = fs.existsSync("~/SUCCESS")
+  const buildWasSuccessful = fs.existsSync("~/SUCCESS")
 
-  const cmArtifactLinks: CmArtifactLink[] = JSON.parse(process.env.CM_ARTIFACT_LINKS!)
+  const webhook = process.env.teams_webhook_url!
+  const buildId = process.env.CM_BUILD_ID!
+  const projectId = process.env.CM_PROJECT_ID!
+  const buildNumber = process.env.BUILD_NUMBER!
 
-  console.log("isSuccess: ", isSuccess)
-  console.log("CM_ARTIFACT_LINKS: ", cmArtifactLinks)
+  let cmArtifactLink: string
+  try {
+    const cmArtifactLinks: CmArtifactLink[] = JSON.parse(process.env.CM_ARTIFACT_LINKS!).filter(
+      (element: any) => element.type === "apk" || element.type === "ipa"
+    )
+    let artifactLink: string
+    if (cmArtifactLinks.filter((element: any) => element.type === "apk" || element.type === "ipa").length !== 0) {
+      artifactLink = cmArtifactLinks.filter((element: any) => element.type === "apk" || element.type === "ipa")[0].url
+    } else {
+      // should link to the workflow-log can be determined from buildId and projectId
+      artifactLink = `https://codemagic.io/app/${projectId}/build/${buildId}`
+    }
+    cmArtifactLink = artifactLink
+  } catch (error) {
+    console.log(error)
+    console.log("To ensure correct execution the environment variable CM_ARTIFACT_LINKS must be present in the system")
+    process.exit(1)
+  }
 
   await yargs(process.argv.slice(2))
     .command(
       "teams-develop",
       "After Codemagic Build: Send MS-Teams message informing about the new build",
-      async (args) => {
+      async () => {
         const teamsMessagingCommand = new TeamsDevelopMessaging()
-        const options = await teamsMessagingCommand.parseCLIOptions(args)
-        await teamsMessagingCommand.run({
-          ...options,
-          wasBuildSuccessful: isSuccess,
-          cmArtifactLinks
-        })
-        return options
+        const unresolvedOptions = parseCLIOptionsTeams(yargs)
+        const resolvedOptions: { platform: string; projectName: string } =
+          unresolvedOptions instanceof Promise ? await unresolvedOptions : unresolvedOptions
+        checkArtifactLinkMatchesPlatform(resolvedOptions, cmArtifactLink)
+
+        const parameters = teamsMessagingCommand.extractArguments(
+          webhook,
+          buildWasSuccessful,
+          Number(buildNumber),
+          projectId,
+          buildId,
+          resolvedOptions,
+          cmArtifactLink
+        )
+        await teamsMessagingCommand.run(parameters)
+        return
       }
     )
     .command(
       "teams-production",
       "After Codemagic Publish: Send MS-Teams message informing about the new release",
-      async (args) => {
+      async () => {
         const teamsMessagePublish = new TeamsProductionMessaging()
-        const options = await teamsMessagePublish.parseCLIOptions(args)
+        const unresolvedOptions = parseCLIOptionsTeams(yargs)
+        const resolvedOptions: { platform: string; projectName: string } =
+          unresolvedOptions instanceof Promise ? await unresolvedOptions : unresolvedOptions
+        checkArtifactLinkMatchesPlatform(resolvedOptions, cmArtifactLink)
+
+        const options = teamsMessagePublish.extractArguments(
+          webhook,
+          Number(buildNumber),
+          projectId,
+          buildId,
+          resolvedOptions
+        )
         await teamsMessagePublish.run(options)
-        return options
+        return resolvedOptions
       }
     )
     .demand(1, "Must provide a valid command from the ones listed above.")
     .scriptName("jscm")
     .parseAsync()
 }
 
+function parseCLIOptionsTeams(argv: yargs.Argv<{}>): TeamsCommandLineOptions | Promise<TeamsCommandLineOptions> {
+  return argv
+    .option("platform", {
+      description: "identifier of the platform for which the build was created",
+      required: true,
+      type: "string",
+      choices: ["ios", "android"]
+    })
+    .option("projectName", {
+      description: "objectIdentifier",
+      required: true,
+      type: "string"
+    }).argv
+}
+
+function checkArtifactLinkMatchesPlatform(resolvedOptions: TeamsCommandLineOptions, cmArtifactLink: string) {
+  // throw exception if the artifact link does not have the correct type for the given platform
+  if (
+    (resolvedOptions.platform === "ios" && cmArtifactLink.includes("ipa")!) ||
+    (resolvedOptions.platform === "android" && cmArtifactLink.includes("apk")!)
+  ) {
+    console.log("The artifact link does not have the correct type for the given platform")
+    process.exit(1)
+  }
+}
+
 run()
   .then(() => process.exit(0))
   .catch((error) => {