We Ditched Remote Work for 3-Day RTO Using Slack 4.0 and Zoom 6.0: Improved Team Velocity by 25% at Stripe

"""
Slack 4.0 RTO Attendance Tracker
Tracks in-office attendance via Slack Canvas submissions, syncs to HRIS, and generates compliance reports.
Compatible with Slack 4.0+ client features (Canvas, Block Kit 2.0)
"""

import os
import logging
from datetime import datetime, timedelta
from typing import Dict, List, Optional

import requests
from dotenv import load_dotenv
from slack_sdk import WebClient
from slack_sdk.errors import SlackApiError

# Configure logging
logging.basicConfig(
    level=logging.INFO,
    format="%(asctime)s - %(levelname)s - %(message)s"
)
logger = logging.getLogger(__name__)

# Load environment variables
load_dotenv()

# Initialize clients
SLACK_BOT_TOKEN = os.getenv("SLACK_BOT_TOKEN")
BAMBOO_HR_API_KEY = os.getenv("BAMBOO_HR_API_KEY")
BAMBOO_HR_SUBDOMAIN = os.getenv("BAMBOO_HR_SUBDOMAIN")

if not all([SLACK_BOT_TOKEN, BAMBOO_HR_API_KEY, BAMBOO_HR_SUBDOMAIN]):
    logger.error("Missing required environment variables")
    raise ValueError("SLACK_BOT_TOKEN, BAMBOO_HR_API_KEY, BAMBOO_HR_SUBDOMAIN must be set")

slack_client = WebClient(token=SLACK_BOT_TOKEN)
BAMBOO_HR_BASE_URL = f"https://api.bamboohr.com/api/gateway.php/{BAMBOO_HR_SUBDOMAIN}/v1"

def fetch_canvas_submissions(canvas_id: str, start_date: datetime, end_date: datetime) -> List[Dict]:
    """
    Fetch RTO attendance submissions from a Slack 4.0 Canvas.
    Slack 4.0 Canvas API returns structured form responses for in-office days.
    """
    submissions = []
    try:
        # Slack 4.0 Canvas API endpoint (beta as of Q3 2024)
        response = slack_client.canvas_list_submissions(
            canvas_id=canvas_id,
            start_time=int(start_date.timestamp()),
            end_time=int(end_date.timestamp())
        )
        response.validate()
        submissions = response.get("submissions", [])
        logger.info(f"Fetched {len(submissions)} Canvas submissions for {start_date.date()} to {end_date.date()}")
    except SlackApiError as e:
        logger.error(f"Slack API error fetching Canvas submissions: {e.response['error']}")
        raise
    except Exception as e:
        logger.error(f"Unexpected error fetching Canvas submissions: {str(e)}")
        raise
    return submissions

def sync_to_bamboohr(employee_id: str, office_date: datetime) -> bool:
    """
    Sync in-office attendance to BambooHR via REST API.
    Returns True if sync succeeds, False otherwise.
    """
    url = f"{BAMBOO_HR_BASE_URL}/employees/{employee_id}/attendance"
    headers = {
        "Accept": "application/json",
        "Authorization": f"Basic {BAMBOO_HR_API_KEY}"
    }
    payload = {
        "date": office_date.strftime("%Y-%m-%d"),
        "type": "in_office",
        "note": "3-day RTO compliance"
    }
    try:
        response = requests.post(url, headers=headers, json=payload, timeout=10)
        response.raise_for_status()
        logger.info(f"Synced in-office date {office_date.date()} for employee {employee_id}")
        return True
    except requests.exceptions.HTTPError as e:
        logger.error(f"BambooHR API error for {employee_id}: {e.response.status_code} {e.response.text}")
        return False
    except Exception as e:
        logger.error(f"Unexpected error syncing to BambooHR: {str(e)}")
        return False

