Browse the data

1from fastapi import FastAPI, HTTPException, Header
2from datetime import datetime, date, time, timedelta
3import secrets
4import hashlib
5 
6app = FastAPI()
7 
8# In-memory stores
9users = {}
10tokens = {}
11slots = {}
12bookings = {}
13slot_id_counter = 1
14booking_id_counter = 1
15 
16# Predefined time slots (9:00 AM to 5:00 PM, 30 min intervals)
17def generate_slots_for_date(target_date):
18    slots_list = []
19    start_time = time(9, 0)
20    end_time = time(17, 0)
21    current = datetime.combine(target_date, start_time)
22    end = datetime.combine(target_date, end_time)
23    while current < end:
24        slot_start = current
25        slot_end = current + timedelta(minutes=30)
26        slots_list.append({
27            "start": slot_start.isoformat(),
28            "end": slot_end.isoformat()
29        })
30        current = slot_end
31    return slots_list
32 
33def get_current_user(authorization: str = Header(None)):
34    if not authorization:
35        raise HTTPException(status_code=401, detail="Missing authorization header")
36    token = authorization.replace("Bearer ", "")
37    if token not in tokens:
38        raise HTTPException(status_code=401, detail="Invalid token")
39    return tokens[token]
40 
41# Auth
42@app.post("/signup")
43def signup(username: str, password: str):
44    if username in users:
45        raise HTTPException(status_code=400, detail="User already exists")
46    users[username] = hashlib.sha256(password.encode()).hexdigest()
47    return {"message": "User created"}
48 
49@app.post("/login")
50def login(username: str, password: str):
51    if username not in users or users[username] != hashlib.sha256(password.encode()).hexdigest():
52        raise HTTPException(status_code=401, detail="Invalid credentials")
53    token = secrets.token_hex(16)
54    tokens[token] = username
55    return {"token": token}
56 
57# Slots
58@app.get("/slots")
59def get_slots(date_str: str, duration_minutes: int = 30, authorization: str = Header(None)):
60    user = get_current_user(authorization)
61    try:
62        target_date = date.fromisoformat(date_str)
63    except:
64        raise HTTPException(status_code=400, detail="Invalid date format (YYYY-MM-DD)")
65    
66    all_slots = generate_slots_for_date(target_date)
67    available = []
68    for slot in all_slots:
69        slot_start = datetime.fromisoformat(slot["start"])
70        slot_end = datetime.fromisoformat(slot["end"])
71        # Check if slot is already booked
72        is_booked = False
73        for bid, booking in bookings.items():
74            if booking["date"] == date_str and booking["start"] == slot["start"]:
75                is_booked = True
76                break
77        if not is_booked:
78            available.append(slot)
79    return {"date": date_str, "duration_minutes": duration_minutes, "slots": available}
80 
81@app.post("/slots/book")
82def book_slot(date_str: str, start_time_str: str, authorization: str = Header(None)):
83    global booking_id_counter
84    user = get_current_user(authorization)
85    try:
86        target_date = date.fromisoformat(date_str)
87        start_dt = datetime.fromisoformat(start_time_str)
88        if start_dt.date() != target_date:
89            raise HTTPException(status_code=400, detail="Start time must match date")
90    except:
91        raise HTTPException(status_code=400, detail="Invalid date or time format")
92    
93    # Check if slot already booked
94    for bid, booking in bookings.items():
95        if booking["date"] == date_str and booking["start"] == start_time_str:
96            raise HTTPException(status_code=409, detail="Slot already booked")
97    
98    # Check if slot is within business hours
99    valid_slots = generate_slots_for_date(target_date)
100    valid = False
101    for slot in valid_slots:
102        if slot["start"] == start_time_str:
103            valid = True
104            break
105    if not valid:
106        raise HTTPException(status_code=400, detail="Invalid slot time")
107    
108    booking_id = booking_id_counter
109    booking_id_counter += 1
110    bookings[booking_id] = {
111        "id": booking_id,
112        "user": user,
113        "date": date_str,
114        "start": start_time_str,
115        "end": (datetime.fromisoformat(start_time_str) + timedelta(minutes=30)).isoformat()
116    }
117    confirmation_code = secrets.token_hex(8).upper()
118    return {"confirmation_code": confirmation_code, "booking_id": booking_id}
119 
120# Generic resource endpoints
121@app.get("/{resource}/{resource_id}")
122def get_resource(resource: str, resource_id: int, authorization: str = Header(None)):
123    user = get_current_user(authorization)
124    if resource == "bookings":
125        if resource_id not in bookings:
126            raise HTTPException(status_code=404, detail="Not found")
127        return bookings[resource_id]
128    elif resource == "slots":
129        # Slots are generated on the fly, not stored by ID
130        raise HTTPException(status_code=400, detail="Use GET /slots?date=...")
131    else:
132        raise HTTPException(status_code=400, detail="Unknown resource")
133 
134@app.post("/{resource}")
135def create_resource(resource: str, data: dict, authorization: str = Header(None)):
136    user = get_current_user(authorization)
137    if resource == "bookings":
138        # Use the dedicated booking endpoint
139        raise HTTPException(status_code=400, detail="Use POST /slots/book")
140    elif resource == "slots":
141        raise HTTPException(status_code=400, detail="Slots are generated, not created")
142    else:
143        raise HTTPException(status_code=400, detail="Unknown resource")

1fastapi
2uvicorn