diff --git a/docker-compose.yml b/docker-compose.yml
index b995946..f4d1647 100644
--- a/docker-compose.yml
+++ b/docker-compose.yml
@@ -9,6 +9,7 @@ services:
- TZ=Europe/London
volumes:
- ./storage/:/usr/src/app/zwift-offline/storage
+ - ${ZWIFT_WORKOUTS_DIR:-~/Documents/Zwift/Workouts}:/root/Documents/Zwift/Workouts
ports:
- 80:80
- 443:443
diff --git a/docs/local-usage.md b/docs/local-usage.md
new file mode 100644
index 0000000..f180320
--- /dev/null
+++ b/docs/local-usage.md
@@ -0,0 +1,110 @@
+# zoffline 本地使用说明
+
+## 当前已完成能力
+
+1. Intervals.icu
+- 可在启动 Zwift 前自动拉取当天 workout
+- 骑完保存后可自动上传活动回 Intervals.icu
+- 若活动匹配当天同步的 workout，会自动带 paired_event_id 并 mark-done
+
+2. Strava
+- 已支持 OAuth 授权
+- 骑完保存后可自动上传 FIT 到 Strava
+
+3. TrainingPeaks
+- 已支持手工桥接模式
+- 将 TrainingPeaks 导出的 `.zwo` 文件放入本地目录后，可一键导入 Zwift custom workouts
+- 当前不支持官方 API 自动拉取/自动上传，因为需要 TrainingPeaks partner access
+
+4. Provider 互斥模式
+- Intervals.icu 和 TrainingPeaks 不会再同时出现在 customworkouts
+- 谁最后同步，谁就是当前 active provider
+
+## 启动方式
+
+推荐使用非特权端口本地运行：
+
+```bash
+cd /Users/sumulige/Documents/Antigravity/zwift-offline
+python3 -m venv .venv
+. .venv/bin/activate
+pip install -r requirements.txt
+env \
+ ZOFFLINE_CDN_PORT=18080 \
+ ZOFFLINE_TCP_PORT=13025 \
+ ZOFFLINE_UDP_PORT=13024 \
+ ZOFFLINE_API_PORT=18443 \
+ ZOFFLINE_API_USE_CERT=false \
+ ./.venv/bin/python standalone.py
+```
+
+打开页面：
+- 主页: `http://127.0.0.1:18443/user/zoffline/`
+- Settings: `http://127.0.0.1:18443/settings/zoffline/`
+- Intervals: `http://127.0.0.1:18443/intervals/zoffline/`
+- Strava: `http://127.0.0.1:18443/strava/zoffline/`
+- TrainingPeaks: `http://127.0.0.1:18443/trainingpeaks/zoffline/`
+
+## Intervals.icu 设置
+
+在 `Settings -> Intervals` 中填写：
+- Athlete ID
+- API key
+
+然后你可以：
+- 点击 `Sync today's workout` 手动同步
+- 或点击 `Start Zwift` 时自动同步
+
+同步成功后：
+- workout 会写入 `storage/
/customworkouts/`
+- metadata 会写入 provider state 文件
+
+## Strava 设置
+
+在 `Settings -> Strava` 中填写：
+- Client ID
+- Client Secret
+
+然后点击 `Authorize` 完成 OAuth。
+
+授权成功后，`storage//strava_token.txt` 会存在。
+
+之后每次活动保存时会自动上传到 Strava。
+
+## TrainingPeaks 手工桥接
+
+1. 在 TrainingPeaks 中导出 workout 为 `.zwo`
+2. 把 `.zwo` 文件放到本地某个目录，例如：
+ - `/Users/yourname/TrainingPeaksExports`
+3. 打开 `TrainingPeaks` 页面
+4. 在 `Bridge folder` 输入该目录
+5. 点击 `Save bridge folder`
+6. 点击 `Import workouts`
+
+导入后的文件会写到：
+- `storage//customworkouts/trainingpeaks-*.zwo`
+
+## Provider 切换规则
+
+- 点击 `Intervals -> Sync today's workout`
+ - active provider 切到 `intervals-icu`
+ - TrainingPeaks workouts 会被清掉
+
+- 点击 `TrainingPeaks -> Import workouts`
+ - active provider 切到 `trainingpeaks`
+ - Intervals workouts 会被清掉
+
+- 点击 `Start Zwift` 时，只会同步当前 active provider
+
+## 关键文件
+
+- Intervals provider: `intervals_workouts.py`
+- TrainingPeaks bridge/provider scaffold: `trainingpeaks_workouts.py`
+- Provider state: `workout_state.py`
+- 主服务: `zwift_offline.py`
+
+## Git 提交
+
+本次功能提交：
+- commit: `f0418ee`
+- message: `feat: add workout provider sync integrations`
diff --git a/intervals_workouts.py b/intervals_workouts.py
new file mode 100644
index 0000000..59863c7
--- /dev/null
+++ b/intervals_workouts.py
@@ -0,0 +1,135 @@
+import datetime
+import re
+from io import BytesIO
+from urllib.parse import urlencode
+
+from requests.auth import HTTPBasicAuth
+
+
+DEFAULT_BASE_URL = "https://intervals.icu/api/v1"
+
+
+def normalize_events_payload(payload):
+ if isinstance(payload, list):
+ return payload
+ if isinstance(payload, dict):
+ for key in ("events", "data", "items"):
+ value = payload.get(key)
+ if isinstance(value, list):
+ return value
+ return []
+
+
+def parse_datetime(value):
+ if not value:
+ return None
+ if isinstance(value, datetime.datetime):
+ parsed = value
+ else:
+ if value.endswith("Z"):
+ value = value[:-1] + "+00:00"
+ try:
+ parsed = datetime.datetime.fromisoformat(value)
+ except ValueError:
+ return None
+ if parsed.tzinfo is None:
+ parsed = parsed.replace(tzinfo=datetime.timezone.utc)
+ return parsed
+
+
+def parse_event_datetime(event):
+ value = event.get("start_date_local") or event.get("start_date") or event.get("date")
+ return parse_datetime(value)
+
+
+def choose_workout_event(events, now=None):
+ if not events:
+ return None
+ now = now or datetime.datetime.now(datetime.timezone.utc)
+ ordered = sorted(events, key=lambda event: parse_event_datetime(event) or datetime.datetime.max.replace(tzinfo=datetime.timezone.utc))
+ future = [event for event in ordered if (parse_event_datetime(event) or now) >= now]
+ if future:
+ return future[0]
+ return ordered[-1]
+
+
+def slugify_filename(value):
+ value = (value or "").strip().lower()
+ value = re.sub(r"[^a-z0-9]+", "-", value)
+ return value.strip("-")
+
+
+def build_workout_filename(event):
+ event_id = event.get("id", "workout")
+ name = slugify_filename(event.get("name") or f"workout-{event_id}")
+ if not name:
+ name = f"workout-{event_id}"
+ return f"intervals-icu-{event_id}-{name}.zwo"
+
+
+def build_activity_upload_url(base_url, athlete_id, activity_name, paired_event_id=None):
+ params = {"name": activity_name}
+ if paired_event_id:
+ params["paired_event_id"] = paired_event_id
+ return f"{base_url}/athlete/{athlete_id}/activities?{urlencode(params)}"
+
+
+def activity_matches_workout(activity, workout_metadata):
+ if not workout_metadata:
+ return False
+ event_dt = parse_datetime(workout_metadata.get("start_date_local") or workout_metadata.get("start_date") or workout_metadata.get("synced_for_date"))
+ activity_dt = parse_datetime(getattr(activity, "start_date", None) or getattr(activity, "date", None))
+ if not event_dt or not activity_dt:
+ return False
+ return event_dt.date() == activity_dt.date()
+
+
+def upload_activity(athlete_id, api_key, activity, workout_metadata=None, session=None, base_url=DEFAULT_BASE_URL):
+ session = session or __import__("requests")
+ paired_event_id = None
+ if activity_matches_workout(activity, workout_metadata):
+ paired_event_id = workout_metadata.get("event_id") or workout_metadata.get("id")
+ upload_url = build_activity_upload_url(base_url, athlete_id, activity.name, paired_event_id=paired_event_id)
+ upload_response = session.post(upload_url, files={"file": BytesIO(activity.fit)}, auth=HTTPBasicAuth("API_KEY", api_key), timeout=30)
+ upload_response.raise_for_status()
+ if paired_event_id:
+ mark_done_url = f"{base_url}/athlete/{athlete_id}/events/{paired_event_id}/mark-done"
+ mark_done_response = session.post(mark_done_url, auth=HTTPBasicAuth("API_KEY", api_key), timeout=30)
+ mark_done_response.raise_for_status()
+ return {
+ "status": "uploaded",
+ "paired": bool(paired_event_id),
+ "paired_event_id": paired_event_id,
+ }
+
+
+def sync_workout(athlete_id, api_key, store_workout, today=None, now=None, session=None, base_url=DEFAULT_BASE_URL):
+ today = today or datetime.date.today()
+ now = now or datetime.datetime.now(datetime.timezone.utc)
+ session = session or __import__("requests")
+
+ query = urlencode({
+ "oldest": today.isoformat(),
+ "newest": today.isoformat(),
+ "category": "WORKOUT",
+ })
+ events_url = f"{base_url}/athlete/{athlete_id}/events?{query}"
+ events_response = session.get(events_url, auth=HTTPBasicAuth("API_KEY", api_key), timeout=30)
+ events_response.raise_for_status()
+ events = normalize_events_payload(events_response.json())
+ event = choose_workout_event(events, now=now)
+ if not event:
+ return {"status": "no_workout", "message": f"No Intervals.icu workout found for {today.isoformat()}"}
+
+ workout_url = f"{base_url}/athlete/{athlete_id}/events/{event['id']}/download.zwo"
+ workout_response = session.get(workout_url, auth=HTTPBasicAuth("API_KEY", api_key), timeout=30)
+ workout_response.raise_for_status()
+
+ filename = build_workout_filename(event)
+ store_workout(filename, workout_response.content, event)
+ return {
+ "status": "synced",
+ "event": event,
+ "filename": filename,
+ "message": f"Synced Intervals.icu workout: {event.get('name', filename)}",
+ }
diff --git a/local_zwift_workouts.py b/local_zwift_workouts.py
new file mode 100644
index 0000000..5b2cd76
--- /dev/null
+++ b/local_zwift_workouts.py
@@ -0,0 +1,168 @@
+import hashlib
+import os
+import xml.etree.ElementTree as ET
+
+
+MANIFEST_FILENAME = 'workouts.files'
+
+
+def workouts_dir(root_dir, player_id):
+ return os.path.join(root_dir, str(player_id))
+
+
+def manifest_file(root_dir, player_id):
+ return os.path.join(workouts_dir(root_dir, player_id), MANIFEST_FILENAME)
+
+
+def parse_int(value):
+ try:
+ return int((value or '0').strip() or '0')
+ except ValueError:
+ return 0
+
+
+def file_checksum(content):
+ return (-sum(content)) % 256
+
+
+def file_guid(filename):
+ digest = hashlib.sha1(filename.encode('utf-8')).digest()
+ return (int.from_bytes(digest[:4], 'big') & 0x7fffffff) or 1
+
+
+def load_manifest(root_dir, player_id):
+ path = manifest_file(root_dir, player_id)
+ if not os.path.exists(path):
+ return []
+ try:
+ root = ET.parse(path).getroot()
+ except ET.ParseError:
+ return []
+ entries = []
+ for node in root.findall('custom_file'):
+ name = (node.findtext('name') or '').strip()
+ if not name:
+ continue
+ entries.append({
+ 'name': name,
+ 'time': parse_int(node.findtext('time')),
+ 'guid': parse_int(node.findtext('guid')),
+ 'checksum': parse_int(node.findtext('checksum')),
+ 'deleted': (node.findtext('deleted') or 'false').strip().lower() == 'true',
+ })
+ return entries
+
+
+def save_manifest(root_dir, player_id, entries):
+ directory = workouts_dir(root_dir, player_id)
+ os.makedirs(directory, exist_ok=True)
+ root = ET.Element('custom_file_directory')
+ for entry in sorted(entries, key=lambda item: item['name'].lower()):
+ node = ET.SubElement(root, 'custom_file')
+ ET.SubElement(node, 'name').text = entry['name']
+ ET.SubElement(node, 'time').text = str(int(entry['time']))
+ ET.SubElement(node, 'guid').text = str(int(entry['guid']))
+ ET.SubElement(node, 'checksum').text = str(int(entry['checksum']))
+ ET.SubElement(node, 'deleted').text = 'true' if entry.get('deleted') else 'false'
+ ET.SubElement(root, 'deleted_files')
+ tree = ET.ElementTree(root)
+ ET.indent(tree, space=' ')
+ path = manifest_file(root_dir, player_id)
+ tree.write(path, encoding='utf-8', xml_declaration=False)
+ with open(path, 'a', encoding='utf-8') as fd:
+ fd.write('\n')
+ return path
+
+
+def upsert_manifest_entry(root_dir, player_id, filename, content, timestamp=None):
+ entries = [entry for entry in load_manifest(root_dir, player_id) if entry['name'] != filename]
+ timestamp = int(timestamp if timestamp is not None else os.path.getmtime(os.path.join(workouts_dir(root_dir, player_id), filename)))
+ entry = {
+ 'name': filename,
+ 'time': timestamp,
+ 'guid': file_guid(filename),
+ 'checksum': file_checksum(content),
+ 'deleted': False,
+ }
+ entries.append(entry)
+ save_manifest(root_dir, player_id, entries)
+ return entry
+
+
+def remove_manifest_entries(root_dir, player_id, names):
+ names = set(names)
+ if not names:
+ return 0
+ existing = load_manifest(root_dir, player_id)
+ remaining = [entry for entry in existing if entry['name'] not in names]
+ removed = len(existing) - len(remaining)
+ if removed or os.path.exists(manifest_file(root_dir, player_id)):
+ save_manifest(root_dir, player_id, remaining)
+ return removed
+
+
+def export_workout(root_dir, player_id, filename, content):
+ directory = workouts_dir(root_dir, player_id)
+ os.makedirs(directory, exist_ok=True)
+ path = os.path.join(directory, filename)
+ with open(path, 'wb') as fd:
+ fd.write(content)
+ timestamp = int(os.path.getmtime(path))
+ manifest_entry = upsert_manifest_entry(root_dir, player_id, filename, content, timestamp=timestamp)
+ return {
+ 'path': path,
+ 'manifest_path': manifest_file(root_dir, player_id),
+ 'manifest_entry': manifest_entry,
+ }
+
+
+def remove_prefixed_workouts(root_dir, player_id, prefixes):
+ directory = workouts_dir(root_dir, player_id)
+ if not os.path.isdir(directory):
+ return {'removed_files': 0, 'removed_manifest_entries': 0}
+ names_to_remove = []
+ removed_files = 0
+ for name in os.listdir(directory):
+ if name == MANIFEST_FILENAME or not any(name.startswith(prefix) for prefix in prefixes):
+ continue
+ path = os.path.join(directory, name)
+ if not os.path.isfile(path):
+ continue
+ os.remove(path)
+ names_to_remove.append(name)
+ removed_files += 1
+ removed_manifest_entries = remove_manifest_entries(root_dir, player_id, names_to_remove)
+ return {
+ 'removed_files': removed_files,
+ 'removed_manifest_entries': removed_manifest_entries,
+ }
+
+
+def health_report(root_dir, player_id, filename):
+ directory = workouts_dir(root_dir, player_id)
+ path = os.path.join(directory, filename)
+ entries = {entry['name']: entry for entry in load_manifest(root_dir, player_id)}
+ entry = entries.get(filename)
+ report = {
+ 'directory': directory,
+ 'path': path,
+ 'manifest_path': manifest_file(root_dir, player_id),
+ 'file_exists': os.path.exists(path),
+ 'manifest_entry_exists': entry is not None,
+ 'manifest_entry': entry,
+ }
+ if report['file_exists']:
+ with open(path, 'rb') as fd:
+ content = fd.read()
+ report['expected_checksum'] = file_checksum(content)
+ report['expected_guid'] = file_guid(filename)
+ else:
+ report['expected_checksum'] = None
+ report['expected_guid'] = file_guid(filename)
+ report['healthy'] = (
+ report['file_exists']
+ and report['manifest_entry_exists']
+ and entry.get('checksum') == report['expected_checksum']
+ and int(entry.get('guid') or 0) > 0
+ ) if entry else False
+ return report
diff --git a/tests/__init__.py b/tests/__init__.py
new file mode 100644
index 0000000..e69de29
diff --git a/tests/test_intervals_workouts.py b/tests/test_intervals_workouts.py
new file mode 100644
index 0000000..2a40a9b
--- /dev/null
+++ b/tests/test_intervals_workouts.py
@@ -0,0 +1,152 @@
+import datetime
+import unittest
+from types import SimpleNamespace
+
+from intervals_workouts import sync_workout, upload_activity
+
+
+class FakeResponse:
+ def __init__(self, payload=None, content=b"", status_code=200):
+ self._payload = payload
+ self.content = content
+ self.status_code = status_code
+
+ def json(self):
+ return self._payload
+
+ def raise_for_status(self):
+ if self.status_code >= 400:
+ raise RuntimeError(f"HTTP {self.status_code}")
+
+
+class FakeSession:
+ def __init__(self, responses=None):
+ self.responses = list(responses or [])
+ self.calls = []
+
+ def _pop(self):
+ return self.responses.pop(0)
+
+ def get(self, url, **kwargs):
+ self.calls.append(("GET", url, kwargs))
+ return self._pop()
+
+ def post(self, url, **kwargs):
+ self.calls.append(("POST", url, kwargs))
+ return self._pop()
+
+
+class SyncWorkoutTests(unittest.TestCase):
+ def test_sync_workout_downloads_next_planned_workout_and_saves_it(self):
+ now = datetime.datetime(2026, 4, 22, 10, 30, tzinfo=datetime.timezone.utc)
+ session = FakeSession([
+ FakeResponse(payload={
+ "events": [
+ {
+ "id": 41,
+ "name": "Morning opener",
+ "start_date_local": "2026-04-22T08:00:00+00:00",
+ },
+ {
+ "id": 42,
+ "name": "Threshold Session",
+ "start_date_local": "2026-04-22T18:00:00+00:00",
+ },
+ ]
+ }),
+ FakeResponse(content=b"'
+ ''
+ 'intervals-icu-test.zwo '
+ 'bad '
+ 'also-bad '
+ 'false '
+ ' '
+ ' '
+ )
+
+ entries = load_manifest(tmp, 1)
+ self.assertEqual(entries[0]['time'], 0)
+ self.assertEqual(entries[0]['guid'], 0)
+ self.assertEqual(entries[0]['checksum'], 0)
+
+ def test_remove_prefixed_workouts_removes_matching_files_and_manifest_entries(self):
+ with tempfile.TemporaryDirectory() as tmp:
+ export_workout(tmp, 1, 'intervals-icu-a.zwo', b'a')
+ export_workout(tmp, 1, 'trainingpeaks-b.zwo', b'b')
+ export_workout(tmp, 1, 'custom-other.zwo', b'c')
+
+ removed = remove_prefixed_workouts(tmp, 1, {'intervals-icu-'})
+
+ self.assertEqual(removed['removed_files'], 1)
+ self.assertFalse(os.path.exists(os.path.join(tmp, '1', 'intervals-icu-a.zwo')))
+ self.assertTrue(os.path.exists(os.path.join(tmp, '1', 'trainingpeaks-b.zwo')))
+ self.assertTrue(os.path.exists(os.path.join(tmp, '1', 'custom-other.zwo')))
+ names = {entry['name'] for entry in load_manifest(tmp, 1)}
+ self.assertEqual(names, {'trainingpeaks-b.zwo', 'custom-other.zwo'})
+
+ def test_health_report_detects_consistent_export(self):
+ with tempfile.TemporaryDirectory() as tmp:
+ export_workout(tmp, 1, 'intervals-icu-a.zwo', b'a')
+ report = health_report(tmp, 1, 'intervals-icu-a.zwo')
+ self.assertTrue(report['healthy'])
+ self.assertTrue(report['manifest_entry_exists'])
+ self.assertEqual(report['manifest_entry']['guid'], file_guid('intervals-icu-a.zwo'))
+
+ def test_health_report_detects_manifest_mismatch(self):
+ with tempfile.TemporaryDirectory() as tmp:
+ export_workout(tmp, 1, 'intervals-icu-a.zwo', b'a')
+ save_manifest(tmp, 1, [{
+ 'name': 'intervals-icu-a.zwo',
+ 'time': 123,
+ 'guid': 999,
+ 'checksum': 42,
+ 'deleted': False,
+ }])
+ report = health_report(tmp, 1, 'intervals-icu-a.zwo')
+ self.assertFalse(report['healthy'])
+ self.assertTrue(os.path.exists(manifest_file(tmp, 1)))
+
+
+if __name__ == '__main__':
+ unittest.main()
diff --git a/tests/test_trainingpeaks_workouts.py b/tests/test_trainingpeaks_workouts.py
new file mode 100644
index 0000000..32c05bf
--- /dev/null
+++ b/tests/test_trainingpeaks_workouts.py
@@ -0,0 +1,55 @@
+import os
+import tempfile
+import unittest
+from types import SimpleNamespace
+
+from trainingpeaks_workouts import (
+ build_workout_filename,
+ sync_exported_workouts,
+ sync_workout,
+ upload_activity,
+)
+
+
+class TrainingPeaksWorkoutTests(unittest.TestCase):
+ def test_build_workout_filename_uses_trainingpeaks_prefix(self):
+ workout = {'id': 51, 'title': 'VO2 Max Builder'}
+ self.assertEqual(build_workout_filename(workout), 'trainingpeaks-51-vo2-max-builder.zwo')
+
+ def test_sync_exported_workouts_imports_zwo_files_only(self):
+ with tempfile.TemporaryDirectory() as tmp:
+ with open(os.path.join(tmp, 'VO2 Builder.zwo'), 'wb') as fd:
+ fd.write(b'/", methods=["GET", "POST"])
@login_required
def profile(username):
@@ -953,18 +1197,72 @@ def intervals(username):
if request.method == "POST":
if request.form['athlete_id'] == "" or request.form['api_key'] == "":
flash("Intervals.icu credentials can't be empty.")
- return render_template("intervals.html", username=current_user.username)
+ return render_template(
+ "intervals.html",
+ username=current_user.username,
+ sync_status=current_workout_sync_status(current_user.player_id, 'intervals-icu'),
+ active_provider=resolve_workout_provider_for_player(current_user.player_id),
+ )
encrypt_credentials(file, (request.form['athlete_id'], request.form['api_key']))
return redirect(url_for('settings', username=current_user.username))
cred = decrypt_credentials(file)
- return render_template("intervals.html", username=current_user.username, aid=cred[0], akey=cred[1])
+ return render_template(
+ "intervals.html",
+ username=current_user.username,
+ aid=cred[0],
+ akey=cred[1],
+ sync_status=current_workout_sync_status(current_user.player_id, 'intervals-icu'),
+ active_provider=resolve_workout_provider_for_player(current_user.player_id),
+ )
+
+
+@app.route("/intervals//sync", methods=["GET"])
+@login_required
+def intervals_sync(username):
+ result = sync_intervals_workout_for_player(current_user.player_id)
+ flash(result['message'])
+ return redirect(url_for('intervals', username=current_user.username))
+
+
+@app.route("/trainingpeaks//", methods=["GET", "POST"])
+@login_required
+def trainingpeaks(username):
+ if request.method == 'POST':
+ save_trainingpeaks_bridge_folder(current_user.player_id, request.form['bridge_folder'])
+ flash('TrainingPeaks bridge folder saved.')
+ return redirect(url_for('trainingpeaks', username=current_user.username))
+ bridge_folder = load_trainingpeaks_bridge_folder(current_user.player_id)
+ return render_template(
+ "trainingpeaks.html",
+ username=current_user.username,
+ message=trainingpeaks_workouts.PARTNER_ACCESS_MESSAGE,
+ bridge_folder=bridge_folder,
+ )
+
+
+@app.route("/trainingpeaks//sync", methods=["GET"])
+@login_required
+def trainingpeaks_sync(username):
+ result = sync_trainingpeaks_workout_for_player(current_user.player_id)
+ flash(result['message'])
+ return redirect(url_for('trainingpeaks', username=current_user.username))
@app.route("/user//")
@login_required
def user_home(username):
- return render_template("user_home.html", username=current_user.username, enable_ghosts=bool(current_user.enable_ghosts), climbs=CLIMBS,
- online=get_online(), is_admin=current_user.is_admin, restarting=restarting, restarting_in_minutes=restarting_in_minutes)
+ return render_template(
+ "user_home.html",
+ username=current_user.username,
+ enable_ghosts=bool(current_user.enable_ghosts),
+ climbs=CLIMBS,
+ online=get_online(),
+ is_admin=current_user.is_admin,
+ restarting=restarting,
+ restarting_in_minutes=restarting_in_minutes,
+ active_workout_provider=resolve_workout_provider_for_player(current_user.player_id),
+ workout_sync_status=current_workout_sync_status(current_user.player_id),
+ )
def enqueue_player_update(player_id, wa_bytes):
if not player_id in player_update_queue:
@@ -2377,10 +2675,11 @@ def intervals_upload(player_id, activity):
logger.info("intervals_credentials.bin missing, skip Intervals.icu activity update")
return
athlete_id, api_key = decrypt_credentials(intervals_credentials)
+ workout_metadata = load_intervals_workout_metadata(player_id)
try:
- from requests.auth import HTTPBasicAuth
- url = 'https://intervals.icu/api/v1/athlete/%s/activities?name=%s' % (athlete_id, activity.name)
- requests.post(url, files = {"file": BytesIO(activity.fit)}, auth = HTTPBasicAuth('API_KEY', api_key))
+ result = intervals_workouts.upload_activity(athlete_id, api_key, activity, workout_metadata=workout_metadata)
+ if result.get('paired'):
+ clear_intervals_workout_metadata(player_id)
except Exception as exc:
logger.warning("Intervals.icu upload failed. No internet? %s" % repr(exc))
@@ -4446,6 +4745,14 @@ def start_zwift():
selected_climb = request.form['climb']
if selected_climb != 'CALENDAR':
climb_override[request.remote_addr] = selected_climb
+ provider = resolve_workout_provider_for_player(current_user.player_id)
+ sync_result = None
+ if provider == 'intervals-icu':
+ sync_result = sync_intervals_workout_for_player(current_user.player_id)
+ elif provider == 'trainingpeaks':
+ sync_result = sync_trainingpeaks_workout_for_player(current_user.player_id)
+ if sync_result and sync_result['status'] in ('synced', 'no_workout', 'error'):
+ flash(sync_result['message'])
return redirect("/ride", 302)