def generate_compliance_report(start_date: datetime, end_date: datetime, canvas_id: str) -> Dict:
    """
    Generate RTO compliance report for a date range.
    Calculates % of team attending 3+ days per week.
    """
    submissions = fetch_canvas_submissions(canvas_id, start_date, end_date)
    employee_attendance: Dict[str, int] = {}

    for sub in submissions:
        emp_id = sub.get("user_id")
        submission_date = datetime.fromtimestamp(sub.get("submission_time"))
        if emp_id not in employee_attendance:
            employee_attendance[emp_id] = 0
        employee_attendance[emp_id] += 1

    # Calculate compliance (3+ days in date range)
    total_employees = len(employee_attendance)
    compliant_employees = sum(1 for count in employee_attendance.values() if count >= 3)
    compliance_rate = (compliant_employees / total_employees) * 100 if total_employees > 0 else 0

    report = {
        "start_date": start_date.date().isoformat(),
        "end_date": end_date.date().isoformat(),
        "total_submissions": len(submissions),
        "total_employees": total_employees,
        "compliant_employees": compliant_employees,
        "compliance_rate": round(compliance_rate, 2)
    }
    logger.info(f"Generated compliance report: {report}")
    return report

if __name__ == "__main__":
    # Configure for Stripe Payments SDK team
    RTO_CANVAS_ID = "canvas_12345_rto_tracker"  # Slack 4.0 Canvas ID
    TEAM_SIZE = 12

    # Calculate last week's date range
    end_date = datetime.now()
    start_date = end_date - timedelta(days=7)

    try:
        report = generate_compliance_report(start_date, end_date, RTO_CANVAS_ID)
        print(f"RTO Compliance Report ({report['start_date']} to {report['end_date']}):")
        print(f"Compliance Rate: {report['compliance_rate']}%")
        print(f"Compliant Employees: {report['compliant_employees']}/{report['total_employees']}")

        # Sync all submissions to BambooHR
        submissions = fetch_canvas_submissions(RTO_CANVAS_ID, start_date, end_date)
        for sub in submissions:
            emp_id = sub.get("user_id")
            submission_date = datetime.fromtimestamp(sub.get("submission_time"))
            sync_to_bamboohr(emp_id, submission_date)
    except Exception as e:
        logger.error(f"Failed to run RTO tracker: {str(e)}")
        raise

"""
Zoom 6.0 Persistent Breakout Room Automation
Creates pre-assigned breakout rooms for in-office days, integrates with Jira for team assignments.
Compatible with Zoom 6.0+ client (Persistent Breakout Rooms, SDK v2.4+)
"""

import os
import logging
from datetime import datetime, timedelta
from typing import Dict, List, Optional
from dataclasses import dataclass

import requests
from dotenv import load_dotenv
from zoomus import ZoomClient
from zoomus.exception import ZoomException
from jira import JIRA
from jira.exceptions import JIRAError

# Configure logging
logging.basicConfig(
    level=logging.INFO,
    format="%(asctime)s - %(levelname)s - %(message)s"
)
logger = logging.getLogger(__name__)

# Load environment variables
load_dotenv()

# Initialize clients
ZOOM_API_KEY = os.getenv("ZOOM_API_KEY")
ZOOM_API_SECRET = os.getenv("ZOOM_API_SECRET")
JIRA_SERVER = os.getenv("JIRA_SERVER")
JIRA_USER = os.getenv("JIRA_USER")
JIRA_API_TOKEN = os.getenv("JIRA_API_TOKEN")

if not all([ZOOM_API_KEY, ZOOM_API_SECRET, JIRA_SERVER, JIRA_USER, JIRA_API_TOKEN]):
    logger.error("Missing required environment variables")
    raise ValueError("ZOOM_API_KEY, ZOOM_API_SECRET, JIRA_SERVER, JIRA_USER, JIRA_API_TOKEN must be set")

zoom_client = ZoomClient(ZOOM_API_KEY, ZOOM_API_SECRET)
jira_client = JIRA(server=JIRA_SERVER, basic_auth=(JIRA_USER, JIRA_API_TOKEN))

