How to Integrate Replit with Doodle

1import os
2import requests
3from datetime import datetime, timedelta
4from typing import Optional
5
6API_KEY = os.environ["DOODLE_API_KEY"]
7BASE_URL = os.environ.get("DOODLE_BASE_URL", "https://api.doodle.com")
8
9HEADERS = {
10    "Authorization": f"Bearer {API_KEY}",
11    "Content-Type": "application/json",
12    "Accept": "application/json"
13}
14
15def create_poll(
16    title: str,
17    description: str,
18    time_slots: list,
19    organizer_name: str,
20    organizer_email: str
21) -> dict:
22    """
23    Create a Doodle poll.
24    time_slots: list of (start_datetime, duration_minutes) tuples
25    Returns poll data including the poll URL for sharing.
26    """
27    # Convert datetime objects to millisecond timestamps
28    options = []
29    for slot_start, duration_minutes in time_slots:
30        start_ms = int(slot_start.timestamp() * 1000)
31        end_ms = start_ms + (duration_minutes * 60 * 1000)
32        options.append({"start": start_ms, "end": end_ms})
33
34    payload = {
35        "title": title,
36        "description": description,
37        "initiator": {
38            "name": organizer_name,
39            "email": organizer_email
40        },
41        "options": options,
42        "settings": {
43            "ifNeedBe": True,    # Allow 'if need be' responses
44            "hidden": False,     # Show all participant names to voters
45            "notifyParticipants": True
46        }
47    }
48
49    response = requests.post(
50        f"{BASE_URL}/v2/polls",
51        json=payload,
52        headers=HEADERS
53    )
54    response.raise_for_status()
55    return response.json()
56
57def get_poll(poll_id: str) -> dict:
58    """Retrieve poll details, options, and all participant votes."""
59    response = requests.get(
60        f"{BASE_URL}/v2/polls/{poll_id}",
61        headers=HEADERS
62    )
63    response.raise_for_status()
64    return response.json()
65
66def find_best_time(poll_data: dict) -> Optional[dict]:
67    """
68    Analyze poll results and return the option with most 'yes' votes.
69    Returns the winning option dict or None if no votes yet.
70    """
71    options = poll_data.get("options", [])
72    participants = poll_data.get("participants", [])
73
74    if not participants:
75        return None
76
77    vote_counts = {i: 0 for i in range(len(options))}
78    for participant in participants:
79        for vote_index, vote in enumerate(participant.get("preferences", [])):
80            if vote == 1:  # 1 = yes, 0 = no, -1 = if need be
81                vote_counts[vote_index] = vote_counts.get(vote_index, 0) + 1
82
83    best_index = max(vote_counts, key=vote_counts.get)
84    if vote_counts[best_index] == 0:
85        return None
86
87    best_option = options[best_index]
88    best_option["vote_count"] = vote_counts[best_index]
89    return best_option
90
91def delete_poll(poll_id: str) -> None:
92    """Delete a poll (organizer only)."""
93    response = requests.delete(
94        f"{BASE_URL}/v2/polls/{poll_id}",
95        headers=HEADERS
96    )
97    response.raise_for_status()
98
99# Example usage
100if __name__ == "__main__":
101    now = datetime.now()
102    # Propose next Monday and Tuesday at 10am and 2pm
103    days_until_monday = (7 - now.weekday()) % 7 or 7
104    monday = now + timedelta(days=days_until_monday)
105
106    slots = [
107        (monday.replace(hour=10, minute=0, second=0), 60),
108        (monday.replace(hour=14, minute=0, second=0), 60),
109        ((monday + timedelta(days=1)).replace(hour=10, minute=0, second=0), 60),
110    ]
111
112    poll = create_poll(
113        title="Q2 Planning Meeting",
114        description="Please vote for your preferred time for our quarterly planning session.",
115        time_slots=slots,
116        organizer_name="Alex Smith",
117        organizer_email="alex@example.com"
118    )
119    print(f"Poll created: {poll.get('url')}")
120    print(f"Poll ID: {poll.get('id')}")

1const express = require('express');
2const axios = require('axios');
3
4const app = express();
5app.use(express.json());
6
7const API_KEY = process.env.DOODLE_API_KEY;
8const BASE_URL = process.env.DOODLE_BASE_URL || 'https://api.doodle.com';
9
10const doodleHeaders = {
11  'Authorization': `Bearer ${API_KEY}`,
12  'Content-Type': 'application/json',
13  'Accept': 'application/json'
14};
15
16// POST /poll — create a new scheduling poll
17app.post('/poll', async (req, res) => {
18  const { title, description, timeSlots, organizerName, organizerEmail } = req.body;
19
20  if (!title || !timeSlots || timeSlots.length === 0) {
21    return res.status(400).json({ error: 'title and timeSlots are required' });
22  }
23
24  // timeSlots: [{startIso: '2026-04-07T10:00:00', durationMinutes: 60}, ...]
25  const options = timeSlots.map(slot => {
26    const startMs = new Date(slot.startIso).getTime();
27    const endMs = startMs + slot.durationMinutes * 60 * 1000;
28    return { start: startMs, end: endMs };
29  });
30
31  try {
32    const response = await axios.post(`${BASE_URL}/v2/polls`, {
33      title,
34      description: description || '',
35      initiator: { name: organizerName, email: organizerEmail },
36      options,
37      settings: { ifNeedBe: true, hidden: false, notifyParticipants: true }
38    }, { headers: doodleHeaders });
39
40    res.json({
41      pollId: response.data.id,
42      pollUrl: response.data.url,
43      message: 'Poll created successfully'
44    });
45  } catch (error) {
46    console.error('Doodle API error:', error.response?.data || error.message);
47    res.status(500).json({ error: 'Failed to create poll' });
48  }
49});
50
51// GET /poll/:id — get poll results and best time
52app.get('/poll/:id', async (req, res) => {
53  const { id } = req.params;
54  try {
55    const response = await axios.get(`${BASE_URL}/v2/polls/${id}`, {
56      headers: doodleHeaders
57    });
58    const poll = response.data;
59    const participants = poll.participants || [];
60    const options = poll.options || [];
61
62    // Count votes per option
63    const voteCounts = new Array(options.length).fill(0);
64    participants.forEach(p => {
65      (p.preferences || []).forEach((vote, i) => {
66        if (vote === 1) voteCounts[i]++;
67      });
68    });
69
70    const bestIndex = voteCounts.indexOf(Math.max(...voteCounts));
71    const bestOption = voteCounts[bestIndex] > 0 ? {
72      ...options[bestIndex],
73      voteCount: voteCounts[bestIndex]
74    } : null;
75
76    res.json({
77      title: poll.title,
78      participantCount: participants.length,
79      bestOption,
80      allOptions: options.map((opt, i) => ({ ...opt, voteCount: voteCounts[i] }))
81    });
82  } catch (error) {
83    console.error('Doodle API error:', error.response?.data || error.message);
84    res.status(500).json({ error: 'Failed to retrieve poll' });
85  }
86});
87
88app.listen(3000, '0.0.0.0', () => {
89  console.log('Doodle integration server running on port 3000');
90});