Teams集成-订阅事件处理-会议转写

已于 2024-09-29 12:10:25 修改
阅读量264 收藏 1
点赞数 2
分类专栏： Teams集成 文章标签： javascript teams订阅事件 转写 订阅事件 订阅接收
于 2024-09-26 17:00:42 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wxl781227/article/details/142563839
版权

在Teams会议侧边栏应用开发-会议转写-CSDN博客的基础上，使用/delta接口尝试获取实时转写，发现只能更新了一次，然后就不再更新了，想尝试使用订阅事件去获取转写，发现也不是实时的，当会议结束时，订阅事件才会产生，且有一定的延迟。本文主要针对订阅事件如何创建及事件接收后如何处理进行描述。

转写免费配额（很容易使用完，可以重新注册一个新的应用再次获取免费配额）：

转写计费成本：

订阅事件的创建：

// 定义 /subscribe 端点
server.post('/subscribe', async (req, res) => {
  try {
    const onlineMeetingId = req.query.meetingId;
    console.log('/subscribe meetingId:',onlineMeetingId);

    const response = await fetch("https://graph.microsoft.com/beta/subscriptions", {
      method: "GET",
      headers: {
        "Content-Type": "application/json",
        Authorization: `Bearer ${app_token}`,
      }
    });
    if (!response.ok) {
      const errorData = await response.json();
      throw new Error(errorData.error.message);
    }

    const data = await response.json();

    let noSub = true;
    data.value.forEach(sub=>{
      if (sub.resource === `communications/onlineMeetings/${onlineMeetingId}/transcripts`){
        noSub = false;
      }
    })

    if (noSub){
      const subscription = {
        changeType: "created",
        notificationUrl: "https://shortly-adapted-akita.ngrok-free.app/webhook",
        resource: `communications/onlineMeetings/${onlineMeetingId}/transcripts`,
        expirationDateTime: new Date(Date.now() +  60 * 60 * 1000).toISOString(), //1小时
        clientState: "secretClientValue",
      };
  
      const response2 = await fetch("https://graph.microsoft.com/beta/subscriptions", {
        method: "POST",
        headers: {
          "Content-Type": "application/json",
          Authorization: `Bearer ${app_token}`,
        },
        body: JSON.stringify(subscription),
      });
      
      if (!response2.ok) {
        const errorData = await response2.json();
        throw new Error(errorData.error.message);
      }
  
      const data2 = await response2.json();
      console.log("Subscription created:", data2.id);
      res.send(200, data2);
    }
  } catch (error) {
    console.error("Error creating subscription:", error);
    res.send(500, { error: error.message });
  }
});

订阅事件的接收（订阅事件没有使用加密方式，需要调用2次API获取转写）：

// 定义 /webhook 端点
server.post('/webhook', async (req, res) => {
  const validationToken = req.query.validationToken;
  console.log('/webhook validationToken:', validationToken);
  // 如果是验证请求，返回 validationToken
  if (validationToken) {
    res.setHeader('Content-Type', 'text/plain');
    res.send(200, validationToken);
    return;
  }

  const notification = req.body.value[0];
  const odataId = notification.resourceData['@odata.id'];

  const url = `https://graph.microsoft.com/beta/${odataId}`.replace('communications','me');
  //console.log('url:', url);

  const response = await fetch('https://shortly-adapted-akita.ngrok-free.app/get_user_token');
  const token_data = await response.json();

  // 获取具体的转写数据
  try {
    const response = await fetch(url, {
      headers: {
        Authorization: `Bearer ${token_data.user_token}`,
      },
    });

    if (!response.ok) {
      const errorData = await response.json();
      //console.log(errorData);
      throw new Error(errorData.error.message);
    }

    const transcriptData = await response.json();
    //console.log("Transcript Data:", transcriptData);

    // 获取转写内容
    const transcriptContentUrl = transcriptData.transcriptContentUrl;
    const contentResponse = await fetch(`${transcriptContentUrl}?$format=text/vtt`, {
      headers: {
        Authorization: `Bearer ${token_data.user_token}`,
      },
    });

    if (!contentResponse.ok) {
      const errorData = await contentResponse.text();
      //console.log(errorData);
      throw new Error(errorData);
    }

    const transcriptContent = await contentResponse.text();
    console.log("Transcript Content:", transcriptContent);

    // 将转写数据发送到所有连接的 WebSocket 客户端
    wss.clients.forEach((client) => {
      if (client.readyState === WebSocket.OPEN) {
        client.send(JSON.stringify({ type: 'newTranscript', data: transcriptContent }));
      }
    });

  } catch (error) {
    console.error("Error fetching transcript data:", error);
  }

  res.send(200, "OK");
});

