Add interactive platform prototype

- Complete clickable mockup showing full platform UI/UX
- Dashboard with real-time metrics and charts
- Data management interface with API connectors
- Strategy engine configuration and backtesting
- Risk management controls and monitoring
- Navigation between all platform sections
- Dark theme with professional trading aesthetic
- Responsive design for mobile/desktop
- Interactive charts using Chart.js with mock data
- Reusable HTML/CSS/JavaScript structure
- Updated README with prototype documentation
This commit is contained in:
2026-02-04 15:59:22 +08:00
parent 6e86da6733
commit 994fb0fab5
6 changed files with 2219 additions and 0 deletions

346
prototype/js/app.js vendored Normal file
View File

@@ -0,0 +1,346 @@
/*
* Quantitative Trading Platform - Interactive Mockup
* Main JavaScript for navigation and interactivity
*/
// Global state
const AppState = {
currentSection: 'dashboard',
charts: {},
mockData: {}
};
// Initialize the application
function initApp() {
console.log('Quantitative Trading Platform Mockup Initialized');
// Set up navigation
setupNavigation();
// Load mock data
loadMockData();
// Initialize charts
initCharts();
// Show default section
showSection('dashboard');
// Set up event listeners for interactive elements
setupEventListeners();
}
// Set up sidebar navigation
function setupNavigation() {
const navLinks = document.querySelectorAll('.nav-link[data-section]');
navLinks.forEach(link => {
link.addEventListener('click', function(e) {
e.preventDefault();
const section = this.getAttribute('data-section');
showSection(section);
// Update active state
navLinks.forEach(l => l.classList.remove('active'));
this.classList.add('active');
});
});
}
// Show a specific section
function showSection(sectionId) {
// Hide all sections
const sections = document.querySelectorAll('.section-content');
sections.forEach(section => {
section.classList.add('d-none');
});
// Show the selected section
const targetSection = document.getElementById(`${sectionId}-section`);
if (targetSection) {
targetSection.classList.remove('d-none');
AppState.currentSection = sectionId;
// Update page title
const sectionTitle = targetSection.querySelector('h1, h2')?.textContent || 'Quantitative Trading Platform';
document.title = `${sectionTitle} - Mockup`;
// Refresh charts for the section if needed
refreshSectionCharts(sectionId);
}
}
// Refresh charts for a specific section
function refreshSectionCharts(sectionId) {
switch(sectionId) {
case 'dashboard':
if (AppState.charts.portfolioChart) {
updatePortfolioChart();
}
break;
case 'data-management':
if (AppState.charts.dataQualityChart) {
updateDataQualityChart();
}
break;
case 'strategy-engine':
if (AppState.charts.backtestChart) {
updateBacktestChart();
}
break;
case 'risk-management':
if (AppState.charts.riskChart) {
updateRiskChart();
}
break;
}
}
// Set up event listeners for buttons and interactive elements
function setupEventListeners() {
// Refresh buttons
const refreshButtons = document.querySelectorAll('button:contains("Refresh"), .btn-refresh');
refreshButtons.forEach(btn => {
btn.addEventListener('click', function() {
const section = AppState.currentSection;
refreshSectionCharts(section);
// Show toast notification
showToast('Data refreshed', 'success');
});
});
// Form submissions
const forms = document.querySelectorAll('form');
forms.forEach(form => {
form.addEventListener('submit', function(e) {
e.preventDefault();
showToast('Settings saved successfully', 'success');
});
});
// Toggle buttons
const toggleButtons = document.querySelectorAll('.btn[data-toggle]');
toggleButtons.forEach(btn => {
btn.addEventListener('click', function() {
const target = this.getAttribute('data-toggle');
const state = this.getAttribute('data-state');
if (target && state) {
// Toggle state
const newState = state === 'on' ? 'off' : 'on';
this.setAttribute('data-state', newState);
// Update button appearance
if (newState === 'on') {
this.classList.remove('btn-outline-secondary');
this.classList.add('btn-success');
this.innerHTML = '<i class="bi bi-toggle-on me-1"></i> ON';
} else {
this.classList.remove('btn-success');
this.classList.add('btn-outline-secondary');
this.innerHTML = '<i class="bi bi-toggle-off me-1"></i> OFF';
}
showToast(`Feature ${newState === 'on' ? 'enabled' : 'disabled'}`, 'info');
}
});
});
// Tab clicks
const tabs = document.querySelectorAll('[data-bs-toggle="tab"]');
tabs.forEach(tab => {
tab.addEventListener('shown.bs.tab', function() {
const tabId = this.getAttribute('data-bs-target');
console.log(`Tab activated: ${tabId}`);
});
});
// Simulate live data updates
setInterval(updateLiveData, 5000);
}
// Update live data (simulated)
function updateLiveData() {
if (AppState.currentSection === 'dashboard') {
// Update metrics with small random changes
updateDashboardMetrics();
}
}
// Update dashboard metrics with random changes
function updateDashboardMetrics() {
const metrics = {
'total-pnl': { base: 42580, range: 500 },
'max-drawdown': { base: 8420, range: 200 },
'win-rate': { base: 64.8, range: 1.5 }
};
for (const [id, config] of Object.entries(metrics)) {
const element = document.getElementById(id);
if (element) {
const current = parseFloat(element.textContent.replace(/[^\d.-]/g, ''));
const change = (Math.random() - 0.5) * 2 * config.range;
const newValue = config.base + change;
// Format based on metric type
if (id === 'total-pnl' || id === 'max-drawdown') {
element.textContent = `$${Math.round(newValue).toLocaleString()}`;
} else if (id === 'win-rate') {
element.textContent = `${newValue.toFixed(1)}%`;
}
// Add subtle animation
element.classList.add('text-highlight');
setTimeout(() => {
element.classList.remove('text-highlight');
}, 1000);
}
}
}
// Show toast notification
function showToast(message, type = 'info') {
// Create toast container if it doesn't exist
let toastContainer = document.getElementById('toast-container');
if (!toastContainer) {
toastContainer = document.createElement('div');
toastContainer.id = 'toast-container';
toastContainer.className = 'toast-container position-fixed bottom-0 end-0 p-3';
document.body.appendChild(toastContainer);
}
// Create toast
const toastId = 'toast-' + Date.now();
const toast = document.createElement('div');
toast.id = toastId;
toast.className = `toast align-items-center text-bg-${type} border-0`;
toast.setAttribute('role', 'alert');
toast.setAttribute('aria-live', 'assertive');
toast.setAttribute('aria-atomic', 'true');
toast.innerHTML = `
<div class="d-flex">
<div class="toast-body">
${message}
</div>
<button type="button" class="btn-close btn-close-white me-2 m-auto" data-bs-dismiss="toast" aria-label="Close"></button>
</div>
`;
toastContainer.appendChild(toast);
// Initialize and show toast
const bsToast = new bootstrap.Toast(toast, { delay: 3000 });
bsToast.show();
// Remove toast after it's hidden
toast.addEventListener('hidden.bs.toast', function() {
toast.remove();
});
}
// Load mock data
function loadMockData() {
// Generate mock data for charts
AppState.mockData = {
portfolioData: generatePortfolioData(),
dataQualityData: generateDataQualityData(),
backtestData: generateBacktestData(),
riskData: generateRiskData()
};
}
// Generate mock portfolio data
function generatePortfolioData() {
const data = [];
let value = 100000;
for (let i = 0; i < 30; i++) {
const date = new Date();
date.setDate(date.getDate() - (30 - i));
// Random walk with drift
const change = (Math.random() - 0.4) * 0.02 * value;
value += change;
data.push({
date: date.toLocaleDateString('en-US', { month: 'short', day: 'numeric' }),
value: Math.max(90000, value)
});
}
return data;
}
// Generate mock data quality data
function generateDataQualityData() {
const data = [];
for (let i = 0; i < 7; i++) {
const date = new Date();
date.setDate(date.getDate() - (7 - i));
data.push({
date: date.toLocaleDateString('en-US', { weekday: 'short' }),
completeness: 90 + Math.random() * 8,
latency: 5 + Math.random() * 15,
errors: Math.floor(Math.random() * 5)
});
}
return data;
}
// Generate mock backtest data
function generateBacktestData() {
const strategies = ['Dual Momentum', 'Mean Reversion', 'Pairs Trading'];
const data = [];
strategies.forEach(strategy => {
let returns = 100;
const returnsData = [];
for (let i = 0; i < 12; i++) {
const monthlyReturn = (Math.random() - 0.2) * 0.1;
returns *= (1 + monthlyReturn);
returnsData.push(returns);
}
data.push({
strategy,
returns: returnsData,
sharpe: 0.8 + Math.random() * 1.5,
winRate: 50 + Math.random() * 30
});
});
return data;
}
// Generate mock risk data
function generateRiskData() {
const metrics = ['VaR', 'CVaR', 'Max Drawdown', 'Volatility'];
const data = [];
metrics.forEach(metric => {
const values = [];
for (let i = 0; i < 10; i++) {
values.push(Math.random() * 10);
}
data.push({ metric, values });
});
return data;
}
// Initialize when DOM is loaded
document.addEventListener('DOMContentLoaded', initApp);
// Export for use in other scripts
window.App = {
showSection,
showToast,
refreshSectionCharts,
state: AppState
};