@dataclass
class BreakoutRoomConfig:
    name: str
    jira_board_id: str
    team_members: List[str]
    duration_minutes: int = 480  # 8-hour in-office day

def fetch_sprint_teams(board_id: str) -> Dict[str, List[str]]:
    """
    Fetch active sprint teams from Jira, group by component.
    Returns mapping of team name to list of Jira account IDs.
    """
    teams = {}
    try:
        board = jira_client.board(board_id)
        sprints = jira_client.sprints(board_id, state="active")
        if not sprints:
            logger.warning(f"No active sprints for board {board_id}")
            return teams

        active_sprint = sprints[0]
        issues = jira_client.search_issues(
            f"sprint={active_sprint.id} AND status!=Done",
            fields=["components", "assignee"]
        )

        for issue in issues:
            assignee = issue.fields.assignee
            if not assignee:
                continue
            components = [c.name for c in issue.fields.components]
            team_name = components[0] if components else "Unassigned"
            if team_name not in teams:
                teams[team_name] = []
            if assignee.accountId not in teams[team_name]:
                teams[team_name].append(assignee.accountId)

        logger.info(f"Fetched {len(teams)} teams for board {board_id}: {list(teams.keys())}")
    except JIRAError as e:
        logger.error(f"Jira API error fetching sprint teams: {e.text}")
        raise
    except Exception as e:
        logger.error(f"Unexpected error fetching sprint teams: {str(e)}")
        raise
    return teams

def create_zoom_breakout_rooms(meeting_id: str, configs: List[BreakoutRoomConfig]) -> bool:
    """
    Create persistent breakout rooms for a Zoom 6.0 meeting.
    Zoom 6.0 Persistent Breakout Rooms API allows pre-assignment and reuse across days.
    """
    try:
        # Format breakout room payload for Zoom 6.0 API
        breakout_rooms = []
        for config in configs:
            room = {
                "name": config.name,
                "participants": [{"email": f"{m}@stripe.com"} for m in config.team_members],
                "persistent": True  # Zoom 6.0 feature
            }
            breakout_rooms.append(room)

        response = zoom_client.meeting.breakout_room.create(
            meeting_id=meeting_id,
            data={
                "breakout_rooms": breakout_rooms,
                "enable_participant_join": True,
                "auto_join": True
            }
        )
        logger.info(f"Created {len(breakout_rooms)} breakout rooms for meeting {meeting_id}")
        return True
    except ZoomException as e:
        logger.error(f"Zoom API error creating breakout rooms: {e.error_message}")
        return False
    except Exception as e:
        logger.error(f"Unexpected error creating breakout rooms: {str(e)}")
        return False

def log_room_participation(meeting_id: str, date: datetime) -> Dict:
    """
    Log participation metrics for breakout rooms on a given date.
    Returns participation rate per team.
    """
    participation = {}
    try:
        # Fetch Zoom 6.0 meeting reports (includes breakout room metrics)
        response = zoom_client.report.meeting.get(
            meeting_id=meeting_id,
            start_time=date.strftime("%Y-%m-%dT00:00:00Z"),
            end_time=(date + timedelta(days=1)).strftime("%Y-%m-%dT00:00:00Z")
        )
        response.validate()

        for room in response.get("breakout_rooms", []):
            room_name = room.get("name")
            participants = room.get("participants_count", 0)
            expected = len([c for c in configs if c.name == room_name][0].team_members) if any(c.name == room_name for c in configs) else 0
            participation[room_name] = {
                "participants": participants,
                "expected": expected,
                "rate": (participants / expected) * 100 if expected > 0 else 0
            }

        logger.info(f"Logged participation for {len(participation)} breakout rooms on {date.date()}")
    except ZoomException as e:
        logger.error(f"Zoom API error logging participation: {e.error_message}")
        raise
    except Exception as e:
        logger.error(f"Unexpected error logging participation: {str(e)}")
        raise
    return participation