完整的服务端代码如下：

import restify from "restify";
import send from "send";
import fs from "fs";
import fetch from "node-fetch";
import path from 'path';
import { fileURLToPath } from 'url';
import { storeToken, getToken } from './redisClient.js';
import { WebSocketServer, WebSocket } from 'ws';

const __filename = fileURLToPath(import.meta.url);
console.log('__filename: ', __filename);

const __dirname = path.dirname(__filename);
console.log('__dirname: ', __dirname);

// Create HTTP server.
const server = restify.createServer({
  key: process.env.SSL_KEY_FILE ? fs.readFileSync(process.env.SSL_KEY_FILE) : undefined,
  certificate: process.env.SSL_CRT_FILE ? fs.readFileSync(process.env.SSL_CRT_FILE) : undefined,
  formatters: {
    "text/html": function (req, res, body) {
      return body;
    },
  },
});

server.use(restify.plugins.bodyParser());
server.use(restify.plugins.queryParser());

server.get(
  "/static/*",
  restify.plugins.serveStatic({
    directory: __dirname,
  })
);

server.listen(process.env.port || process.env.PORT || 3000, function () {
  console.log(`\n${server.name} listening to ${server.url}`);
});

// Adding tabs to our app. This will setup routes to various views
// Setup home page
server.get("/config", (req, res, next) => {
  send(req, __dirname + "/config/config.html").pipe(res);
});

// Setup the static tab
server.get("/meetingTab", (req, res, next) => {
  send(req, __dirname + "/panel/panel.html").pipe(res);
});

//获得用户token
server.get('/auth', (req, res, next) => {
  res.status(200);
  res.send(`
<!DOCTYPE html>
<html>
<head>
    <script>
        // Function to handle the token storage
        async function handleToken() {
            const hash = window.location.hash.substring(1);
            const hashParams = new URLSearchParams(hash);
            const access_token = hashParams.get('access_token');
            console.log('Received hash parameters:', hashParams);

            if (access_token) {
                console.log('Access token found:', access_token);
                localStorage.setItem("access_token", access_token);
                console.log('Access token stored in localStorage');
                try {
                  const response = await fetch('https://shortly-adapted-akita.ngrok-free.app/store_user_token', {
                      method: 'POST',
                      headers: {
                          'Content-Type': 'application/json'
                      },
                      body: JSON.stringify({ "user_token" : access_token })
                  });

                  if (response.ok) {
                      console.log('Token stored successfully');
                  } else {
                      console.error('Failed to store token:', response.statusText);
                  }
              } catch (error) {
                  console.error('Error storing token:', error);
              }
            } else {
                console.log('No access token found');
            }
            window.close();
        }

        // Call the function to handle the token
        handleToken();
    </script>
</head>
<body></body>
</html>
  `);
  next();
});

// 存储 user_token
server.post('/store_user_token', async (req, res) => {
  const user_token = req.body.user_token;
  if (!user_token) {
      res.status(400);
      res.send('user_token are required');
  }
  try {
      // Store user token
      await storeToken('user_token', user_token);
      console.log('user_token stored in Redis');
  } catch (err) {
      console.error('user_token store Error:', err);
  }
  res.status(200);   
  res.send('Token stored successfully');
});

// 获取 user_token
server.get('/get_user_token', async (req, res) => {
  try {
    // Store user token
    const user_token = await getToken('user_token');
    console.log('user_token get in Redis');
    res.send({"user_token": user_token});
  } catch (err) {
      console.error('user_token get Error:', err);
  }
});

//应用token
let app_token = '';
let app_token_expires_at = 0;
const app_token_refresh_interval = 3000 * 1000; // 3000秒

