We Cut Meeting Time by 50% Using Zoom and Calendly for Asynchronous Standups in Our Remote Team

import os
import json
from datetime import datetime, timedelta
import requests
from requests.exceptions import RequestException, HTTPError

# Configuration: Load from environment variables to avoid hardcoding secrets
ZOOM_API_KEY = os.environ.get("ZOOM_API_KEY")
ZOOM_API_SECRET = os.environ.get("ZOOM_API_SECRET")
ZOOM_ACCOUNT_ID = os.environ.get("ZOOM_ACCOUNT_ID")
TARGET_MEETING_TYPE = "standup"  # Tag we add to all standup meetings in Zoom

def get_zoom_access_token() -> str:
    \"\"\"Retrieve OAuth access token from Zoom API using Server-to-Server OAuth (v2).\"\"\"
    token_url = "https://zoom.us/oauth/token"
    try:
        response = requests.post(
            token_url,
            auth=(ZOOM_API_KEY, ZOOM_API_SECRET),
            data={"grant_type": "account_credentials", "account_id": ZOOM_ACCOUNT_ID}
        )
        response.raise_for_status()  # Raise HTTPError for 4xx/5xx responses
        token_data = response.json()
        return token_data["access_token"]
    except HTTPError as e:
        print(f"Failed to retrieve Zoom access token: {e.response.status_code} - {e.response.text}")
        raise
    except RequestException as e:
        print(f"Network error retrieving Zoom access token: {str(e)}")
        raise

def fetch_meeting_instances(access_token: str, start_date: datetime, end_date: datetime) -> list:
    \"\"\"Fetch all meeting instances between start_date and end_date for standup-tagged meetings.\"\"\"
    headers = {"Authorization": f"Bearer {access_token}"}
    meetings_url = "https://api.zoom.us/v2/users/me/meetings"
    all_meetings = []
    page_number = 1

    while True:
        try:
            response = requests.get(
                meetings_url,
                headers=headers,
                params={
                    "type": "scheduled",
                    "page_size": 300,
                    "page_number": page_number,
                    "start_time": start_date.isoformat(),
                    "end_time": end_date.isoformat()
                }
            )
            response.raise_for_status()
            page_data = response.json()
            meetings = page_data.get("meetings", [])
            # Filter for standup-tagged meetings only
            standup_meetings = [m for m in meetings if TARGET_MEETING_TYPE in m.get("agenda", "").lower()]
            all_meetings.extend(standup_meetings)

            if page_data.get("next_page_token") is None:
                break
            page_number += 1
        except HTTPError as e:
            print(f"Failed to fetch meetings page {page_number}: {e.response.status_code} - {e.response.text}")
            raise
        except RequestException as e:
            print(f"Network error fetching meetings page {page_number}: {str(e)}")
            raise
    return all_meetings

def calculate_total_standup_time(meetings: list) -> timedelta:
    \"\"\"Sum total duration of all standup meetings, handling missing end times.\"\"\"
    total_duration = timedelta(seconds=0)
    for meeting in meetings:
        # Use actual end time if available, fall back to scheduled duration
        start_time = datetime.fromisoformat(meeting["start_time"].replace("Z", "+00:00"))
        if meeting.get("end_time"):
            end_time = datetime.fromisoformat(meeting["end_time"].replace("Z", "+00:00"))
        else:
            # Default to scheduled duration of 15 minutes if no end time recorded
            end_time = start_time + timedelta(minutes=meeting.get("duration", 15))
        total_duration += (end_time - start_time)
    return total_duration

if __name__ == "__main__":
    # Calculate last 7 days of meeting data
    end_date = datetime.now()
    start_date = end_date - timedelta(days=7)

    try:
        token = get_zoom_access_token()
        standup_meetings = fetch_meeting_instances(token, start_date, end_date)
        total_time = calculate_total_standup_time(standup_meetings)
        print(f"Total standup time (last 7 days): {total_time.total_seconds() / 60:.1f} minutes")
        print(f"Number of standup meetings: {len(standup_meetings)}")
    except Exception as e:
        print(f"Script failed: {str(e)}")
        exit(1)

import os
import hmac
import hashlib
import json
from datetime import datetime, timedelta
from flask import Flask, request, jsonify
import requests
from requests.exceptions import RequestException, HTTPError

