Tag Geometri
{/* Basic dimensions */}
{
setGeometry({...geometry, width: e.target.value});
recalculateGeometry({...geometry, width: e.target.value});
}}
/>
{
setGeometry({...geometry, length: e.target.value});
recalculateGeometry({...geometry, length: e.target.value});
}}
/>
{
setGeometry({...geometry, sternToRidgeHeight: e.target.value});
recalculateGeometry({...geometry, sternToRidgeHeight: e.target.value});
}}
/>
{/* Angle/Pitch input */}
handleAngleChange(parseFloat(e.target.value))}
disabled={!allowEdit && calculatedValues}
/>
{!allowEdit && (
)}
{/* Spærafstand selector */}
{/* Calculated values */}
{calculatedValues && (
Beregnede værdier:
📐 Tagareal: {calculatedValues.roofArea} m²
📏 Taghældning: {calculatedValues.roofSlope} m
🪚 Antal spær: {calculatedValues.spaerCount} stk
📏 Faktisk afstand: {calculatedValues.actualSpaerDistance} m
🔗 Total spærlængde: {calculatedValues.totalSpaerLength} m
📐 Vindskede: {calculatedValues.vindskede} lbm
)}
);
}
```
#### Backend API Update
```javascript
// unified-server.js - Update geometry endpoint
app.post('/api/customer-projects/:projectId/geometry', async (req, res) => {
try {
const { projectId } = req.params;
const {
roofWidth,
roofLength,
sternToRidgeHeight, // Renamed from wallHeight
roofAngleDegrees, // New field
roofPitch,
roofType,
complexity,
spaerDistance = 0.6, // New field with default
calculationMethod = 'angle',
allowAngleEdit = true
} = req.body;
// Validation
if (!roofWidth || !roofLength || !sternToRidgeHeight) {
return res.status(400).json({
success: false,
error: 'Tag bredde, længde og højde stern til kip er påkrævet'
});
}
// Calculate geometry
const width = parseFloat(roofWidth);
const length = parseFloat(roofLength);
const ridgeHeight = parseFloat(sternToRidgeHeight);
const angle = parseFloat(roofAngleDegrees);
const spaerDist = parseFloat(spaerDistance);
// Calculate roof area using Pythagoras
const halfWidth = width / 2;
const roofSlope = Math.sqrt(Math.pow(halfWidth, 2) + Math.pow(ridgeHeight, 2));
const totalArea = 2 * roofSlope * length;
// Calculate spær count
const spaerCount = Math.ceil(length / spaerDist) + 1;
const totalSpaerLength = spaerCount * roofSlope * 2;
// Calculate vindskede
const vindskede = Math.sqrt(Math.pow(roofSlope, 2) + Math.pow(length, 2));
// Save to database
await databaseService.query(`
INSERT INTO roof_geometry (
project_id, width_main, length_main, total_area,
stern_to_ridge_height, roof_angle_degrees, roof_pitch,
roof_type, complexity_factor, roof_height, vindskede_lbm,
spaer_distance, spaer_count, allow_angle_edit, calculation_method,
created_at, updated_at
) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, NOW(), NOW())
ON DUPLICATE KEY UPDATE
width_main = VALUES(width_main),
length_main = VALUES(length_main),
total_area = VALUES(total_area),
stern_to_ridge_height = VALUES(stern_to_ridge_height),
roof_angle_degrees = VALUES(roof_angle_degrees),
roof_pitch = VALUES(roof_pitch),
spaer_distance = VALUES(spaer_distance),
spaer_count = VALUES(spaer_count),
allow_angle_edit = VALUES(allow_angle_edit),
calculation_method = VALUES(calculation_method),
updated_at = NOW()
`, [
projectId, width, length, totalArea,
ridgeHeight, angle, roofPitch,
roofType, complexity, roofSlope, vindskede,
spaerDist, spaerCount, allowAngleEdit, calculationMethod
]);
res.json({
success: true,
geometry: {
area: totalArea.toFixed(2),
roofSlope: roofSlope.toFixed(2),
spaerCount,
totalSpaerLength: totalSpaerLength.toFixed(2),
vindskede: vindskede.toFixed(2),
actualSpaerDistance: (length / (spaerCount - 1)).toFixed(2)
}
});
} catch (error) {
console.error('Geometry calculation error:', error);
res.status(500).json({ success: false, error: error.message });
}
});
```
---
## 3️⃣ Smart Pakker Udvidelse
### 📝 Beskrivelse
Smart pakker skal indeholde materialer, tidsforbrug og opgaver i korrekt rækkefølge.
### 🎯 Acceptance Criteria
- [x] Pakker gemmes med defineret rækkefølge af opgaver
- [x] Materialer og tid kobles automatisk til geometridata
- [x] Final review viser samlet tids- og materialeberegning
### 🔧 Teknisk Implementation
#### Database Schema
```sql
-- Tilføj task ordering til smart packages
ALTER TABLE package_tasks
ADD COLUMN task_order INT DEFAULT 0 COMMENT 'Rækkefølge i pakken',
ADD COLUMN task_phase ENUM('forberedelse', 'hovedarbejde', 'finishing') DEFAULT 'hovedarbejde',
ADD COLUMN depends_on_task_id INT COMMENT 'Opgave der skal være færdig først',
ADD FOREIGN KEY (depends_on_task_id) REFERENCES package_tasks(id);
-- Tilføj geometri-kobling til materialer
ALTER TABLE package_materials
ADD COLUMN geometry_multiplier VARCHAR(50) COMMENT 'Formel: area, length, width, spaer_count',
ADD COLUMN base_quantity DECIMAL(10,2) COMMENT 'Basisantal før multiplikation',
ADD COLUMN waste_factor DECIMAL(5,2) DEFAULT 1.1 COMMENT 'Spild-faktor (1.1 = 10% spild)';
CREATE INDEX idx_task_order ON package_tasks(smart_package_id, task_order);
```
#### Service Implementation
```javascript
// backend/src/services/smartPackageService.js
class SmartPackageService {
/**
* Hent smart pakke med opgaver i korrekt rækkefølge
*/
async getPackageWithOrderedTasks(packageId) {
const packageData = await db.query(
'SELECT * FROM smart_packages WHERE id = ?',
[packageId]
);
const tasks = await db.query(`
SELECT
pt.*,
pt.task_order,
pt.task_phase,
pt.depends_on_task_id,
dt.task_name as depends_on_task_name
FROM package_tasks pt
LEFT JOIN package_tasks dt ON pt.depends_on_task_id = dt.id
WHERE pt.smart_package_id = ?
ORDER BY pt.task_phase, pt.task_order ASC
`, [packageId]);
const materials = await db.query(`
SELECT
pm.*,
pm.geometry_multiplier,
pm.base_quantity,
pm.waste_factor
FROM package_materials pm
WHERE pm.smart_package_id = ?
ORDER BY pm.material_category, pm.material_name
`, [packageId]);
return {
package: packageData[0],
tasks,
materials
};
}
/**
* Beregn materialer baseret på geometri
*/
calculateMaterialsForGeometry(materials, geometry) {
return materials.map(material => {
let quantity = material.base_quantity || 0;
// Apply geometry multiplier
switch (material.geometry_multiplier) {
case 'area':
quantity = geometry.total_area * material.base_quantity;
break;
case 'length':
quantity = geometry.length_main * material.base_quantity;
break;
case 'width':
quantity = geometry.width_main * material.base_quantity;
break;
case 'spaer_count':
quantity = geometry.spaer_count * material.base_quantity;
break;
case 'perimeter':
quantity = (2 * geometry.width_main + 2 * geometry.length_main) * material.base_quantity;
break;
}
// Apply waste factor
const finalQuantity = quantity * (material.waste_factor || 1.1);
return {
...material,
calculated_quantity: Math.ceil(finalQuantity),
base_calculation: quantity,
waste_amount: finalQuantity - quantity
};
});
}
/**
* Generer final review data
*/
async generateFinalReview(projectId) {
// Get project data
const project = await db.query(
'SELECT * FROM customer_projects WHERE id = ?',
[projectId]
);
// Get geometry
const geometry = await db.query(
'SELECT * FROM roof_geometry WHERE project_id = ?',
[projectId]
);
// Get selected packages
const packages = await db.query(`
SELECT sp.*, cpp.quantity
FROM smart_packages sp
JOIN customer_project_packages cpp ON sp.id = cpp.smart_package_id
WHERE cpp.project_id = ?
`, [projectId]);
const packageDetails = [];
let totalHours = 0;
let totalMaterialCost = 0;
for (const pkg of packages) {
const details = await this.getPackageWithOrderedTasks(pkg.id);
const materials = this.calculateMaterialsForGeometry(
details.materials,
geometry[0]
);
// Calculate costs
const packageHours = details.tasks.reduce((sum, task) =>
sum + (task.estimated_hours || 0), 0
);
const packageMaterialCost = materials.reduce((sum, mat) =>
sum + (mat.calculated_quantity * mat.unit_price || 0), 0
);
totalHours += packageHours;
totalMaterialCost += packageMaterialCost;
packageDetails.push({
package: pkg,
tasks: details.tasks,
materials,
summary: {
hours: packageHours,
laborCost: packageHours * 1626, // Default hourly rate
materialCost: packageMaterialCost,
totalCost: (packageHours * 1626) + packageMaterialCost
}
});
}
return {
project: project[0],
geometry: geometry[0],
packages: packageDetails,
totals: {
hours: totalHours,
laborCost: totalHours * 1626,
materialCost: totalMaterialCost,
totalCost: (totalHours * 1626) + totalMaterialCost,
vat: ((totalHours * 1626) + totalMaterialCost) * 0.25
}
};
}
}
module.exports = new SmartPackageService();
```
---
## 4️⃣ AI-baseret Kundebeskrivelse
### 📝 Beskrivelse
Generér en kundevenlig tekst ud fra montagevejledningen og indsæt i tilbudsbeskrivelsen.
### 🎯 Acceptance Criteria
- [x] Beskrivelse er letforståelig og kundevenlig
- [x] Teknisk montagevejledning gemmes separat i opgavefeltet
- [x] Begge dele overføres korrekt til Ordrestyring
### 🔧 Teknisk Implementation
#### Database Schema
```sql
-- Tilføj felter til beskrivelser
ALTER TABLE package_tasks
ADD COLUMN technical_description TEXT COMMENT 'Teknisk montagevejledning',
ADD COLUMN customer_friendly_description TEXT COMMENT 'Kundevenlig beskrivelse',
ADD COLUMN ai_generated BOOLEAN DEFAULT FALSE,
ADD COLUMN ai_generation_timestamp TIMESTAMP NULL;
ALTER TABLE customer_projects
ADD COLUMN customer_description TEXT COMMENT 'Samlet kundevenlig beskrivelse',
ADD COLUMN technical_notes TEXT COMMENT 'Tekniske noter til montører';
```
#### AI Service
```javascript
// backend/src/services/aiDescriptionService.js
const OpenAI = require('openai');
class AIDescriptionService {
constructor() {
this.openai = new OpenAI({
apiKey: process.env.OPENAI_API_KEY
});
}
/**
* Generér kundevenlig beskrivelse fra teknisk tekst
*/
async generateCustomerFriendlyDescription(technicalDescription, context = {}) {
const prompt = `
Du er en ekspert i at kommunikere byggeprojekter til kunder på en letforståelig måde.
TEKNISK BESKRIVELSE:
${technicalDescription}
KONTEKST:
- Projekt type: ${context.projectType || 'Byggeprojekt'}
- Område: ${context.area || 'Ikke specificeret'}
- Kunde niveau: ${context.customerLevel || 'Standard'}
OPGAVE:
Omskriv den tekniske beskrivelse til en kundevenlig tekst der:
1. Er let at forstå for en person uden byggefaglig baggrund
2. Fokuserer på fordele og resultatet for kunden
3. Undgår teknisk jargon (eller forklarer det simpelt)
4. Er positiv og professionel i tonen
5. Er max 3-4 sætninger
KUNDEVENLIG BESKRIVELSE:
`.trim();
try {
const completion = await this.openai.chat.completions.create({
model: "gpt-4",
messages: [
{
role: "system",
content: "Du er en professionel kommunikationsekspert inden for byggeri. Du omskriver tekniske beskrivelser til kundevenlige tekster."
},
{
role: "user",
content: prompt
}
],
temperature: 0.7,
max_tokens: 300
});
return completion.choices[0].message.content.trim();
} catch (error) {
console.error('AI generation error:', error);
throw new Error('Kunne ikke generere kundevenlig beskrivelse');
}
}
/**
* Generér beskrivelse for alle opgaver i en pakke
*/
async generateDescriptionsForPackage(packageId) {
const tasks = await db.query(
'SELECT * FROM package_tasks WHERE smart_package_id = ?',
[packageId]
);
const results = [];
for (const task of tasks) {
if (!task.technical_description) {
console.log(`⚠️ No technical description for task ${task.id}, skipping`);
continue;
}
const customerDescription = await this.generateCustomerFriendlyDescription(
task.technical_description,
{
projectType: 'Tag udskiftning',
area: 'Tag'
}
);
await db.query(`
UPDATE package_tasks
SET customer_friendly_description = ?,
ai_generated = TRUE,
ai_generation_timestamp = NOW()
WHERE id = ?
`, [customerDescription, task.id]);
results.push({
taskId: task.id,
taskName: task.task_name,
technical: task.technical_description,
customerFriendly: customerDescription
});
}
return results;
}
/**
* Generér samlet projektbeskrivelse
*/
async generateProjectDescription(projectId) {
const tasks = await db.query(`
SELECT
pt.customer_friendly_description,
pt.task_name,
pt.task_order,
sp.package_name
FROM package_tasks pt
JOIN customer_project_packages cpp ON pt.smart_package_id = cpp.smart_package_id
JOIN smart_packages sp ON sp.id = cpp.smart_package_id
WHERE cpp.project_id = ?
ORDER BY pt.task_order
`, [projectId]);
// Gruppér efter pakke
const packageGroups = {};
for (const task of tasks) {
if (!packageGroups[task.package_name]) {
packageGroups[task.package_name] = [];
}
packageGroups[task.package_name].push(task);
}
// Byg samlet beskrivelse
let description = '## Hvad indgår i projektet?\n\n';
for (const [packageName, packageTasks] of Object.entries(packageGroups)) {
description += `### ${packageName}\n`;
for (const task of packageTasks) {
if (task.customer_friendly_description) {
description += `- ${task.customer_friendly_description}\n`;
}
}
description += '\n';
}
await db.query(
'UPDATE customer_projects SET customer_description = ? WHERE id = ?',
[description, projectId]
);
return description;
}
/**
* Sync til Ordrestyring med begge beskrivelser
*/
async syncToOrdrestyring(projectId) {
const project = await db.query(
'SELECT * FROM customer_projects WHERE id = ?',
[projectId]
);
const tasks = await db.query(`
SELECT
pt.task_name,
pt.technical_description,
pt.customer_friendly_description,
pt.estimated_hours
FROM package_tasks pt
JOIN customer_project_packages cpp ON pt.smart_package_id = cpp.smart_package_id
WHERE cpp.project_id = ?
`, [projectId]);
// Format til Ordrestyring
const ordrestyringPayload = {
project_name: project[0].project_name,
customer_description: project[0].customer_description,
tasks: tasks.map(task => ({
name: task.task_name,
description: task.customer_friendly_description, // Til kunden
technical_notes: task.technical_description, // Til montører
estimated_hours: task.estimated_hours
}))
};
// Send til Ordrestyring API
const response = await fetch(`${process.env.ORDRESTYRING_API_URL}/projects`, {
method: 'POST',
headers: {
'Content-Type': 'application/json',
'Authorization': `Bearer ${process.env.ORDRESTYRING_API_TOKEN}`
},
body: JSON.stringify(ordrestyringPayload)
});
return await response.json();
}
}
module.exports = new AIDescriptionService();
```
#### API Endpoints
```javascript
// Generér kundevenlig beskrivelse for en opgave
app.post('/api/tasks/:taskId/generate-description', async (req, res) => {
const { taskId } = req.params;
const task = await db.query('SELECT * FROM package_tasks WHERE id = ?', [taskId]);
const description = await aiDescriptionService.generateCustomerFriendlyDescription(
task[0].technical_description
);
await db.query(
'UPDATE package_tasks SET customer_friendly_description = ?, ai_generated = TRUE WHERE id = ?',
[description, taskId]
);
res.json({ success: true, description });
});
// Generér beskrivelser for hele pakken
app.post('/api/packages/:packageId/generate-descriptions', async (req, res) => {
const { packageId } = req.params;
const results = await aiDescriptionService.generateDescriptionsForPackage(packageId);
res.json({ success: true, results });
});
// Generér samlet projektbeskrivelse
app.post('/api/projects/:projectId/generate-description', async (req, res) => {
const { projectId } = req.params;
const description = await aiDescriptionService.generateProjectDescription(projectId);
res.json({ success: true, description });
});
// Sync til Ordrestyring
app.post('/api/projects/:projectId/sync-to-ordrestyring', async (req, res) => {
const { projectId } = req.params;
const result = await aiDescriptionService.syncToOrdrestyring(projectId);
res.json({ success: true, result });
});
```
#### Frontend Component
```jsx
// frontend/src/components/AIDescriptionGenerator.js
function AIDescriptionGenerator({ taskId, technicalDescription, onGenerated }) {
const [loading, setLoading] = useState(false);
const [customerDescription, setCustomerDescription] = useState('');
const generateDescription = async () => {
setLoading(true);
try {
const response = await fetch(`/api/tasks/${taskId}/generate-description`, {
method: 'POST'
});
const result = await response.json();
if (result.success) {
setCustomerDescription(result.description);
onGenerated(result.description);
}
} catch (error) {
console.error('Error generating description:', error);
} finally {
setLoading(false);
}
};
return (