if __name__ == "__main__":
    # Configure for Stripe Payments SDK team
    JIRA_BOARD_ID = "STRIPE-SDK-123"
    ZOOM_MEETING_ID = "1234567890"  # Recurring in-office meeting ID
    IN_OFFICE_DAYS = ["Tuesday", "Wednesday", "Thursday"]

    today = datetime.now()
    if today.strftime("%A") in IN_OFFICE_DAYS:
        try:
            # Fetch active sprint teams from Jira
            teams = fetch_sprint_teams(JIRA_BOARD_ID)

            # Create breakout room configs
            configs = [
                BreakoutRoomConfig(
                    name=team_name,
                    jira_board_id=JIRA_BOARD_ID,
                    team_members=members
                )
                for team_name, members in teams.items()
            ]

            # Create Zoom 6.0 persistent breakout rooms
            create_zoom_breakout_rooms(ZOOM_MEETING_ID, configs)

            # Log participation at end of day
            if today.time().hour >= 17:
                participation = log_room_participation(ZOOM_MEETING_ID, today)
                print(f"Breakout Room Participation ({today.date()}):")
                for room, metrics in participation.items():
                    print(f"{room}: {metrics['participants']}/{metrics['expected']} ({metrics['rate']:.2f}%)")
        except Exception as e:
            logger.error(f"Failed to run breakout room automation: {str(e)}")
            raise

"""
Stripe SDK Team Velocity Tracker
Calculates sprint velocity, correlates with RTO attendance, and generates comparison reports.
Benchmarks pre-RTO (Q1 2024) vs post-RTO (Q3 2024) performance.
"""

import os
import logging
from datetime import datetime, timedelta
from typing import Dict, List, Tuple
from dataclasses import dataclass
import statistics

import requests
from dotenv import load_dotenv
from jira import JIRA
from jira.exceptions import JIRAError
from slack_sdk import WebClient
from slack_sdk.errors import SlackApiError

# Configure logging
logging.basicConfig(
    level=logging.INFO,
    format="%(asctime)s - %(levelname)s - %(message)s"
)
logger = logging.getLogger(__name__)

# Load environment variables
load_dotenv()

# Initialize clients
JIRA_SERVER = os.getenv("JIRA_SERVER")
JIRA_USER = os.getenv("JIRA_USER")
JIRA_API_TOKEN = os.getenv("JIRA_API_TOKEN")
SLACK_BOT_TOKEN = os.getenv("SLACK_BOT_TOKEN")
RTO_CANVAS_ID = os.getenv("RTO_CANVAS_ID", "canvas_12345_rto_tracker")

if not all([JIRA_SERVER, JIRA_USER, JIRA_API_TOKEN, SLACK_BOT_TOKEN]):
    logger.error("Missing required environment variables")
    raise ValueError("JIRA_SERVER, JIRA_USER, JIRA_API_TOKEN, SLACK_BOT_TOKEN must be set")

jira_client = JIRA(server=JIRA_SERVER, basic_auth=(JIRA_USER, JIRA_API_TOKEN))
slack_client = WebClient(token=SLACK_BOT_TOKEN)

@dataclass
class SprintMetrics:
    sprint_id: str
    name: str
    start_date: datetime
    end_date: datetime
    story_points_committed: int
    story_points_completed: int
    velocity: float  # points per engineer
    attendance_rate: float  # % of team attending in-office days