const getAppToken = async () => {
  try {
    // 构建请求体
    const requestBody = new URLSearchParams({
      "grant_type": "client_credentials",
      "client_id": "Azure注册应用ID",
      "client_secret": "Azure注册应用密码",
      "scope": "https://graph.microsoft.com/.default",
    }).toString();

    // 获取app令牌
    const tokenUrl = `https://login.microsoftonline.com/注册应用租户ID/oauth2/v2.0/token`;
    const tokenResponse = await fetch(tokenUrl, {
      method: 'POST',
      headers: {
          'Content-Type': 'application/x-www-form-urlencoded',
      },
      body: requestBody,
    });

    if (!tokenResponse.ok) {
      const errorData = await tokenResponse.json();
      throw new Error(errorData.error_description);
    }

    const tokenData = await tokenResponse.json();
    app_token = tokenData.access_token;
    app_token_expires_at = Date.now() + app_token_refresh_interval;
    console.log("app_token received!");
  } catch (error) {
    console.error('Error getting app token:', error);
  }
};

// 定期刷新 app_token
setInterval(getAppToken, app_token_refresh_interval);

// 定义 /getTranscripts 端点
server.get('/getTranscripts', async (req, res) => {
  try {
    const url = req.query.url;

    if (!url) {
        res.send(400, { error: 'URL is required' });
        return;
    }

    // 调用 Microsoft Graph API
    const graphResponse = await fetch(url, {
        headers: {
            Authorization: `Bearer ${app_token}`,
        },
    });

    if (!graphResponse.ok) {
        const errorData = await graphResponse.json();
        res.send(500, { error: errorData.error.message });
        return;
    }

    const data = await graphResponse.json();

    const currentTime = new Date().toISOString(); // 获取当前时间
    console.log(currentTime, ', getTranscripts length:',data.value.length);
    // 返回转录文本
    res.send(200, data);
  } catch (error) {
      // 返回错误
      res.send(500, { error: error.message });
  }
});

// 定义 /getTranscriptContent 端点
let callCount = 0; // 调用计数器

server.get('/getTranscriptContent', async (req, res) => {
  try {
    const response = await fetch('https://shortly-adapted-akita.ngrok-free.app/get_user_token');
    const token_data = await response.json();

    const transcriptContentUrl = req.query.transcriptContentUrl;
      
      if (!transcriptContentUrl) {
          res.send(400, { error: 'transcriptContentUrl is required' });
          return;
      }
      const content_url = `${transcriptContentUrl}?$format=text/vtt`;
      // 调用 Microsoft Graph API
      const graphResponse = await fetch(content_url, {
          headers: {
              Authorization: `Bearer ${token_data.user_token}`,
          },
      });

      if (!graphResponse.ok) {
          const errorData = await graphResponse.text();
          res.send(500, { error: errorData });
          return;
      }

      const data = await graphResponse.text();
      callCount++; // 增加正确调用计数
      const currentTime = new Date().toISOString(); // 获取当前时间
      console.log(`getTranscriptContent called at ${currentTime}, call count: ${callCount}`); // 输出日志
      console.log('content:', data)

      // 返回转录文本
      res.send(200, data);
  } catch (error) {
      // 返回错误
      res.send(500, { error: error.message });
  }
});

// 确保在服务器启动时获取 app_token
getAppToken();

// 初始化 WebSocket 服务器
const wss = new WebSocketServer({ server: server.server });

wss.on('connection', (ws) => {
  console.log('A client connected');

  ws.on('message', (message) => {
    console.log(`Received message: ${message}`);
  });

  ws.on('close', () => {
    console.log('A client disconnected');
  });
});


// 定义 /subscribe 端点
server.post('/subscribe', async (req, res) => {
  try {
    const onlineMeetingId = req.query.meetingId;
    console.log('/subscribe meetingId:',onlineMeetingId);

    const response = await fetch("https://graph.microsoft.com/beta/subscriptions", {
      method: "GET",
      headers: {
        "Content-Type": "application/json",
        Authorization: `Bearer ${app_token}`,
      }
    });
    if (!response.ok) {
      const errorData = await response.json();
      throw new Error(errorData.error.message);
    }

    const data = await response.json();

    let noSub = true;
    data.value.forEach(sub=>{
      if (sub.resource === `communications/onlineMeetings/${onlineMeetingId}/transcripts`){
        noSub = false;
      }
    })

    if (noSub){
      const subscription = {
        changeType: "created",
        notificationUrl: "https://shortly-adapted-akita.ngrok-free.app/webhook",
        resource: `communications/onlineMeetings/${onlineMeetingId}/transcripts`,
        expirationDateTime: new Date(Date.now() +  60 * 60 * 1000).toISOString(), //1小时
        clientState: "secretClientValue",
      };
  
      const response2 = await fetch("https://graph.microsoft.com/beta/subscriptions", {
        method: "POST",
        headers: {
          "Content-Type": "application/json",
          Authorization: `Bearer ${app_token}`,
        },
        body: JSON.stringify(subscription),
      });
      
      if (!response2.ok) {
        const errorData = await response2.json();
        throw new Error(errorData.error.message);
      }
  
      const data2 = await response2.json();
      console.log("Subscription created:", data2.id);
      res.send(200, data2);
    }
  } catch (error) {
    console.error("Error creating subscription:", error);
    res.send(500, { error: error.message });
  }
});