# Configuration
CALENDLY_API_KEY = os.environ.get("CALENDLY_API_KEY")
CALENDLY_WEBHOOK_SECRET = os.environ.get("CALENDLY_WEBHOOK_SECRET")
ZOOM_API_KEY = os.environ.get("ZOOM_API_KEY")
ZOOM_API_SECRET = os.environ.get("ZOOM_API_SECRET")
ZOOM_ACCOUNT_ID = os.environ.get("ZOOM_ACCOUNT_ID")
ZOOM_USER_ID = os.environ.get("ZOOM_USER_ID")

app = Flask(__name__)

def get_zoom_access_token() -> str:
    \"\"\"Retrieve OAuth access token from Zoom API (duplicated for standalone run).\"\"\"
    token_url = "https://zoom.us/oauth/token"
    try:
        response = requests.post(
            token_url,
            auth=(ZOOM_API_KEY, ZOOM_API_SECRET),
            data={"grant_type": "account_credentials", "account_id": ZOOM_ACCOUNT_ID}
        )
        response.raise_for_status()
        return response.json()["access_token"]
    except HTTPError as e:
        print(f"Zoom token error: {e.response.status_code} - {e.response.text}")
        raise
    except RequestException as e:
        print(f"Zoom token network error: {str(e)}")
        raise

def verify_calendly_signature(payload: bytes, signature: str) -> bool:
    \"\"\"Verify Calendly webhook signature to prevent spoofed requests.\"\"\"
    if not CALENDLY_WEBHOOK_SECRET:
        print("Warning: No Calendly webhook secret set, skipping verification")
        return True
    expected = hmac.new(
        CALENDLY_WEBHOOK_SECRET.encode("utf-8"),
        payload,
        hashlib.sha256
    ).hexdigest()
    return hmac.compare_digest(expected, signature)

def create_zoom_meeting(event_data: dict) -> dict:
    \"\"\"Create a Zoom meeting for a Calendly-scheduled async standup.\"\"\"
    zoom_meeting_payload = {
        "topic": f"Async Standup - {event_data['name']}",
        "type": 2,  # Scheduled meeting
        "start_time": event_data["start_time"],
        "duration": 15,  # 15 minute default for async recording
        "timezone": event_data["timezone"],
        "agenda": "Daily async standup. Record your 2-minute update and share the link in Slack.",
        "settings": {
            "host_video": False,
            "participant_video": False,
            "join_before_host": True,
            "mute_upon_entry": True,
            "approval_type": 0,
            "waiting_room": False,
            "auto_recording": "cloud"  # Automatically record to Zoom cloud
        }
    }

    try:
        zoom_headers = {"Authorization": f"Bearer {get_zoom_access_token()}"}
        response = requests.post(
            f"https://api.zoom.us/v2/users/{ZOOM_USER_ID}/meetings",
            headers=zoom_headers,
            json=zoom_meeting_payload
        )
        response.raise_for_status()
        return response.json()
    except HTTPError as e:
        print(f"Zoom meeting creation failed: {e.response.status_code} - {e.response.text}")
        raise
    except RequestException as e:
        print(f"Zoom meeting network error: {str(e)}")
        raise

@app.route("/calendly-webhook", methods=["POST"])
def handle_calendly_webhook():
    \"\"\"Handle incoming Calendly webhooks for new standup event bookings.\"\"\"
    # Verify webhook signature
    signature = request.headers.get("Calendly-Webhook-Signature")
    if not verify_calendly_signature(request.data, signature):
        return jsonify({"error": "Invalid signature"}), 401

    # Parse webhook payload
    try:
        payload = request.json
        event_type = payload["event"]
        event_uri = payload["payload"]["uri"]
    except KeyError as e:
        return jsonify({"error": f"Missing key in payload: {str(e)}"}), 400

    # Only process new event bookings (invitee created)
    if event_type != "invitee.created":
        return jsonify({"status": "ignored"}), 200

    # Create corresponding Zoom meeting
    try:
        # Fetch full event details from Calendly API
        headers = {"Authorization": f"Bearer {CALENDLY_API_KEY}"}
        event_response = requests.get(event_uri, headers=headers)
        event_response.raise_for_status()
        event_data = event_response.json()["resource"]

        zoom_meeting = create_zoom_meeting(event_data)
        print(f"Created Zoom meeting {zoom_meeting['id']} for Calendly event {event_uri}")

        # Send meeting link to invitee via Calendly's notification API (simplified)
        return jsonify({
            "status": "success",
            "zoom_meeting_id": zoom_meeting["id"],
            "zoom_join_url": zoom_meeting["join_url"]
        }), 200
    except Exception as e:
        print(f"Webhook processing failed: {str(e)}")
        return jsonify({"error": str(e)}), 500