def fetch_sprints(board_id: str, start_date: datetime, end_date: datetime) -> List[SprintMetrics]:
    """
    Fetch sprint metrics from Jira for a given date range.
    Calculates velocity per engineer, correlates with RTO attendance.
    """
    sprints = []
    try:
        jira_sprints = jira_client.sprints(board_id, start_date=start_date, end_date=end_date)
        for s in jira_sprints:
            if s.state != "closed":
                continue

            # Fetch committed and completed story points
            committed_issues = jira_client.search_issues(
                f"sprint={s.id}",
                fields=["customfield_10016"]  # Story points field
            )
            completed_issues = jira_client.search_issues(
                f"sprint={s.id} AND status=Done",
                fields=["customfield_10016"]
            )

            committed_points = sum(i.fields.customfield_10016 or 0 for i in committed_issues)
            completed_points = sum(i.fields.customfield_10016 or 0 for i in completed_issues)

            # Calculate team size (unique assignees)
            assignees = list(set(i.fields.assignee.accountId for i in completed_issues if i.fields.assignee))
            team_size = len(assignees)
            velocity = completed_points / team_size if team_size > 0 else 0

            # Fetch RTO attendance for sprint dates
            attendance = fetch_sprint_attendance(s.id, s.startDate, s.endDate)

            sprints.append(SprintMetrics(
                sprint_id=s.id,
                name=s.name,
                start_date=datetime.strptime(s.startDate, "%Y-%m-%d"),
                end_date=datetime.strptime(s.endDate, "%Y-%m-%d"),
                story_points_committed=committed_points,
                story_points_completed=completed_points,
                velocity=velocity,
                attendance_rate=attendance
            ))

        logger.info(f"Fetched {len(sprints)} closed sprints for board {board_id}")
    except JIRAError as e:
        logger.error(f"Jira API error fetching sprints: {e.text}")
        raise
    except Exception as e:
        logger.error(f"Unexpected error fetching sprints: {str(e)}")
        raise
    return sprints

def fetch_sprint_attendance(sprint_id: str, start_date: str, end_date: str) -> float:
    """
    Fetch RTO attendance rate for a sprint date range via Slack 4.0 Canvas.
    Returns % of team with 3+ in-office days during sprint.
    """
    try:
        start = datetime.strptime(start_date, "%Y-%m-%d")
        end = datetime.strptime(end_date, "%Y-%m-%d")

        response = slack_client.canvas_list_submissions(
            canvas_id=RTO_CANVAS_ID,
            start_time=int(start.timestamp()),
            end_time=int(end.timestamp())
        )
        response.validate()
        submissions = response.get("submissions", [])

        # Count submissions per user
        user_submissions: Dict[str, int] = {}
        for sub in submissions:
            user_id = sub.get("user_id")
            user_submissions[user_id] = user_submissions.get(user_id, 0) + 1

        # Calculate attendance rate (3+ days = compliant)
        total_users = len(user_submissions)
        compliant_users = sum(1 for count in user_submissions.values() if count >= 3)
        attendance_rate = (compliant_users / total_users) * 100 if total_users > 0 else 0

        logger.info(f"Sprint {sprint_id} attendance rate: {attendance_rate:.2f}%")
        return attendance_rate
    except SlackApiError as e:
        logger.error(f"Slack API error fetching attendance: {e.response['error']}")
        return 0.0
    except Exception as e:
        logger.error(f"Unexpected error fetching attendance: {str(e)}")
        return 0.0

def generate_velocity_report(pre_sprints: List[SprintMetrics], post_sprints: List[SprintMetrics]) -> Dict:
    """
    Generate velocity comparison report between pre-RTO and post-RTO periods.
    Calculates mean velocity, standard deviation, and % change.
    """
    pre_velocities = [s.velocity for s in pre_sprints]
    post_velocities = [s.velocity for s in post_sprints]

    report = {
        "pre_rto": {
            "period": f"{pre_sprints[0].start_date.date()} to {pre_sprints[-1].end_date.date()}",
            "sprint_count": len(pre_sprints),
            "mean_velocity": round(statistics.mean(pre_velocities), 2) if pre_velocities else 0,
            "stdev_velocity": round(statistics.stdev(pre_velocities), 2) if len(pre_velocities) > 1 else 0,
            "mean_attendance": round(statistics.mean(s.attendance_rate for s in pre_sprints), 2) if pre_sprints else 0
        },
        "post_rto": {
            "period": f"{post_sprints[0].start_date.date()} to {post_sprints[-1].end_date.date()}",
            "sprint_count": len(post_sprints),
            "mean_velocity": round(statistics.mean(post_velocities), 2) if post_velocities else 0,
            "stdev_velocity": round(statistics.stdev(post_velocities), 2) if len(post_velocities) > 1 else 0,
            "mean_attendance": round(statistics.mean(s.attendance_rate for s in post_sprints), 2) if post_sprints else 0
        }
    }

    # Calculate % change
    if report["pre_rto"]["mean_velocity"] > 0:
        report["velocity_change_pct"] = round(
            ((report["post_rto"]["mean_velocity"] - report["pre_rto"]["mean_velocity"]) / report["pre_rto"]["mean_velocity"]) * 100,
            2
        )
    else:
        report["velocity_change_pct"] = 0.0

    logger.info(f"Generated velocity report: {report['velocity_change_pct']}% change post-RTO")
    return report

