@khester/create-dynamics-app 2.7.0 → 2.9.0

package/templates/teams-bot/_variants/bot.echo/src/bot/welcomeCard.ts

@@ -0,0 +1,134 @@
+import { CardFactory, Attachment } from 'botbuilder';
+
+export function createWelcomeCard(userName: string): Attachment {
+  const card = {
+    type: 'AdaptiveCard',
+    $schema: 'http://adaptivecards.io/schemas/adaptive-card.json',
+    version: '1.4',
+    body: [
+      {
+        type: 'TextBlock',
+        size: 'Large',
+        weight: 'Bolder',
+        text: `Welcome, ${userName}!`,
+        wrap: true,
+      },
+      {
+        type: 'TextBlock',
+        text: "I'm a Teams bot built with Bot Framework. Here's what I can do:",
+        wrap: true,
+        spacing: 'Medium',
+      },
+      {
+        type: 'FactSet',
+        facts: [
+          { title: 'Echo', value: 'I repeat what you say' },
+          { title: 'Help', value: 'Type "help" for commands' },
+          { title: 'About', value: 'Type "about" for info' },
+        ],
+      },
+      {
+        type: 'TextBlock',
+        text: 'Try sending me a message!',
+        wrap: true,
+        spacing: 'Medium',
+        color: 'Accent',
+      },
+    ],
+    actions: [
+      {
+        type: 'Action.Submit',
+        title: 'Say Hello',
+        data: { action: 'hello' },
+      },
+    ],
+  };
+
+  return CardFactory.adaptiveCard(card);
+}
+
+export function createHelpCard(): Attachment {
+  const card = {
+    type: 'AdaptiveCard',
+    $schema: 'http://adaptivecards.io/schemas/adaptive-card.json',
+    version: '1.4',
+    body: [
+      {
+        type: 'TextBlock',
+        size: 'Medium',
+        weight: 'Bolder',
+        text: 'Available Commands',
+        wrap: true,
+      },
+      {
+        type: 'Container',
+        items: [
+          {
+            type: 'TextBlock',
+            text: '**help** - Show this help message',
+            wrap: true,
+          },
+          {
+            type: 'TextBlock',
+            text: '**about** - Learn about this bot',
+            wrap: true,
+          },
+          {
+            type: 'TextBlock',
+            text: '**echo [message]** - Echo your message',
+            wrap: true,
+          },
+          {
+            type: 'TextBlock',
+            text: 'Or just type anything and I will echo it back!',
+            wrap: true,
+            spacing: 'Medium',
+            isSubtle: true,
+          },
+        ],
+      },
+    ],
+  };
+
+  return CardFactory.adaptiveCard(card);
+}
+
+export function createAboutCard(): Attachment {
+  const card = {
+    type: 'AdaptiveCard',
+    $schema: 'http://adaptivecards.io/schemas/adaptive-card.json',
+    version: '1.4',
+    body: [
+      {
+        type: 'TextBlock',
+        size: 'Medium',
+        weight: 'Bolder',
+        text: 'About This Bot',
+        wrap: true,
+      },
+      {
+        type: 'FactSet',
+        facts: [
+          { title: 'Name', value: '{{projectName}}' },
+          { title: 'Framework', value: 'Bot Framework SDK v4' },
+          { title: 'Scaffold', value: 'create-dynamics-app (teams-bot)' },
+        ],
+      },
+      {
+        type: 'TextBlock',
+        text: 'This bot demonstrates the fundamentals of building a Teams bot using the Bot Framework SDK.',
+        wrap: true,
+        spacing: 'Medium',
+      },
+    ],
+    actions: [
+      {
+        type: 'Action.OpenUrl',
+        title: 'View Documentation',
+        url: 'https://learn.microsoft.com/en-us/microsoftteams/platform/bots/what-are-bots',
+      },
+    ],
+  };
+
+  return CardFactory.adaptiveCard(card);
+}

package/templates/teams-bot/_variants/bot.echo/src/index.ts