// 定义 /webhook 端点
server.post('/webhook', async (req, res) => {
  const validationToken = req.query.validationToken;
  console.log('/webhook validationToken:', validationToken);
  // 如果是验证请求，返回 validationToken
  if (validationToken) {
    res.setHeader('Content-Type', 'text/plain');
    res.send(200, validationToken);
    return;
  }

  const notification = req.body.value[0];
  const odataId = notification.resourceData['@odata.id'];

  const url = `https://graph.microsoft.com/beta/${odataId}`.replace('communications','me');
  //console.log('url:', url);

  const response = await fetch('https://shortly-adapted-akita.ngrok-free.app/get_user_token');
  const token_data = await response.json();

  // 获取具体的转写数据
  try {
    const response = await fetch(url, {
      headers: {
        Authorization: `Bearer ${token_data.user_token}`,
      },
    });

    if (!response.ok) {
      const errorData = await response.json();
      //console.log(errorData);
      throw new Error(errorData.error.message);
    }

    const transcriptData = await response.json();
    //console.log("Transcript Data:", transcriptData);

    // 获取转写内容
    const transcriptContentUrl = transcriptData.transcriptContentUrl;
    const contentResponse = await fetch(`${transcriptContentUrl}?$format=text/vtt`, {
      headers: {
        Authorization: `Bearer ${token_data.user_token}`,
      },
    });

    if (!contentResponse.ok) {
      const errorData = await contentResponse.text();
      //console.log(errorData);
      throw new Error(errorData);
    }

    const transcriptContent = await contentResponse.text();
    console.log("Transcript Content:", transcriptContent);

    // 将转写数据发送到所有连接的 WebSocket 客户端
    wss.clients.forEach((client) => {
      if (client.readyState === WebSocket.OPEN) {
        client.send(JSON.stringify({ type: 'newTranscript', data: transcriptContent }));
      }
    });

  } catch (error) {
    console.error("Error fetching transcript data:", error);
  }

  res.send(200, "OK");
});

完整的页面代码如下：

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Meeting Transcripts</title>
    <script src="https://res.cdn.office.net/teams-js/2.0.0/js/MicrosoftTeams.min.js"></script>
    <script src="https://cdnjs.cloudflare.com/ajax/libs/socket.io/4.0.1/socket.io.js"></script>
    <style>
        .subtitle {
            display: flex;
            align-items: center;
            margin-bottom: 10px;
        }
        .speaker-photo {
            width: 20px;
            height: 20px;
            border-radius: 50%;
            margin-right: 10px;
        }
    </style>