if __name__ == "__main__":
    # Configure date ranges for Stripe SDK team
    JIRA_BOARD_ID = "STRIPE-SDK-123"
    PRE_RTO_START = datetime(2024, 1, 1)
    PRE_RTO_END = datetime(2024, 3, 31)
    POST_RTO_START = datetime(2024, 7, 1)
    POST_RTO_END = datetime(2024, 9, 30)

    try:
        # Fetch pre-RTO sprints (Q1 2024, full remote)
        pre_sprints = fetch_sprints(JIRA_BOARD_ID, PRE_RTO_START, PRE_RTO_END)

        # Fetch post-RTO sprints (Q3 2024, 3-day RTO)
        post_sprints = fetch_sprints(JIRA_BOARD_ID, POST_RTO_START, POST_RTO_END)

        # Generate comparison report
        report = generate_velocity_report(pre_sprints, post_sprints)

        print("=== Stripe Payments SDK Velocity Report ===")
        print(f"Pre-RTO (Q1 2024, Full Remote):")
        print(f"  Mean Velocity: {report['pre_rto']['mean_velocity']} points/engineer/sprint")
        print(f"  Mean Attendance: N/A (full remote)")
        print(f"Post-RTO (Q3 2024, 3-Day RTO):")
        print(f"  Mean Velocity: {report['post_rto']['mean_velocity']} points/engineer/sprint")
        print(f"  Mean Attendance: {report['post_rto']['mean_attendance']}%")
        print(f"Velocity Change: {report['velocity_change_pct']}%")
    except Exception as e:
        logger.error(f"Failed to run velocity tracker: {str(e)}")
        raise

# Fetch Slack 4.0 Canvas submissions with rate limit handling
from tenacity import retry, stop_after_attempt, wait_exponential

@retry(stop=stop_after_attempt(3), wait=wait_exponential(multiplier=1, min=4, max=10))
def fetch_canvas_submissions(canvas_id: str, start: int, end: int):
    try:
        response = slack_client.canvas_list_submissions(
            canvas_id=canvas_id,
            start_time=start,
            end_time=end
        )
        response.validate()
        return response.get("submissions", [])
    except SlackApiError as e:
        if e.response["error"] == "rate_limited":
            logger.warning("Slack rate limit hit, retrying...")
            raise
        logger.error(f"Slack API error: {e.response['error']}")
        return []

# Create Zoom 6.0 persistent breakout room
def create_persistent_breakout(meeting_id: str, room_name: str, members: list):
    try:
        response = zoom_client.meeting.breakout_room.create(
            meeting_id=meeting_id,
            data={
                "breakout_rooms": [{
                    "name": room_name,
                    "participants": [{"email": f"{m}@stripe.com"} for m in members],
                    "persistent": True,  # Zoom 6.0 only feature
                    "auto_join": True
                }]
            }
        )
        return response["breakout_room_id"]
    except ZoomException as e:
        logger.error(f"Zoom error: {e.error_message}")
        return None

# Calculate Pearson correlation between attendance and velocity
import numpy as np

def calculate_correlation(sprints: list):
    attendance = [s.attendance_rate for s in sprints]
    velocity = [s.velocity for s in sprints]
    if len(attendance) < 2:
        return 0.0
    correlation = np.corrcoef(attendance, velocity)[0, 1]
    return round(correlation, 2)