@@ -0,0 +1,59 @@
+import express, { Request, Response } from 'express';
+import { config, validateConfig } from './config';
+import { createBotAdapter } from './adapters/botAdapter';
+import { TeamsBot } from './bot/TeamsBot';
+import { startInteractiveTest } from './mock/mockMode';
+
+validateConfig();
+
+// Interactive mock mode: console chat loop, no server / no Azure.
+if (process.argv.includes('--interactive')) {
+  startInteractiveTest();
+} else {
+  const app = express();
+  app.use(express.json());
+
+  const adapter = createBotAdapter();
+  const bot = new TeamsBot();
+
+  // Health check endpoint (the deploy pipeline gates on this)
+  app.get('/health', (_req: Request, res: Response) => {
+    res.json({
+      status: 'healthy',
+      timestamp: new Date().toISOString(),
+      mockMode: config.mockMode,
+    });
+  });
+
+  // Bot messaging endpoint
+  app.post('/api/messages', async (req: Request, res: Response) => {
+    try {
+      await adapter.process(req, res, (context) => bot.run(context));
+    } catch (error) {
+      console.error('Error processing message:', error);
+      res.status(500).send('Internal Server Error');
+    }
+  });
+
+  app.get('/', (_req: Request, res: Response) => {
+    res.json({
+      name: '{{projectName}}',
+      description: 'Microsoft Teams echo bot (Bot Framework SDK v4)',
+      endpoints: { messaging: '/api/messages', health: '/health' },
+      mockMode: config.mockMode,
+    });
+  });
+
+  app.listen(config.port, () => {
+    console.log(`\nBot server is running!`);
+    console.log(`   Local:  http://localhost:${config.port}`);
+    console.log(`   Health: http://localhost:${config.port}/health`);
+    console.log(`   Mode:   ${config.mockMode ? 'Mock (development)' : 'Production'}`);
+    console.log(`\n   Messaging endpoint: /api/messages`);
+
+    if (config.mockMode) {
+      console.log(`\nTip: run with --interactive for console testing:`);
+      console.log(`   npm run dev -- --interactive`);
+    }
+  });
+}

package/templates/teams-bot/_variants/bot.echo/src/mock/mockMode.ts

@@ -0,0 +1,104 @@
+import { TestAdapter, Activity, ConversationReference, TurnContext } from 'botbuilder';
+import { TeamsBot } from '../bot/TeamsBot';
+
+// Create a test adapter for mock mode testing
+export function createMockAdapter(): TestAdapter {
+  const adapter = new TestAdapter(async (context: TurnContext) => {
+    const bot = new TeamsBot();
+    await bot.run(context);
+  });
+
+  return adapter;
+}
+
+// Simulate a Teams conversation for testing
+export async function runMockConversation(
+  userMessage: string,
+  callback?: (response: Partial<Activity>[]) => void
+): Promise<Partial<Activity>[]> {
+  const adapter = createMockAdapter();
+  const responses: Partial<Activity>[] = [];
+
+  await adapter.send(userMessage).assertReply((activity) => {
+    responses.push(activity);
+    callback?.([activity]);
+  });
+
+  return responses;
+}
+
+// Create a mock conversation reference for proactive messaging tests
+export function createMockConversationReference(
+  userId: string = 'user-1'
+): Partial<ConversationReference> {
+  return {
+    activityId: 'mock-activity-id',
+    user: {
+      id: userId,
+      name: 'Mock User',
+    },
+    bot: {
+      id: 'mock-bot-id',
+      name: 'Mock Bot',
+    },
+    conversation: {
+      id: 'mock-conversation-id',
+      isGroup: false,
+      conversationType: 'personal',
+      tenantId: 'mock-tenant-id',
+      name: '',
+    },
+    channelId: 'msteams',
+    serviceUrl: 'https://smba.trafficmanager.net/teams/',
+  };
+}
+
+// Interactive console testing
+export async function startInteractiveTest(): Promise<void> {
+  const readline = await import('readline');
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout,
+  });
+
+  console.log('\n=== Bot Mock Mode Interactive Test ===');
+  console.log('Type messages to test the bot. Type "exit" to quit.\n');
+
+  const adapter = createMockAdapter();
+
+  const askQuestion = (): void => {
+    rl.question('You: ', async (input) => {
+      if (input.toLowerCase() === 'exit') {
+        console.log('Goodbye!');
+        rl.close();
+        process.exit(0);
+        return;
+      }
+
+      try {
+        await adapter.send(input).assertReply((activity) => {
+          if (activity.text) {
+            console.log(`Bot: ${activity.text}`);
+          }
+          if (activity.attachments && activity.attachments.length > 0) {
+            console.log('Bot: [Adaptive Card]');
+            const card = activity.attachments[0].content;
+            if (card.body) {
+              for (const block of card.body) {
+                if (block.type === 'TextBlock' && block.text) {
+                  console.log(`      ${block.text}`);
+                }
+              }
+            }
+          }
+        });
+      } catch {
+        console.log('Bot: [No response]');
+      }
+
+      askQuestion();
+    });
+  };
+
+  askQuestion();
+}