</head>
<body>
    <h2>Meeting Transcripts</h2>
    <div id="transcripts"></div>

    <script>
        const clientId = 'Azure注册应用ID';
        const tenantId = 'Azure注册应用租户ID';
        const authUrl = `https://login.microsoftonline.com/${tenantId}/oauth2/v2.0/authorize`;
        const redirectUri = '你的https域名/auth'; // 确保与服务器端一致
        const scope = 'user.read';

        let user_token = null;
        let meetingOrganizerUserId = null;
        let participants = {}; // 用于存储参会者的信息
        let nextLink = null;
        let deltaLink = null;
        let userPhotoCache = {}; // 用于缓存用户头像
        let tokenFetched = false; // 标志变量，用于跟踪是否已经获取了 user_token

        const getUserInfo = async (userId, accessToken) => {
            const graphUrl = `https://graph.microsoft.com/v1.0/users/${userId}`;
            const response = await fetch(graphUrl, {
                headers: {
                    'Authorization': `Bearer ${accessToken}`
                }
            });

            if (response.status === 401) {
                // 如果 token 超期，重新触发 initAuthentication
                initAuthentication();
                return null;
            }

            const userInfo = await response.json();
            return userInfo;
        };

        const getUserPhoto = async (userId, accessToken) => {
            if (userPhotoCache[userId]) {
                return userPhotoCache[userId];
            }

            const graphUrl = `https://graph.microsoft.com/v1.0/users/${userId}/photo/$value`;
            const response = await fetch(graphUrl, {
                headers: {
                    'Authorization': `Bearer ${accessToken}`
                }
            });

            if (!response.ok) {
                const errorData = await response.json();
                console.error('Error fetching user photo:', errorData);
                return null;
            }

            const photoBlob = await response.blob();
            const photoUrl = URL.createObjectURL(photoBlob);
            userPhotoCache[userId] = photoUrl; // 缓存头像 URL
            return photoUrl;
        };

        const getMeetingDetails = async (user_token, joinMeetingId) => {
            const apiUrl = `https://graph.microsoft.com/v1.0/me/onlineMeetings?$filter=joinMeetingIdSettings/joinMeetingId eq '${joinMeetingId}'`;
            const response = await fetch(apiUrl, {
                method: 'GET',
                headers: {
                    'Authorization': `Bearer ${user_token}`,
                    'Content-Type': 'application/json'
                }
            });
        
            if (!response.ok) {
                const errorData = await response.json();
                throw new Error(`HTTP error! status: ${response.status}, message: ${errorData.error}`);
            }
        
            const data = await response.json();
            return data.value[0];
        };

        const getTranscriptContent = async (content) => {
            const lines = content.trim().split('\n');
            const subtitles = [];
        
            let currentSpeaker = null;
        
            for (let i = 0; i < lines.length; i++) {
                const line = lines[i].trim();
        
                if (line.includes('-->')) {
                    const [startTime, endTime] = line.split(' --> ');
                    const text = lines[i + 1].trim();
                    const speakerMatch = text.match(/<v\s*([^>]+)>/);
                    const speaker = speakerMatch ? speakerMatch[1] : null;
                    const content = text.replace(/<v\s*[^>]*>/, '').replace(/<\/v>/, '');
        
                    if (speaker && speaker !== currentSpeaker) {
                        currentSpeaker = speaker;
                    }
        
                    subtitles.push({ startTime, endTime, speaker: currentSpeaker, content });
                    i++; // Skip the next line as it's the text content
                }
            }
            return subtitles;
        };

        const displaySubtitle = async (subtitle, transcriptElement, accessToken) => {
            const subtitleElement = document.createElement('div');
            subtitleElement.classList.add('subtitle');

            // 获取说话者的头像
            const speakerUserId = participants[subtitle.speaker];
            const speakerPhotoUrl = speakerUserId ? await getUserPhoto(speakerUserId, accessToken) : 'default-avatar.png';

            // 创建头像元素
            const speakerPhotoElement = document.createElement('img');
            speakerPhotoElement.src = speakerPhotoUrl;
            speakerPhotoElement.alt = subtitle.speaker;
            speakerPhotoElement.classList.add('speaker-photo');

            // 创建输出字符串
            const output = `${subtitle.startTime}\n${subtitle.content}`;
            
            subtitleElement.appendChild(speakerPhotoElement);
            subtitleElement.appendChild(document.createTextNode(output));
            transcriptElement.appendChild(subtitleElement);
        };

        const subscribeToWebhook = async (meetingId) => {
            try {
                const subscribeResponse = await fetch(`https://shortly-adapted-akita.ngrok-free.app/subscribe?meetingId=${meetingId}`, {
                    method: 'POST'
                });
                if (!subscribeResponse.ok) {
                    const errorData = await subscribeResponse.json();
                    console.error('Webhook subscription failed:', errorData);
                } else {
                    console.log('Webhook subscription successful');
                }
            } catch (error) {
                console.error('Error subscribing to webhook:', error);
            }
        };

        const init = async () => {
            try {
                if (!tokenFetched) {
                    const response = await fetch('https://shortly-adapted-akita.ngrok-free.app/get_user_token');
                    const data = await response.json();
                    if (response.ok) {
                        user_token = data.user_token;
                        console.log('user token retrieved:', user_token);
                        tokenFetched = true;
                    } else {
                        console.error('Failed to get token:', response.statusText);
                        return;
                    }
                }
                const joinMeetingId = '45756456529'; // 替换为你要查询的 joinMeetingId
                try {
                    const meetingDetails = await getMeetingDetails(user_token, joinMeetingId);
                    console.log('Meeting Details:', meetingDetails);
                    meetingOrganizerUserId = meetingDetails.participants.organizer.identity.user.id;
                    const meetingId = meetingDetails.id; // 获取会议 ID
                    console.log('Organizer User ID:', meetingOrganizerUserId);
                    console.log('Meeting ID:', meetingId);

                    // 获取主持人信息
                    const organizerInfo = await getUserInfo(meetingOrganizerUserId, user_token);
                    const organizerDisplayName = organizerInfo.displayName;
                    participants[organizerDisplayName] = meetingOrganizerUserId;

                    // 获取参会者信息
                    const attendeesPromises = meetingDetails.participants.attendees.map(async attendee => {
                        const userId = attendee.identity.user.id;
                        const userInfo = await getUserInfo(userId, user_token);
                        const displayName = userInfo.displayName;
                        participants[displayName] = userId;
                    });

                    await Promise.all(attendeesPromises);

                    // 初始化历史转写
                    // await fetchTranscripts();

                    // 订阅 Webhook
                    await subscribeToWebhook(meetingId);

                    // 设置每小时调用一次订阅 Webhook
                    setInterval(() => subscribeToWebhook(meetingId), 3600000); // 每3600秒（1小时）调用一次

                } catch (error) {
                    console.error('Error fetching meeting details:', error);
                }
                console.log('User Token:', user_token);
            } catch (error) {
                console.error('Error getting token:', error);
            }
        };

        const initAuthentication = () => {
            microsoftTeams.app.initialize();
            microsoftTeams.authentication.authenticate({
                url: `${authUrl}?client_id=${clientId}&response_type=token&redirect_uri=${encodeURIComponent(redirectUri)}&scope=${encodeURIComponent(scope)}`,
                width: 600,
                height: 535,
                successCallback: async (result) => {
                    console.log('Authentication success:', result);
                },
                failureCallback: (error) => {
                    console.error('Authentication failed:', error);
                }
            });
        };

        // 设置较长的轮询时间来防止 user_token 的超期
        setInterval(initAuthentication, 3000000); // 每3000秒（50分钟）轮询一次
        initAuthentication();
        init();

        // 初始化 WebSocket 客户端
        const socket = new WebSocket('wss://shortly-adapted-akita.ngrok-free.app');

        socket.onopen = () => {
            console.log('WebSocket connection established');
        };

        socket.onmessage = (event) => {
            const message = JSON.parse(event.data);
            console.log(message);
            if (message.type === 'newTranscript') {
                const transcriptData = message.data;
                console.log('New Transcript Data:', transcriptData);

                const transcriptsContainer = document.getElementById('transcripts');
                const transcriptElement = document.createDocumentFragment(); // 使用 DocumentFragment 优化 DOM 操作

                getTranscriptContent(transcriptData)
                    .then(subtitles => {
                        subtitles.forEach(subtitle => {
                            displaySubtitle(subtitle, transcriptElement, user_token);
                        });
                    })
                    .catch(error => {
                        const errorElement = document.createElement('div');
                        errorElement.innerHTML = `<strong>${error}</strong>`;
                        transcriptElement.appendChild(errorElement);
                    })
                    .finally(() => {
                        transcriptsContainer.appendChild(transcriptElement); // 一次性插入 DOM
                    });
            }
        };

        socket.onclose = () => {
            console.log('WebSocket connection closed');
        };

        socket.onerror = (error) => {
            console.error('WebSocket error:', error);
        };
    </script>