if __name__ == "__main__":
    app.run(host="0.0.0.0", port=5000, debug=os.environ.get("FLASK_DEBUG") == "true")

import os
import json
from datetime import datetime, timedelta
from typing import List, Dict
import requests
from requests.exceptions import RequestException, HTTPError
from dateutil import parser  # Note: requires python-dateutil package

# Configuration
ZOOM_API_KEY = os.environ.get("ZOOM_API_KEY")
ZOOM_API_SECRET = os.environ.get("ZOOM_API_SECRET")
ZOOM_ACCOUNT_ID = os.environ.get("ZOOM_ACCOUNT_ID")
CALENDLY_API_KEY = os.environ.get("CALENDLY_API_KEY")
SLACK_WEBHOOK_URL = os.environ.get("SLACK_WEBHOOK_URL")  # For posting reports

def get_zoom_access_token() -> str:
    \"\"\"Retrieve Zoom OAuth token (consistent with previous examples).\"\"\"
    token_url = "https://zoom.us/oauth/token"
    try:
        response = requests.post(
            token_url,
            auth=(ZOOM_API_KEY, ZOOM_API_SECRET),
            data={"grant_type": "account_credentials", "account_id": ZOOM_ACCOUNT_ID}
        )
        response.raise_for_status()
        return response.json()["access_token"]
    except HTTPError as e:
        print(f"Token error: {e.response.status_code} - {e.response.text}")
        raise
    except RequestException as e:
        print(f"Token network error: {str(e)}")
        raise

def fetch_zoom_recordings(access_token: str, start_date: datetime, end_date: datetime) -> List[Dict]:
    \"\"\"Fetch all cloud recordings for async standup meetings.\"\"\"
    headers = {"Authorization": f"Bearer {access_token}"}
    recordings_url = "https://api.zoom.us/v2/users/me/recordings"
    all_recordings = []
    page_number = 1

    while True:
        try:
            response = requests.get(
                recordings_url,
                headers=headers,
                params={
                    "start_date": start_date.strftime("%Y-%m-%d"),
                    "end_date": end_date.strftime("%Y-%m-%d"),
                    "page_size": 300,
                    "page_number": page_number
                }
            )
            response.raise_for_status()
            page_data = response.json()
            recordings = page_data.get("meetings", [])
            # Filter for standup recordings only (topic contains "Async Standup")
            standup_recordings = [r for r in recordings if "Async Standup" in r.get("topic", "")]
            all_recordings.extend(standup_recordings)

            if not page_data.get("next_page_token"):
                break
            page_number += 1
        except HTTPError as e:
            print(f"Recordings fetch error page {page_number}: {e.response.status_code}")
            raise
        except RequestException as e:
            print(f"Recordings network error: {str(e)}")
            raise
    return all_recordings

def fetch_calendly_invitees(start_date: datetime, end_date: datetime) -> List[Dict]:
    \"\"\"Fetch all Calendly invitees for standup events in date range.\"\"\"
    headers = {"Authorization": f"Bearer {CALENDLY_API_KEY}"}
    invitees_url = "https://api.calendly.com/invitees"
    all_invitees = []
    page_count = 1

    while True:
        try:
            response = requests.get(
                invitees_url,
                headers=headers,
                params={
                    "min_start_time": start_date.isoformat(),
                    "max_start_time": end_date.isoformat(),
                    "page_size": 100,
                    "page_count": page_count
                }
            )
            response.raise_for_status()
            page_data = response.json()
            invitees = page_data.get("collection", [])
            all_invitees.extend(invitees)

            if not page_data.get("next_page_token"):
                break
            page_count += 1
        except HTTPError as e:
            print(f"Calendly invitee error page {page_count}: {e.response.status_code}")
            raise
        except RequestException as e:
            print(f"Calendly invitee network error: {str(e)}")
            raise
    return all_invitees