package/templates/teams-bot/_variants/bot.message-extension/appPackage/manifest.template.json

@@ -0,0 +1,56 @@
+{
+  "$schema": "https://developer.microsoft.com/en-us/json-schemas/teams/v1.19/MicrosoftTeams.schema.json",
+  "manifestVersion": "1.19",
+  "id": "{{TEAMS_APP_ID}}",
+  "version": "1.0.0",
+  "developer": {
+    "name": "Contoso",
+    "websiteUrl": "https://example.com",
+    "privacyUrl": "https://example.com/privacy",
+    "termsOfUseUrl": "https://example.com/terms"
+  },
+  "name": { "short": "{{projectName}}", "full": "{{projectName}}" },
+  "description": { "short": "{{projectName}} message extension", "full": "{{projectName}} — a Microsoft Teams message extension: search sample data from the compose box, create items via a task module, and unfurl links" },
+  "icons": { "color": "color.png", "outline": "outline.png" },
+  "accentColor": "#6264A7",
+  "composeExtensions": [
+    {
+      "botId": "{{BOT_ID}}",
+      "canUpdateConfiguration": false,
+      "commands": [
+        {
+          "id": "searchCommand",
+          "type": "query",
+          "title": "Search",
+          "description": "Search sample data",
+          "initialRun": true,
+          "context": ["commandBox", "compose"],
+          "parameters": [
+            {
+              "name": "query",
+              "title": "Search query",
+              "description": "Enter search terms"
+            }
+          ]
+        },
+        {
+          "id": "createCommand",
+          "type": "action",
+          "title": "Create",
+          "description": "Create a new item",
+          "fetchTask": true,
+          "context": ["commandBox", "compose"]
+        }
+      ],
+      "messageHandlers": [
+        {
+          "type": "link",
+          "value": {
+            "domains": ["*.example.com"]
+          }
+        }
+      ]
+    }
+  ],
+  "permissions": ["identity"]
+}

package/templates/teams-bot/_variants/bot.message-extension/src/bot/MessageExtensionBot.ts

@@ -0,0 +1,114 @@
+import {
+  TeamsActivityHandler,
+  TurnContext,
+  MessagingExtensionQuery,
+  MessagingExtensionResponse,
+  MessagingExtensionAction,
+  MessagingExtensionActionResponse,
+  CardFactory,
+  TaskModuleResponse,
+} from 'botbuilder';
+import { searchProducts, mockProducts, IProduct } from '../mock/mockData';
+
+export class MessageExtensionBot extends TeamsActivityHandler {
+  // Handle search-based message extension
+  protected async handleTeamsMessagingExtensionQuery(
+    context: TurnContext,
+    query: MessagingExtensionQuery
+  ): Promise<MessagingExtensionResponse> {
+    const searchQuery = query.parameters?.[0]?.value || '';
+    const results = searchQuery ? searchProducts(searchQuery) : mockProducts.slice(0, 5);
+
+    const attachments = results.map((product) => this.createProductCard(product));
+
+    return {
+      composeExtension: {
+        type: 'result',
+        attachmentLayout: 'list',
+        attachments,
+      },
+    };
+  }
+
+  // Handle action-based message extension (fetch task)
+  protected async handleTeamsMessagingExtensionFetchTask(
+    _context: TurnContext,
+    _action: MessagingExtensionAction
+  ): Promise<TaskModuleResponse> {
+    return {
+      task: {
+        type: 'continue',
+        value: {
+          title: 'Create New Product',
+          height: 400,
+          width: 400,
+          card: CardFactory.adaptiveCard({
+            type: 'AdaptiveCard',
+            version: '1.4',
+            body: [
+              { type: 'TextBlock', text: 'Create Product', weight: 'Bolder', size: 'Medium' },
+              { type: 'Input.Text', id: 'name', placeholder: 'Product name', label: 'Name' },
+              { type: 'Input.Text', id: 'description', placeholder: 'Description', label: 'Description', isMultiline: true },
+              { type: 'Input.Number', id: 'price', placeholder: '0', label: 'Price ($)' },
+            ],
+            actions: [{ type: 'Action.Submit', title: 'Create' }],
+          }),
+        },
+      },
+    };
+  }
+
+  // Handle action-based message extension (submit action)
+  protected async handleTeamsMessagingExtensionSubmitAction(
+    _context: TurnContext,
+    action: MessagingExtensionAction
+  ): Promise<MessagingExtensionActionResponse> {
+    const data = action.data;
+    const product: IProduct = {
+      id: Date.now().toString(),
+      name: data.name || 'New Product',
+      description: data.description || '',
+      // Adaptive Card Input.Number submits its value as a string — coerce it.
+      price: Number(data.price) || 0,
+      category: 'New',
+      imageUrl: 'https://via.placeholder.com/150',
+    };
+
+    return {
+      composeExtension: {
+        type: 'result',
+        attachmentLayout: 'list',
+        attachments: [this.createProductCard(product)],
+      },
+    };
+  }
+
+  // Handle link unfurling
+  protected async handleTeamsAppBasedLinkQuery(
+    _context: TurnContext,
+    _query: { url: string }
+  ): Promise<MessagingExtensionResponse> {
+    const product = mockProducts[0];
+    return {
+      composeExtension: {
+        type: 'result',
+        attachmentLayout: 'list',
+        attachments: [this.createProductCard(product)],
+      },
+    };
+  }
+
+  private createProductCard(product: IProduct) {
+    const card = CardFactory.thumbnailCard(
+      product.name,
+      `$${product.price} | ${product.category}`,
+      [product.imageUrl],
+      [],
+      { subtitle: product.description }
+    );
+
+    const preview = CardFactory.thumbnailCard(product.name, product.description, [product.imageUrl]);
+
+    return { ...card, preview };
+  }
+}