</body>
</html>

输出效果：

​​​​​​​

摸索不易，欢迎点赞👍加关注！

wxl781227
关注
专栏目录
Microsoft Teams 语音篇（二）--配置语音会议
weixin_44669829的博客
04-20 3033
很早前有一篇文章讲到了如何给用户分配呼叫计划， 本篇来看一下如何配置语音会议–audio conference。 有人问过一个很好的问题，如果这些东西想自己去测试一下应该怎么做，用什么许可证比较好，这里推荐用Business Voice这一个，这个是个一箭三雕的许可，包含了： 呼叫计划 语音会议 电话系统 基本够做所有的纯云端的练习了。 切记获取trail许可的时候最后一步不用选信用卡付款方...
Teams会议/实时事件中的参会者报告详解
weixin_44669829的博客
07-03 8103
参会者报告本身是个非常好的功能，让老板可以抓大家的出勤率。但是这个报告有几个不完美的地方或者说仔细看会发现一些问题。 首先会议报告必须由会议组织者在会议进行中抓取，如果你忘记了第二天再进去抓，抓出来的报告就只有你自己的“加入会议”的动作。这个也在官方文档中提到了: 不过不用担心，如果你不是隔了很久去，哪怕会议结束大家都走了但是你忘记抓取，再次进入会议还是可以抓取到的。没有测试过到底是多久会失效，但是几次经验下来感觉半小时内还是可以亡羊补牢的。 那么抓下来的这份报告严格来说也不是那么亲民。对于会议/培训（
Teams集成-会议侧边栏应用开发-会议转写
09-23 935
获取当前登录用户的信息，获取会议信息，获取会议组织者ID，获取转录列表，获取转写。1）开发工具使用VS Code，下载Teams Tookit插件，创建一个Tab应用，使用JS语言，应用名称随意，如：MeetingRTT。/auth，完成user token的获取，返回一个页面获取access_token(user_token)，存储在redis中；/get_user_token，从redis获取acces_token（user_token)，页面获取会议信息需要；
Microsoft 365 - Teams会议时如何开启美颜功能
WarmSunshine7的博客
02-19 7087
很多人在参加Teams会议时候，都想让自己看起来漂亮些，不想素颜视频。根据这个需求Teams添加了美颜功能。本文对此做介绍。
Microsoft 365 - Outlook中无法创建Teams Meeting的解决方案
WarmSunshine7的博客
01-31 2731
本文主要介绍Outlook中无法找到 'New Teams meeting'的解决方案。
Office365 - 如何设置Teams视频会议背景
热门推荐
WarmSunshine7的博客
01-23 1万+
因为疫情的影响，相信很多人都经历过居家办公，使用Teams视频会议进行工作讨论，进度更新等等内容。有的时候可能不希望会议其他人看到自己周围环境，这种情况下可以设置Teams会议背景为其他图片。那么如何修改Teams会议背景呢？可以通过下面方式设置。
Microsoft 365 - 如何设置Teams自动启动
WarmSunshine7的博客
03-07 1259
在维护Microsoft 365期间，有遇到user设置Teams自动启动但是没有响应，在laptop重新login后Teams没有auto start。尝试uninstall Teams app，清除cache，重新安装Teams app仍然有问题。本文对解决方案做介绍。
Teams升级选项中的后台自动下载安装Teams客户端--Download Teams App in the background
weixin_44669829的博客
11-10 1594
在升级Skype到Teams的时候会涉及到一个很重要的问题就是部署Teams的客户端，对于大多数企业来说如果有成熟的SCCM， Intune或者第三方的解决方案其实都不是太难，或者有些选择用组策略来部署。但是如果以上的方式对你来说都不可行那么该如何操作。 Teams的升级选项页面里就给了一个可以后台下载和安装的选项： 但是很可惜，官网几乎对这个没有任何的解释。对于： 下载包是多大 是否需要管理员权限 占用多少带宽 都没有给出详细的解释。本篇就来看一下这个具体的用户体验。 先找一个升级模式还为Skype
Teams数据统计 - 通话记录
07-13 8533
上篇文章介绍了如何获取用户的在线状态，这篇文章我们记录介绍如何统计用户通话记录。 首先，Teams为了安全，它要求 app 要有CallRecords.Read.All权限。然后就可以通过这个api来获取 call record。 GET /communications/callRecords/{id} 这个接口会返回类似如下的数据： { "@odata.context": "https://graph.microsoft.com/beta/$metadata#communicat..
Microsoft Teams会议设置--页脚字符数限制解决办法
weixin_44669829的博客
04-28 1134
在Teams会议设置里有一项页脚设置： 这里的页脚设置有个最大字符数量的限制，上限为255个字符。所以有公司在把Skype的会议页脚信息复制过来的是否发现少了一大部分： 这个是个死限制，无法突破，微软的roadmap上也没有信息要解决这个问题。所以只能变通一下，使用Exchange 的页脚来替代。 可以参考官网文档 增加一条邮件流规则： 那么现在不管是直接用Teams创建的会议还是使用Ou...
teams-lecture-bot:会记录会议的Microsoft Teams自动加入漫游器
03-22
Microsoft Teams机器人将自动加入会议并进行记录。 要求 Chrome合金 Python3或更高版本。 入门 步骤1：从安装依赖项： pip3 install -r requirements.txt 步骤2：修改 ： { " email " : " ENTER YOUR EMAIL OR ...
Microsoft-Teams-Auto-Joiner:自动加入 Microsoft Teams 会议的 Python 脚本。 只需指定您的团队名称、加入时间和您希望在会议中停留的时间
05-29
Microsoft-Teams-Auto-Joiner 这是现有存储库的修改版本。 原始回购： 这个回购有什么新东西？ 在此版本中，您可以安排加入哪个会议、何时加入和何时退出。 文档 自动加入 Microsoft Teams 会议的 Python 脚本。 ...
teams-phone-fix：修复与Microsoft Teams的通话
02-04
此Firefox插件修复了Microsoft Teams中的错误消息，该错误消息称不支持您的浏览器进行电话呼叫。 它特别适用于使用FirefoxLinux用户，因为Microsoft似乎会阻止不在其范围内的浏览器。 这个Firefox插件也可能在...
Teams-Auto-Joiner:Python脚本自动加入Microsoft Teams会议
03-20
可以自动加入Microsoft Teams会议的Python脚本。加入前自动关闭麦克风和相机。可以在配置文件中设置自动登录和黑名单。 如果您是会议中的最后一位，则始终加入最新的会议并在指定的时间后离开，或者只有在有新的会议...
teams-chat-backup:Microsoft Teams 聊天备份
07-24
Microsoft Teams 聊天备份 该项目检索完整的聊天记录（消息和上传的文件）并将其呈现为 HTML。 要求 Node.js 10（或更高版本）。 在 macOS 和 Windows 上测试过，但很可能也会在 Linux 上运行。 设置 像任何其他 JS ...
如何搭建Vue脚手架
最新发布
w6437286的博客
09-26 448
本文主要讲解如何搭建vue脚手架。
基于JavaWeb开发的Java+SpringMvc+vue+element实现驾校管理系统详细设计
央顺科技官方博客
09-24 931
机遇与挑战始终并存。在开放的互联网平台面前，驾校预约管理系统的信息管理面临着巨大的挑战。传统的管理模式局限于简单数据的管理，无法适应不断变化的市场格局。在早期阶段，在将计算机技术和网络技术融入驾校预约管理系统数据管理方法之前，所有管理方式都通过人工操作完成了管理信息的。系统管理也都将通过计算机进行整体智能化操作，对于驾校预约管理系统所牵扯的管理及数据保存都是非常多的，举例像所有详细信息包括，管理员；首页、个人中心、学员管理、驾校教练管理、驾校车辆管理、预约管理、取消预约管理、驾校公告管理、系统管理。
vue上传预览CAD文件
只会写bug
09-24 601
如果选择的是 Three.js，那么可以创建一个场景来加载和显示模型。如果是用特定的 CAD 查看器库，则按照其文档进行集成即可。根据具体需求和技术能力，可以选择最适合的解决方案来实现 CAD 文件的上传和预览功能。
基于Springboot+Vue的高校教室资源管理系统的设计与实现（含源码+数据库）
m0_59480939的博客
09-25 241
这个系统有三个角色：管理员、学生和教师。管理员可以在前台查看教室信息列表并进行预约，而在后台可以管理学生、教师、教室类型、教室信息、教室预约、系统公告和轮播图等模块，支持新增、查看、修改、删除和审核等操作。系统支持管理员后台登录，但不支持学生和教师后台登录，学生和教师则支持前台注册与登录，而管理员不支持前台登录和注册。数据库版本: mysql5.7或8.0。JDK版本: Java JDK1.8。开发系统:Windows10/11。数据库可视化工具: navicat。架构模式:MVC/前后端分离。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值