658 lines
25 KiB
TypeScript
658 lines
25 KiB
TypeScript
import { defineStore } from "pinia";
|
|
|
|
export const useBudgetStore = defineStore(
|
|
"budget",
|
|
() => {
|
|
// Schema version for persistence
|
|
const schemaVersion = "2.0";
|
|
|
|
// Canonical categories from WizardRevenueStep - matches the wizard exactly
|
|
const revenueCategories = ref([
|
|
'Games & Products',
|
|
'Services & Contracts',
|
|
'Grants & Funding',
|
|
'Community Support',
|
|
'Partnerships',
|
|
'Investment Income',
|
|
'In-Kind Contributions'
|
|
]);
|
|
|
|
// Revenue subcategories by main category (for reference and grouping)
|
|
const revenueSubcategories = ref({
|
|
'Games & Products': ['Direct sales', 'Platform revenue share', 'DLC/expansions', 'Merchandise'],
|
|
'Services & Contracts': ['Contract development', 'Consulting', 'Workshops/teaching', 'Technical services'],
|
|
'Grants & Funding': ['Government funding', 'Arts council grants', 'Foundation support', 'Research grants'],
|
|
'Community Support': ['Patreon/subscriptions', 'Crowdfunding', 'Donations', 'Mutual aid received'],
|
|
'Partnerships': ['Corporate partnerships', 'Academic partnerships', 'Sponsorships'],
|
|
'Investment Income': ['Impact investment', 'Venture capital', 'Loans'],
|
|
'In-Kind Contributions': ['Office space', 'Equipment/hardware', 'Software licenses', 'Professional services', 'Marketing/PR services', 'Legal services']
|
|
});
|
|
|
|
const expenseCategories = ref([
|
|
'Salaries & Benefits',
|
|
'Development Costs',
|
|
'Equipment & Technology',
|
|
'Marketing & Outreach',
|
|
'Office & Operations',
|
|
'Legal & Professional',
|
|
'Other Expenses'
|
|
]);
|
|
|
|
// NEW: Budget worksheet structure (starts empty, populated from wizard data)
|
|
const budgetWorksheet = ref({
|
|
revenue: [],
|
|
expenses: []
|
|
});
|
|
|
|
// Track if worksheet has been initialized from wizard data
|
|
const isInitialized = ref(false);
|
|
|
|
// LEGACY: Keep for backward compatibility
|
|
const budgetLines = ref({});
|
|
const overheadCosts = ref([]);
|
|
const productionCosts = ref([]);
|
|
|
|
// Computed grouped data for category headers
|
|
const groupedRevenue = computed(() => {
|
|
const groups = {};
|
|
revenueCategories.value.forEach(category => {
|
|
groups[category] = budgetWorksheet.value.revenue.filter(item => item.mainCategory === category);
|
|
});
|
|
return groups;
|
|
});
|
|
|
|
const groupedExpenses = computed(() => {
|
|
const groups = {};
|
|
expenseCategories.value.forEach(category => {
|
|
groups[category] = budgetWorksheet.value.expenses.filter(item => item.mainCategory === category);
|
|
});
|
|
return groups;
|
|
});
|
|
|
|
// Computed totals for budget worksheet (legacy - keep for backward compatibility)
|
|
const budgetTotals = computed(() => {
|
|
const years = ['year1', 'year2', 'year3'];
|
|
const scenarios = ['best', 'worst', 'mostLikely'];
|
|
const totals = {};
|
|
|
|
years.forEach(year => {
|
|
totals[year] = {};
|
|
scenarios.forEach(scenario => {
|
|
// Calculate revenue total
|
|
const revenueTotal = budgetWorksheet.value.revenue.reduce((sum, item) => {
|
|
return sum + (item.values?.[year]?.[scenario] || 0);
|
|
}, 0);
|
|
|
|
// Calculate expenses total
|
|
const expensesTotal = budgetWorksheet.value.expenses.reduce((sum, item) => {
|
|
return sum + (item.values?.[year]?.[scenario] || 0);
|
|
}, 0);
|
|
|
|
// Calculate net income
|
|
const netIncome = revenueTotal - expensesTotal;
|
|
|
|
totals[year][scenario] = {
|
|
revenue: revenueTotal,
|
|
expenses: expensesTotal,
|
|
net: netIncome
|
|
};
|
|
});
|
|
});
|
|
|
|
return totals;
|
|
});
|
|
|
|
// Monthly totals computation
|
|
const monthlyTotals = computed(() => {
|
|
const totals = {};
|
|
|
|
// Generate month keys for next 12 months
|
|
const today = new Date();
|
|
for (let i = 0; i < 12; i++) {
|
|
const date = new Date(today.getFullYear(), today.getMonth() + i, 1);
|
|
const monthKey = `${date.getFullYear()}-${String(date.getMonth() + 1).padStart(2, '0')}`;
|
|
|
|
// Calculate revenue total for this month
|
|
const revenueTotal = budgetWorksheet.value.revenue.reduce((sum, item) => {
|
|
return sum + (item.monthlyValues?.[monthKey] || 0);
|
|
}, 0);
|
|
|
|
// Calculate expenses total for this month
|
|
const expensesTotal = budgetWorksheet.value.expenses.reduce((sum, item) => {
|
|
return sum + (item.monthlyValues?.[monthKey] || 0);
|
|
}, 0);
|
|
|
|
// Calculate net income
|
|
const netIncome = revenueTotal - expensesTotal;
|
|
|
|
totals[monthKey] = {
|
|
revenue: revenueTotal,
|
|
expenses: expensesTotal,
|
|
net: netIncome
|
|
};
|
|
}
|
|
|
|
return totals;
|
|
});
|
|
|
|
// LEGACY: Keep for backward compatibility
|
|
const currentDate = new Date();
|
|
const currentYear = currentDate.getFullYear();
|
|
const currentMonth = String(currentDate.getMonth() + 1).padStart(2, '0');
|
|
const currentPeriod = ref(`${currentYear}-${currentMonth}`);
|
|
|
|
const currentBudget = computed(() => {
|
|
return (
|
|
budgetLines.value[currentPeriod.value] || {
|
|
period: currentPeriod.value,
|
|
revenueByStream: {},
|
|
payrollCosts: { memberHours: [], oncostApplied: 0 },
|
|
overheadCosts: [],
|
|
productionCosts: [],
|
|
savingsChange: 0,
|
|
net: 0,
|
|
}
|
|
);
|
|
});
|
|
|
|
// Actions
|
|
function setBudgetLine(period, budgetData) {
|
|
budgetLines.value[period] = {
|
|
period,
|
|
...budgetData,
|
|
};
|
|
}
|
|
|
|
function updateRevenue(period, streamId, type, amount) {
|
|
if (!budgetLines.value[period]) {
|
|
budgetLines.value[period] = { period, revenueByStream: {} };
|
|
}
|
|
if (!budgetLines.value[period].revenueByStream[streamId]) {
|
|
budgetLines.value[period].revenueByStream[streamId] = {};
|
|
}
|
|
budgetLines.value[period].revenueByStream[streamId][type] = amount;
|
|
}
|
|
|
|
// Wizard-required actions
|
|
function addOverheadLine(cost) {
|
|
// Allow creating a blank line so the user can fill it out in the UI
|
|
const safeName = cost?.name ?? "";
|
|
const safeAmountMonthly =
|
|
typeof cost?.amountMonthly === "number" &&
|
|
!Number.isNaN(cost.amountMonthly)
|
|
? cost.amountMonthly
|
|
: 0;
|
|
|
|
overheadCosts.value.push({
|
|
id: Date.now().toString(),
|
|
name: safeName,
|
|
amount: safeAmountMonthly,
|
|
category: cost?.category || "Operations",
|
|
recurring: cost?.recurring ?? true,
|
|
...cost,
|
|
});
|
|
}
|
|
|
|
function removeOverheadLine(id) {
|
|
const index = overheadCosts.value.findIndex((c) => c.id === id);
|
|
if (index > -1) {
|
|
overheadCosts.value.splice(index, 1);
|
|
}
|
|
}
|
|
|
|
function addOverheadCost(cost) {
|
|
addOverheadLine({ name: cost.name, amountMonthly: cost.amount, ...cost });
|
|
}
|
|
|
|
function addProductionCost(cost) {
|
|
productionCosts.value.push({
|
|
id: Date.now().toString(),
|
|
name: cost.name,
|
|
amount: cost.amount,
|
|
category: cost.category || "Production",
|
|
period: cost.period,
|
|
...cost,
|
|
});
|
|
}
|
|
|
|
function setCurrentPeriod(period) {
|
|
currentPeriod.value = period;
|
|
}
|
|
|
|
// Initialize worksheet from wizard data
|
|
async function initializeFromWizardData() {
|
|
if (isInitialized.value && budgetWorksheet.value.revenue.length > 0) {
|
|
console.log('Already initialized with data, skipping...');
|
|
return;
|
|
}
|
|
|
|
console.log('Initializing budget from wizard data...');
|
|
|
|
// Import stores dynamically to avoid circular deps
|
|
const { useStreamsStore } = await import('./streams');
|
|
const { useMembersStore } = await import('./members');
|
|
const { usePoliciesStore } = await import('./policies');
|
|
|
|
const streamsStore = useStreamsStore();
|
|
const membersStore = useMembersStore();
|
|
const policiesStore = usePoliciesStore();
|
|
|
|
console.log('Streams:', streamsStore.streams.length, 'streams');
|
|
console.log('Members capacity:', membersStore.capacityTotals);
|
|
console.log('Policies wage:', policiesStore.equalHourlyWage);
|
|
|
|
// Clear existing data
|
|
budgetWorksheet.value.revenue = [];
|
|
budgetWorksheet.value.expenses = [];
|
|
|
|
// Add revenue streams from wizard
|
|
if (streamsStore.streams.length === 0) {
|
|
console.log('No wizard streams found, adding sample data');
|
|
// Initialize with minimal demo if no wizard data exists
|
|
await streamsStore.initializeWithFixtures();
|
|
}
|
|
|
|
streamsStore.streams.forEach(stream => {
|
|
const monthlyAmount = stream.targetMonthlyAmount || 0;
|
|
console.log('Adding stream:', stream.name, 'category:', stream.category, 'subcategory:', stream.subcategory, 'amount:', monthlyAmount);
|
|
console.log('Full stream object:', stream);
|
|
|
|
// Simple category mapping - just map the key categories we know exist
|
|
let mappedCategory = 'Games & Products'; // Default
|
|
const categoryLower = (stream.category || '').toLowerCase();
|
|
if (categoryLower === 'games' || categoryLower === 'product') mappedCategory = 'Games & Products';
|
|
else if (categoryLower === 'services' || categoryLower === 'service') mappedCategory = 'Services & Contracts';
|
|
else if (categoryLower === 'grants' || categoryLower === 'grant') mappedCategory = 'Grants & Funding';
|
|
else if (categoryLower === 'community') mappedCategory = 'Community Support';
|
|
else if (categoryLower === 'partnerships' || categoryLower === 'partnership') mappedCategory = 'Partnerships';
|
|
else if (categoryLower === 'investment') mappedCategory = 'Investment Income';
|
|
|
|
console.log('Mapped category from', stream.category, 'to', mappedCategory);
|
|
|
|
// Create monthly values - split the annual target evenly across 12 months
|
|
const monthlyValues = {};
|
|
const today = new Date();
|
|
for (let i = 0; i < 12; i++) {
|
|
const date = new Date(today.getFullYear(), today.getMonth() + i, 1);
|
|
const monthKey = `${date.getFullYear()}-${String(date.getMonth() + 1).padStart(2, '0')}`;
|
|
monthlyValues[monthKey] = monthlyAmount;
|
|
}
|
|
console.log('Created monthly values for', stream.name, ':', monthlyValues);
|
|
|
|
budgetWorksheet.value.revenue.push({
|
|
id: `revenue-${stream.id}`,
|
|
name: stream.name,
|
|
mainCategory: mappedCategory,
|
|
subcategory: stream.subcategory || 'Direct sales', // Use actual subcategory from stream
|
|
source: 'wizard',
|
|
monthlyValues,
|
|
values: {
|
|
year1: { best: monthlyAmount * 12, worst: monthlyAmount * 6, mostLikely: monthlyAmount * 10 },
|
|
year2: { best: monthlyAmount * 15, worst: monthlyAmount * 8, mostLikely: monthlyAmount * 12 },
|
|
year3: { best: monthlyAmount * 18, worst: monthlyAmount * 10, mostLikely: monthlyAmount * 15 }
|
|
}
|
|
});
|
|
});
|
|
|
|
// Add payroll from wizard data
|
|
const totalHours = membersStore.capacityTotals.targetHours || 0;
|
|
const hourlyWage = policiesStore.equalHourlyWage || 0;
|
|
const oncostPct = policiesStore.payrollOncostPct || 0;
|
|
if (totalHours > 0 && hourlyWage > 0) {
|
|
const monthlyPayroll = totalHours * hourlyWage * (1 + oncostPct / 100);
|
|
|
|
// Create monthly values for payroll
|
|
const monthlyValues = {};
|
|
const today = new Date();
|
|
for (let i = 0; i < 12; i++) {
|
|
const date = new Date(today.getFullYear(), today.getMonth() + i, 1);
|
|
const monthKey = `${date.getFullYear()}-${String(date.getMonth() + 1).padStart(2, '0')}`;
|
|
monthlyValues[monthKey] = monthlyPayroll;
|
|
}
|
|
|
|
budgetWorksheet.value.expenses.push({
|
|
id: 'expense-payroll',
|
|
name: 'Payroll',
|
|
mainCategory: 'Salaries & Benefits',
|
|
subcategory: 'Base wages and benefits',
|
|
source: 'wizard',
|
|
monthlyValues,
|
|
values: {
|
|
year1: { best: monthlyPayroll * 12, worst: monthlyPayroll * 8, mostLikely: monthlyPayroll * 12 },
|
|
year2: { best: monthlyPayroll * 14, worst: monthlyPayroll * 10, mostLikely: monthlyPayroll * 13 },
|
|
year3: { best: monthlyPayroll * 16, worst: monthlyPayroll * 12, mostLikely: monthlyPayroll * 15 }
|
|
}
|
|
});
|
|
}
|
|
|
|
// Add overhead costs from wizard
|
|
overheadCosts.value.forEach(cost => {
|
|
if (cost.amount > 0) {
|
|
const annualAmount = cost.amount * 12;
|
|
// Map overhead cost categories to expense categories
|
|
let expenseCategory = 'Other Expenses'; // Default
|
|
if (cost.category === 'Operations') expenseCategory = 'Office & Operations';
|
|
else if (cost.category === 'Technology') expenseCategory = 'Equipment & Technology';
|
|
else if (cost.category === 'Legal') expenseCategory = 'Legal & Professional';
|
|
else if (cost.category === 'Marketing') expenseCategory = 'Marketing & Outreach';
|
|
|
|
// Create monthly values for overhead costs
|
|
const monthlyValues = {};
|
|
const today = new Date();
|
|
for (let i = 0; i < 12; i++) {
|
|
const date = new Date(today.getFullYear(), today.getMonth() + i, 1);
|
|
const monthKey = `${date.getFullYear()}-${String(date.getMonth() + 1).padStart(2, '0')}`;
|
|
monthlyValues[monthKey] = cost.amount;
|
|
}
|
|
|
|
budgetWorksheet.value.expenses.push({
|
|
id: `expense-${cost.id}`,
|
|
name: cost.name,
|
|
mainCategory: expenseCategory,
|
|
subcategory: cost.name, // Use the cost name as subcategory
|
|
source: 'wizard',
|
|
monthlyValues,
|
|
values: {
|
|
year1: { best: annualAmount, worst: annualAmount * 0.8, mostLikely: annualAmount },
|
|
year2: { best: annualAmount * 1.1, worst: annualAmount * 0.9, mostLikely: annualAmount * 1.05 },
|
|
year3: { best: annualAmount * 1.2, worst: annualAmount, mostLikely: annualAmount * 1.1 }
|
|
}
|
|
});
|
|
}
|
|
});
|
|
|
|
// Add production costs from wizard
|
|
productionCosts.value.forEach(cost => {
|
|
if (cost.amount > 0) {
|
|
const annualAmount = cost.amount * 12;
|
|
// Create monthly values for production costs
|
|
const monthlyValues = {};
|
|
const today = new Date();
|
|
for (let i = 0; i < 12; i++) {
|
|
const date = new Date(today.getFullYear(), today.getMonth() + i, 1);
|
|
const monthKey = `${date.getFullYear()}-${String(date.getMonth() + 1).padStart(2, '0')}`;
|
|
monthlyValues[monthKey] = cost.amount;
|
|
}
|
|
|
|
budgetWorksheet.value.expenses.push({
|
|
id: `expense-${cost.id}`,
|
|
name: cost.name,
|
|
mainCategory: 'Development Costs',
|
|
subcategory: cost.name, // Use the cost name as subcategory
|
|
source: 'wizard',
|
|
monthlyValues,
|
|
values: {
|
|
year1: { best: annualAmount, worst: annualAmount * 0.7, mostLikely: annualAmount * 0.9 },
|
|
year2: { best: annualAmount * 1.2, worst: annualAmount * 0.8, mostLikely: annualAmount },
|
|
year3: { best: annualAmount * 1.3, worst: annualAmount * 0.9, mostLikely: annualAmount * 1.1 }
|
|
}
|
|
});
|
|
}
|
|
});
|
|
|
|
// If still no data after initialization, add a sample row
|
|
if (budgetWorksheet.value.revenue.length === 0) {
|
|
console.log('Adding sample revenue line');
|
|
// Create monthly values for sample revenue
|
|
const monthlyValues = {};
|
|
const today = new Date();
|
|
for (let i = 0; i < 12; i++) {
|
|
const date = new Date(today.getFullYear(), today.getMonth() + i, 1);
|
|
const monthKey = `${date.getFullYear()}-${String(date.getMonth() + 1).padStart(2, '0')}`;
|
|
monthlyValues[monthKey] = 667; // ~8000/12
|
|
}
|
|
|
|
budgetWorksheet.value.revenue.push({
|
|
id: 'revenue-sample',
|
|
name: 'Sample Revenue',
|
|
mainCategory: 'Games & Products',
|
|
subcategory: 'Direct sales',
|
|
source: 'user',
|
|
monthlyValues,
|
|
values: {
|
|
year1: { best: 10000, worst: 5000, mostLikely: 8000 },
|
|
year2: { best: 12000, worst: 6000, mostLikely: 10000 },
|
|
year3: { best: 15000, worst: 8000, mostLikely: 12000 }
|
|
}
|
|
});
|
|
}
|
|
|
|
if (budgetWorksheet.value.expenses.length === 0) {
|
|
console.log('Adding sample expense line');
|
|
// Create monthly values for sample expense
|
|
const monthlyValues = {};
|
|
const today = new Date();
|
|
for (let i = 0; i < 12; i++) {
|
|
const date = new Date(today.getFullYear(), today.getMonth() + i, 1);
|
|
const monthKey = `${date.getFullYear()}-${String(date.getMonth() + 1).padStart(2, '0')}`;
|
|
monthlyValues[monthKey] = 67; // ~800/12
|
|
}
|
|
|
|
budgetWorksheet.value.expenses.push({
|
|
id: 'expense-sample',
|
|
name: 'Sample Expense',
|
|
mainCategory: 'Other Expenses',
|
|
subcategory: 'Miscellaneous',
|
|
source: 'user',
|
|
monthlyValues,
|
|
values: {
|
|
year1: { best: 1000, worst: 500, mostLikely: 800 },
|
|
year2: { best: 1200, worst: 600, mostLikely: 1000 },
|
|
year3: { best: 1500, worst: 800, mostLikely: 1200 }
|
|
}
|
|
});
|
|
}
|
|
|
|
// Debug: Log all revenue items and their categories
|
|
console.log('Final revenue items:');
|
|
budgetWorksheet.value.revenue.forEach(item => {
|
|
console.log(`- ${item.name}: ${item.mainCategory} > ${item.subcategory} (${item.values.year1.mostLikely})`);
|
|
});
|
|
|
|
console.log('Final expense items:');
|
|
budgetWorksheet.value.expenses.forEach(item => {
|
|
console.log(`- ${item.name}: ${item.mainCategory} > ${item.subcategory} (${item.values.year1.mostLikely})`);
|
|
});
|
|
|
|
// Ensure all items have monthlyValues and new structure - migrate existing items
|
|
[...budgetWorksheet.value.revenue, ...budgetWorksheet.value.expenses].forEach(item => {
|
|
// Migrate to new structure if needed
|
|
if (item.category && !item.mainCategory) {
|
|
console.log('Migrating item structure for:', item.name);
|
|
item.mainCategory = item.category; // Old category becomes mainCategory
|
|
|
|
// Set appropriate subcategory based on the main category and item name
|
|
if (item.category === 'Games & Products') {
|
|
const gameSubcategories = ['Direct sales', 'Platform revenue share', 'DLC/expansions', 'Merchandise'];
|
|
item.subcategory = gameSubcategories.includes(item.name) ? item.name : 'Direct sales';
|
|
} else if (item.category === 'Services & Contracts') {
|
|
const serviceSubcategories = ['Contract development', 'Consulting', 'Workshops/teaching', 'Technical services'];
|
|
item.subcategory = serviceSubcategories.includes(item.name) ? item.name : 'Contract development';
|
|
} else if (item.category === 'Investment Income') {
|
|
const investmentSubcategories = ['Impact investment', 'Venture capital', 'Loans'];
|
|
item.subcategory = investmentSubcategories.includes(item.name) ? item.name : 'Impact investment';
|
|
} else if (item.category === 'Salaries & Benefits') {
|
|
item.subcategory = 'Base wages and benefits';
|
|
} else if (item.category === 'Office & Operations') {
|
|
// Map specific office tools to appropriate subcategories
|
|
if (item.name.toLowerCase().includes('rent') || item.name.toLowerCase().includes('office')) {
|
|
item.subcategory = 'Rent';
|
|
} else if (item.name.toLowerCase().includes('util')) {
|
|
item.subcategory = 'Utilities';
|
|
} else if (item.name.toLowerCase().includes('insurance')) {
|
|
item.subcategory = 'Insurance';
|
|
} else {
|
|
item.subcategory = 'Office supplies';
|
|
}
|
|
} else {
|
|
// For other categories, use appropriate default
|
|
item.subcategory = 'Miscellaneous';
|
|
}
|
|
|
|
delete item.category; // Remove old property
|
|
}
|
|
|
|
if (!item.monthlyValues) {
|
|
console.log('Migrating item to monthly values:', item.name);
|
|
item.monthlyValues = {};
|
|
const today = new Date();
|
|
for (let i = 0; i < 12; i++) {
|
|
const date = new Date(today.getFullYear(), today.getMonth() + i, 1);
|
|
const monthKey = `${date.getFullYear()}-${String(date.getMonth() + 1).padStart(2, '0')}`;
|
|
// Try to use most likely value divided by 12, or default to 0
|
|
const yearlyValue = item.values?.year1?.mostLikely || 0;
|
|
item.monthlyValues[monthKey] = Math.round(yearlyValue / 12);
|
|
}
|
|
console.log('Added monthly values to', item.name, ':', item.monthlyValues);
|
|
}
|
|
});
|
|
|
|
console.log('Initialization complete. Revenue items:', budgetWorksheet.value.revenue.length, 'Expense items:', budgetWorksheet.value.expenses.length);
|
|
|
|
isInitialized.value = true;
|
|
}
|
|
|
|
// NEW: Budget worksheet functions
|
|
function updateBudgetValue(category, itemId, year, scenario, value) {
|
|
const items = budgetWorksheet.value[category];
|
|
const item = items.find(i => i.id === itemId);
|
|
if (item) {
|
|
item.values[year][scenario] = Number(value) || 0;
|
|
}
|
|
}
|
|
|
|
function updateMonthlyValue(category, itemId, monthKey, value) {
|
|
const items = budgetWorksheet.value[category];
|
|
const item = items.find(i => i.id === itemId);
|
|
if (item) {
|
|
if (!item.monthlyValues) {
|
|
item.monthlyValues = {};
|
|
}
|
|
item.monthlyValues[monthKey] = Number(value) || 0;
|
|
}
|
|
}
|
|
|
|
function addBudgetItem(category, name, selectedCategory = '') {
|
|
const id = `${category}-${Date.now()}`;
|
|
|
|
// Create empty monthly values for next 12 months
|
|
const monthlyValues = {};
|
|
const today = new Date();
|
|
for (let i = 0; i < 12; i++) {
|
|
const date = new Date(today.getFullYear(), today.getMonth() + i, 1);
|
|
const monthKey = `${date.getFullYear()}-${String(date.getMonth() + 1).padStart(2, '0')}`;
|
|
monthlyValues[monthKey] = 0;
|
|
}
|
|
|
|
const newItem = {
|
|
id,
|
|
name,
|
|
mainCategory: selectedCategory || (category === 'revenue' ? 'Games & Products' : 'Other Expenses'),
|
|
subcategory: '', // Will be set by user via dropdown
|
|
source: 'user',
|
|
monthlyValues,
|
|
values: {
|
|
year1: { best: 0, worst: 0, mostLikely: 0 },
|
|
year2: { best: 0, worst: 0, mostLikely: 0 },
|
|
year3: { best: 0, worst: 0, mostLikely: 0 }
|
|
}
|
|
};
|
|
budgetWorksheet.value[category].push(newItem);
|
|
return id;
|
|
}
|
|
|
|
function removeBudgetItem(category, itemId) {
|
|
const items = budgetWorksheet.value[category];
|
|
const index = items.findIndex(i => i.id === itemId);
|
|
if (index > -1) {
|
|
items.splice(index, 1);
|
|
}
|
|
}
|
|
|
|
function renameBudgetItem(category, itemId, newName) {
|
|
const items = budgetWorksheet.value[category];
|
|
const item = items.find(i => i.id === itemId);
|
|
if (item) {
|
|
item.name = newName;
|
|
}
|
|
}
|
|
|
|
function updateBudgetCategory(category, itemId, newCategory) {
|
|
const items = budgetWorksheet.value[category];
|
|
const item = items.find(i => i.id === itemId);
|
|
if (item) {
|
|
item.category = newCategory;
|
|
}
|
|
}
|
|
|
|
function addCustomCategory(type, categoryName) {
|
|
if (type === 'revenue' && !revenueCategories.value.includes(categoryName)) {
|
|
revenueCategories.value.push(categoryName);
|
|
} else if (type === 'expenses' && !expenseCategories.value.includes(categoryName)) {
|
|
expenseCategories.value.push(categoryName);
|
|
}
|
|
}
|
|
|
|
// Reset function
|
|
function resetBudgetOverhead() {
|
|
overheadCosts.value = [];
|
|
productionCosts.value = [];
|
|
}
|
|
|
|
function resetBudgetWorksheet() {
|
|
// Reset all values to 0 but keep the structure
|
|
[...budgetWorksheet.value.revenue, ...budgetWorksheet.value.expenses].forEach(item => {
|
|
Object.keys(item.values).forEach(year => {
|
|
Object.keys(item.values[year]).forEach(scenario => {
|
|
item.values[year][scenario] = 0;
|
|
});
|
|
});
|
|
});
|
|
}
|
|
|
|
return {
|
|
// NEW: Budget worksheet
|
|
budgetWorksheet,
|
|
budgetTotals,
|
|
monthlyTotals,
|
|
revenueCategories,
|
|
expenseCategories,
|
|
revenueSubcategories,
|
|
groupedRevenue,
|
|
groupedExpenses,
|
|
isInitialized,
|
|
initializeFromWizardData,
|
|
updateBudgetValue,
|
|
updateMonthlyValue,
|
|
addBudgetItem,
|
|
removeBudgetItem,
|
|
renameBudgetItem,
|
|
updateBudgetCategory,
|
|
addCustomCategory,
|
|
resetBudgetWorksheet,
|
|
// LEGACY: Keep for backward compatibility
|
|
budgetLines,
|
|
overheadCosts,
|
|
productionCosts,
|
|
currentPeriod: readonly(currentPeriod),
|
|
currentBudget,
|
|
schemaVersion,
|
|
setBudgetLine,
|
|
updateRevenue,
|
|
// Wizard actions
|
|
addOverheadLine,
|
|
removeOverheadLine,
|
|
resetBudgetOverhead,
|
|
// Legacy actions
|
|
addOverheadCost,
|
|
addProductionCost,
|
|
setCurrentPeriod,
|
|
};
|
|
},
|
|
{
|
|
persist: {
|
|
key: "urgent-tools-budget",
|
|
paths: ["budgetWorksheet", "revenueCategories", "expenseCategories", "isInitialized", "overheadCosts", "productionCosts", "currentPeriod"],
|
|
},
|
|
}
|
|
);
|