package/templates/teams-bot/_variants/bot.message-extension/src/index.ts

@@ -0,0 +1,51 @@
+import express, { Request, Response } from 'express';
+import { config, validateConfig } from './config';
+import { createBotAdapter } from './adapters/botAdapter';
+import { MessageExtensionBot } from './bot/MessageExtensionBot';
+
+validateConfig();
+
+// A message extension is invoked from the Teams compose box (search / action /
+// link unfurling), not a console — so there is no --interactive mock loop here.
+const app = express();
+app.use(express.json());
+
+const adapter = createBotAdapter();
+const bot = new MessageExtensionBot();
+
+// Health check endpoint (the deploy pipeline gates on this)
+app.get('/health', (_req: Request, res: Response) => {
+  res.json({
+    status: 'healthy',
+    timestamp: new Date().toISOString(),
+    mockMode: config.mockMode,
+  });
+});
+
+// Bot messaging endpoint — message-extension queries/actions/link-queries arrive here
+app.post('/api/messages', async (req: Request, res: Response) => {
+  try {
+    await adapter.process(req, res, (context) => bot.run(context));
+  } catch (error) {
+    console.error('Error processing message:', error);
+    res.status(500).send('Internal Server Error');
+  }
+});
+
+app.get('/', (_req: Request, res: Response) => {
+  res.json({
+    name: '{{projectName}}',
+    description: 'Microsoft Teams message extension (Bot Framework SDK v4)',
+    endpoints: { messaging: '/api/messages', health: '/health' },
+    mockMode: config.mockMode,
+  });
+});
+
+app.listen(config.port, () => {
+  console.log(`\nMessage-extension server is running!`);
+  console.log(`   Local:  http://localhost:${config.port}`);
+  console.log(`   Health: http://localhost:${config.port}/health`);
+  console.log(`   Mode:   ${config.mockMode ? 'Mock (development)' : 'Production'}`);
+  console.log(`\n   Messaging endpoint: /api/messages`);
+  console.log(`   Invoke it from the Teams compose box (search / action / link unfurl).`);
+});

package/templates/teams-bot/_variants/bot.message-extension/src/mock/mockData.ts

@@ -0,0 +1,30 @@
+export interface IProduct {
+  id: string;
+  name: string;
+  description: string;
+  price: number;
+  category: string;
+  imageUrl: string;
+}
+
+// Sample data backing the search / action / link-unfurling responses. Swap this
+// for a live Dataverse query (app-only token) per the teams-message-extension runbook.
+export const mockProducts: IProduct[] = [
+  { id: '1', name: 'Laptop Pro', description: 'High-performance laptop', price: 1299, category: 'Electronics', imageUrl: 'https://via.placeholder.com/150' },
+  { id: '2', name: 'Wireless Mouse', description: 'Ergonomic wireless mouse', price: 49, category: 'Electronics', imageUrl: 'https://via.placeholder.com/150' },
+  { id: '3', name: 'Mechanical Keyboard', description: 'RGB mechanical keyboard', price: 129, category: 'Electronics', imageUrl: 'https://via.placeholder.com/150' },
+  { id: '4', name: 'USB-C Hub', description: '7-in-1 USB-C hub', price: 79, category: 'Electronics', imageUrl: 'https://via.placeholder.com/150' },
+  { id: '5', name: 'Monitor Stand', description: 'Adjustable monitor stand', price: 89, category: 'Office', imageUrl: 'https://via.placeholder.com/150' },
+  { id: '6', name: 'Desk Lamp', description: 'LED desk lamp', price: 45, category: 'Office', imageUrl: 'https://via.placeholder.com/150' },
+  { id: '7', name: 'Webcam HD', description: '1080p webcam', price: 99, category: 'Electronics', imageUrl: 'https://via.placeholder.com/150' },
+  { id: '8', name: 'Headphones', description: 'Noise-canceling headphones', price: 299, category: 'Electronics', imageUrl: 'https://via.placeholder.com/150' },
+];
+
+export function searchProducts(query: string): IProduct[] {
+  const q = query.toLowerCase();
+  return mockProducts.filter(p =>
+    p.name.toLowerCase().includes(q) ||
+    p.description.toLowerCase().includes(q) ||
+    p.category.toLowerCase().includes(q)
+  );
+}