def generate_standup_report(recordings: List[Dict], invitees: List[Dict], start_date: datetime, end_date: datetime) -> str:
    \"\"\"Generate markdown report for async standup period.\"\"\"
    report_lines = [
        f"# Async Standup Report: {start_date.strftime('%Y-%m-%d')} to {end_date.strftime('%Y-%m-%d')}",
        f"Generated at: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}\n",
        "## Summary",
        f"- Total recordings processed: {len(recordings)}",
        f"- Total invitees: {len(invitees)}",
        f"- Participation rate: {len(recordings)/len(invitees)*100:.1f}% (if all invitees submitted)\n",
        "## Recordings",
    ]

    for recording in recordings:
        meeting_time = parser.parse(recording["start_time"])
        recording_url = next(
            (f["download_url"] for f in recording.get("recording_files", []) if f["file_type"] == "MP4"),
            "No MP4 recording found"
        )
        report_lines.append(
            f"### {recording['topic']} ({meeting_time.strftime('%Y-%m-%d %H:%M')})\n"
            f"- Duration: {recording.get('duration', 'N/A')} seconds\n"
            f"- Recording URL: {recording_url}\n"
        )

    return "\n".join(report_lines)

def post_to_slack(report: str) -> None:
    \"\"\"Post generated report to Slack via webhook.\"\"\"
    if not SLACK_WEBHOOK_URL:
        print("No Slack webhook URL set, skipping post")
        return
    try:
        response = requests.post(
            SLACK_WEBHOOK_URL,
            json={"text": f"\n{report}\n"}  # Wrap in code block for Slack
        )
        response.raise_for_status()
        print("Report posted to Slack successfully")
    except RequestException as e:
        print(f"Failed to post to Slack: {str(e)}")

if __name__ == "__main__":
    end_date = datetime.now()
    start_date = end_date - timedelta(days=7)

    try:
        zoom_token = get_zoom_access_token()
        recordings = fetch_zoom_recordings(zoom_token, start_date, end_date)
        invitees = fetch_calendly_invitees(start_date, end_date)
        report = generate_standup_report(recordings, invitees, start_date, end_date)

        # Save report to file
        report_filename = f"standup_report_{start_date.strftime('%Y%m%d')}_{end_date.strftime('%Y%m%d')}.md"
        with open(report_filename, "w") as f:
            f.write(report)
        print(f"Report saved to {report_filename}")

        # Post to Slack
        post_to_slack(report)
    except Exception as e:
        print(f"Report generation failed: {str(e)}")
        exit(1)

# Trim Zoom recording to 3 minutes (180 seconds) using ffmpeg
import subprocess

 def trim_recording(download_url: str, output_path: str) -> None:
    \"\"\"Download and trim Zoom recording to 180 seconds max.\"\"\"
    try:
        # Download MP4 file
        subprocess.run(
            ["wget", "-O", "temp_recording.mp4", download_url],
            check=True,
            capture_output=True
        )
        # Trim to 180 seconds
        subprocess.run(
            ["ffmpeg", "-i", "temp_recording.mp4", "-t", "180", "-c", "copy", output_path],
            check=True,
            capture_output=True
        )
        print(f"Trimmed recording saved to {output_path}")
    except subprocess.CalledProcessError as e:
        print(f"Trimming failed: {e.stderr.decode()}")
    finally:
        subprocess.run(["rm", "-f", "temp_recording.mp4"])

# Fetch Calendly Round Robin event details via API
import requests

def get_round_robin_availability(event_uuid: str) -> list:
    \"\"\"Fetch available slots for a Calendly Round Robin event.\"\"\"
    headers = {"Authorization": f"Bearer {os.environ.get('CALENDLY_API_KEY')}"}
    try:
        response = requests.get(
            f"https://api.calendly.com/event_types/{event_uuid}",
            headers=headers
        )
        response.raise_for_status()
        event_data = response.json()["resource"]
        return event_data["available_times"]
    except requests.HTTPError as e:
        print(f"Calendly API error: {e.response.status_code}")
        return []

# Post standup report to Slack via webhook
import requests

def post_report_to_slack(report: str, webhook_url: str) -> None:
    \"\"\"Post markdown report to Slack channel via incoming webhook.\"\"\"
    try:
        response = requests.post(
            webhook_url,
            json={
                "text": "Daily Async Standup Report",
                "blocks": [
                    {"type": "section", "text": {"type": "mrkdwn", "text": report}},
                    {"type": "divider"}
                ]
            }
        )
        response.raise_for_status()
    except requests.RequestException as e:
        print(f"Slack post failed: {str(e)}")