414
prototype/js/mock-data.js vendored Normal file
View File

@@ -0,0 +1,414 @@
/*
* Quantitative Trading Platform - Interactive Mockup
* Mock data generation for charts and displays
*/
// Chart initialization
function initCharts() {
// Initialize Portfolio Chart
initPortfolioChart();
// Initialize Data Quality Chart
initDataQualityChart();
// Initialize Backtest Chart
initBacktestChart();
// Initialize Risk Chart
initRiskChart();
}
// Portfolio Performance Chart
function initPortfolioChart() {
const ctx = document.getElementById('portfolioChart');
if (!ctx) return;
const data = generatePortfolioData();
AppState.charts.portfolioChart = new Chart(ctx, {
type: 'line',
data: {
labels: data.map(d => d.date),
datasets: [{
label: 'Portfolio Value',
data: data.map(d => d.value),
borderColor: '#4caf50',
backgroundColor: 'rgba(76, 175, 80, 0.1)',
fill: true,
tension: 0.4,
pointRadius: 2,
pointHoverRadius: 5
}]
},
options: {
responsive: true,
maintainAspectRatio: false,
plugins: {
legend: {
display: false
},
tooltip: {
mode: 'index',
intersect: false,
callbacks: {
label: function(context) {
return `$${context.parsed.y.toLocaleString()}`;
}
}
}
},
scales: {
x: {
grid: {
color: 'rgba(255, 255, 255, 0.05)'
},
ticks: {
color: '#b0bec5'
}
},
y: {
grid: {
color: 'rgba(255, 255, 255, 0.05)'
},
ticks: {
color: '#b0bec5',
callback: function(value) {
return '$' + (value / 1000).toFixed(0) + 'k';
}
}
}
}
}
});
}
// Data Quality Chart
function initDataQualityChart() {
const ctx = document.getElementById('dataQualityChart');
if (!ctx) return;
const data = generateDataQualityData();
AppState.charts.dataQualityChart = new Chart(ctx, {
type: 'line',
data: {
labels: data.map(d => d.date),
datasets: [
{
label: 'Completeness (%)',
data: data.map(d => d.completeness),
borderColor: '#4caf50',
backgroundColor: 'rgba(76, 175, 80, 0.1)',
fill: true,
tension: 0.4,
yAxisID: 'y'
},
{
label: 'Latency (ms)',
data: data.map(d => d.latency),
borderColor: '#2196f3',
backgroundColor: 'rgba(33, 150, 243, 0.1)',
fill: true,
tension: 0.4,
yAxisID: 'y1'
}
]
},
options: {
responsive: true,
maintainAspectRatio: false,
plugins: {
legend: {
position: 'top',
labels: {
color: '#b0bec5'
}
}
},
scales: {
x: {
grid: {
color: 'rgba(255, 255, 255, 0.05)'
},
ticks: {
color: '#b0bec5'
}
},
y: {
type: 'linear',
display: true,
position: 'left',
min: 80,
max: 100,
grid: {
color: 'rgba(255, 255, 255, 0.05)'
},
ticks: {
color: '#b0bec5',
callback: function(value) {
return value + '%';
}
}
},
y1: {
type: 'linear',
display: true,
position: 'right',
min: 0,
max: 30,
grid: {
drawOnChartArea: false
},
ticks: {
color: '#b0bec5',
callback: function(value) {
return value + 'ms';
}
}
}
}
}
});
}
// Backtest Results Chart
function initBacktestChart() {
const ctx = document.getElementById('backtestChart');
if (!ctx) return;
const data = generateBacktestData();
AppState.charts.backtestChart = new Chart(ctx, {
type: 'line',
data: {
labels: ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec'],
datasets: data.map((strategy, index) => {
const colors = ['#4caf50', '#2196f3', '#9c27b0'];
return {
label: strategy.strategy,
data: strategy.returns,
borderColor: colors[index],
backgroundColor: colors[index] + '20',
fill: false,
tension: 0.4
};
})
},
options: {
responsive: true,
maintainAspectRatio: false,
plugins: {
legend: {
position: 'top',
labels: {
color: '#b0bec5'
}
}
},
scales: {
x: {
grid: {
color: 'rgba(255, 255, 255, 0.05)'
},
ticks: {
color: '#b0bec5'
}
},
y: {
grid: {
color: 'rgba(255, 255, 255, 0.05)'
},
ticks: {
color: '#b0bec5',
callback: function(value) {
return '$' + value.toLocaleString();
}
}
}
}
}
});
}
// Risk Management Chart
function initRiskChart() {
const ctx = document.getElementById('riskChart');
if (!ctx) return;
const data = generateRiskData();
AppState.charts.riskChart = new Chart(ctx, {
type: 'radar',
data: {
labels: data.map(d => d.metric),
datasets: [{
label: 'Risk Metrics',
data: data.map(d => d.values[0]),
backgroundColor: 'rgba(255, 152, 0, 0.2)',
borderColor: 'rgba(255, 152, 0, 1)',
pointBackgroundColor: 'rgba(255, 152, 0, 1)',
pointBorderColor: '#fff',
pointHoverBackgroundColor: '#fff',
pointHoverBorderColor: 'rgba(255, 152, 0, 1)'
}]
},
options: {
responsive: true,
maintainAspectRatio: false,
plugins: {
legend: {
display: false
}
},
scales: {
r: {
angleLines: {
color: 'rgba(255, 255, 255, 0.1)'
},
grid: {
color: 'rgba(255, 255, 255, 0.1)'
},
pointLabels: {
color: '#b0bec5'
},
ticks: {
color: '#b0bec5',
backdropColor: 'transparent'
},
min: 0,
max: 10
}
}
}
});
}
// Update functions for live data
function updatePortfolioChart() {
if (!AppState.charts.portfolioChart) return;
const newData = generatePortfolioData();
AppState.charts.portfolioChart.data.labels = newData.map(d => d.date);
AppState.charts.portfolioChart.data.datasets[0].data = newData.map(d => d.value);
AppState.charts.portfolioChart.update('none');
}
function updateDataQualityChart() {
if (!AppState.charts.dataQualityChart) return;
const newData = generateDataQualityData();
AppState.charts.dataQualityChart.data.labels = newData.map(d => d.date);
AppState.charts.dataQualityChart.data.datasets[0].data = newData.map(d => d.completeness);
AppState.charts.dataQualityChart.data.datasets[1].data = newData.map(d => d.latency);
AppState.charts.dataQualityChart.update('none');
}
function updateBacktestChart() {
if (!AppState.charts.backtestChart) return;
const newData = generateBacktestData();
newData.forEach((strategy, index) => {
AppState.charts.backtestChart.data.datasets[index].data = strategy.returns;
});
AppState.charts.backtestChart.update('none');
}
function updateRiskChart() {
if (!AppState.charts.riskChart) return;
const newData = generateRiskData();
AppState.charts.riskChart.data.datasets[0].data = newData.map(d => d.values[0]);
AppState.charts.riskChart.update('none');
}
// Data generation functions (same as in app.js but exported for use)
function generatePortfolioData() {
const data = [];
let value = 100000;
for (let i = 0; i < 30; i++) {
const date = new Date();
date.setDate(date.getDate() - (30 - i));
const change = (Math.random() - 0.4) * 0.02 * value;
value += change;
data.push({
date: date.toLocaleDateString('en-US', { month: 'short', day: 'numeric' }),
value: Math.max(90000, value)
});
}
return data;
}
function generateDataQualityData() {
const data = [];
for (let i = 0; i < 7; i++) {
const date = new Date();
date.setDate(date.getDate() - (7 - i));
data.push({
date: date.toLocaleDateString('en-US', { weekday: 'short' }),
completeness: 90 + Math.random() * 8,
latency: 5 + Math.random() * 15,
errors: Math.floor(Math.random() * 5)
});
}
return data;
}
function generateBacktestData() {
const strategies = ['Dual Momentum', 'Mean Reversion', 'Pairs Trading'];
const data = [];
strategies.forEach(strategy => {
let returns = 100;
const returnsData = [];
for (let i = 0; i < 12; i++) {
const monthlyReturn = (Math.random() - 0.2) * 0.1;
returns *= (1 + monthlyReturn);
returnsData.push(returns);
}
data.push({
strategy,
returns: returnsData,
sharpe: 0.8 + Math.random() * 1.5,
winRate: 50 + Math.random() * 30
});
});
return data;
}
function generateRiskData() {
const metrics = ['VaR', 'CVaR', 'Max Drawdown', 'Volatility'];
const data = [];
metrics.forEach(metric => {
const values = [];
for (let i = 0; i < 10; i++) {
values.push(Math.random() * 10);
}
data.push({ metric, values });
});
return data;
}
// Export for use in other scripts
window.MockData = {
initCharts,
updatePortfolioChart,
updateDataQualityChart,
updateBacktestChart,
updateRiskChart,
generatePortfolioData,
generateDataQualityData,
generateBacktestData,
generateRiskData
};