package/templates/teams-bot/_variants/bot.notification/appPackage/manifest.template.json

@@ -0,0 +1,25 @@
+{
+  "$schema": "https://developer.microsoft.com/en-us/json-schemas/teams/v1.19/MicrosoftTeams.schema.json",
+  "manifestVersion": "1.19",
+  "id": "{{TEAMS_APP_ID}}",
+  "version": "1.0.0",
+  "developer": {
+    "name": "Contoso",
+    "websiteUrl": "https://example.com",
+    "privacyUrl": "https://example.com/privacy",
+    "termsOfUseUrl": "https://example.com/terms"
+  },
+  "name": { "short": "{{projectName}}", "full": "{{projectName}}" },
+  "description": { "short": "{{projectName}} notifications", "full": "{{projectName}} — a Microsoft Teams bot that delivers proactive notifications; message it 'subscribe' to opt in" },
+  "icons": { "color": "color.png", "outline": "outline.png" },
+  "accentColor": "#6264A7",
+  "bots": [
+    {
+      "botId": "{{BOT_ID}}",
+      "scopes": ["personal", "team", "groupChat"],
+      "supportsFiles": false,
+      "isNotificationOnly": false
+    }
+  ],
+  "permissions": ["identity"]
+}

package/templates/teams-bot/_variants/bot.notification/src/bot/NotificationBot.ts

@@ -0,0 +1,54 @@
+import { TeamsActivityHandler, TurnContext, MessageFactory, CardFactory, Attachment } from 'botbuilder';
+import { IConversationStore } from '../storage/conversationStore';
+
+export class NotificationBot extends TeamsActivityHandler {
+  constructor(private conversationStore: IConversationStore) {
+    super();
+
+    // Capture the conversation reference whenever we hear from a user — this is
+    // what proactive messaging replays later via continueConversationAsync.
+    this.onConversationUpdate(async (context: TurnContext, next: () => Promise<void>) => {
+      await this.saveConversationReference(context);
+      await next();
+    });
+
+    this.onMessage(async (context: TurnContext, next: () => Promise<void>) => {
+      await this.saveConversationReference(context);
+      const text = context.activity.text?.toLowerCase().trim() || '';
+
+      if (text === 'subscribe') {
+        await context.sendActivity(MessageFactory.text('You are subscribed to notifications!'));
+      } else if (text === 'unsubscribe') {
+        const userId = context.activity.from.id;
+        await this.conversationStore.delete(userId);
+        await context.sendActivity(MessageFactory.text('You have been unsubscribed.'));
+      } else {
+        await context.sendActivity(
+          MessageFactory.text('Commands: **subscribe**, **unsubscribe**. Notifications arrive via POST /api/notify.')
+        );
+      }
+      await next();
+    });
+  }
+
+  private async saveConversationReference(context: TurnContext): Promise<void> {
+    const reference = TurnContext.getConversationReference(context.activity);
+    const userId = context.activity.from?.id;
+    if (userId) {
+      await this.conversationStore.save(userId, reference);
+    }
+  }
+
+  static createNotificationCard(title: string, message: string): Attachment {
+    return CardFactory.adaptiveCard({
+      type: 'AdaptiveCard',
+      $schema: 'http://adaptivecards.io/schemas/adaptive-card.json',
+      version: '1.4',
+      body: [
+        { type: 'TextBlock', text: title, weight: 'Bolder', size: 'Medium', wrap: true },
+        { type: 'TextBlock', text: message, wrap: true },
+        { type: 'TextBlock', text: new Date().toLocaleString(), size: 'Small', isSubtle: true },
+      ],
+    });
+  }
+}