352 lines
16 KiB
JavaScript
352 lines
16 KiB
JavaScript
// -----------------------------
|
||
// Projektübersicht — Auslastung (Load) & Aufwand je Leistungsphase
|
||
// -----------------------------
|
||
// Modul für den Auslastungs-Tab der Hauptseite (Test.html, Ladereihenfolge:
|
||
// globals → utils → ui → date-picker → csv → server → store → weeks → board →
|
||
// people → projects → load → gantt → …). Es stellt renderLoad(), das LP-
|
||
// Aufwand-Modal und das Neues-Projekt-Modal bereit. Genutzt werden LPHS/ROLES
|
||
// aus js/globals.js, currentWeek()/save() aus js/store.js, guardWeekLocked()
|
||
// aus js/weeks.js sowie peopleByRole()/assignKey() aus js/utils.js.
|
||
// Die Auslastungs-Logik (berechneAuslastung, lpActiveList, faktorFormat,
|
||
// pdfLoadAmpelColor, LOAD_BAR_MAX) wird zusätzlich von js/pdf.js für den
|
||
// PDF-Export wiederverwendet.
|
||
//
|
||
// Datenmodell je Projekt (rollen- und leistungsphasenspezifisch):
|
||
// pr.aufwandProLP = {
|
||
// 'LPH 1': { Planung: 0.4, Projektleitung: 0.6, Bauüberwachung: 0.0 },
|
||
// ...
|
||
// } // Gewichtungsfaktor je Rolle (0.0–1.0)
|
||
// pr.aktuelleLP = ['LPH 6'] // aktuell amtierende Phase (max. 1)
|
||
//
|
||
// Es zählt genau eine amtierende Phase je Projekt ("Nur amtierende Einzelphase",
|
||
// Absprache mit dem Auftraggeber). Altdaten mit mehreren aktiven Phasen
|
||
// verwenden deterministisch die erste aktive Phase der Liste.
|
||
//
|
||
// Berechnungslogik:
|
||
// Auslastung(Mitarbeiter) = Σ Faktor der amtierenden LP je Projekt,
|
||
// in dem der Mitarbeiter (in seiner Rolle) zugewiesen ist.
|
||
// Der Faktor zählt 1:1 – die Zuordnungsart (Haupt/Optional) skaliert nicht.
|
||
// Leere Matrix-Felder zählen bei gesetzter aktiver LP mit dem Standard-Faktor
|
||
// 1,0; ohne gesetzte aktive LP zählt das Projekt 0 (nicht eingerechnet).
|
||
// "In Anbahnung" wird nicht eingerechnet.
|
||
//
|
||
// HINWEIS (Fachplaner-Fragen, bewusst NICHT eigenständig entschieden):
|
||
// - Ampel-Schwellen (50 % / 75 % des Maximalwerts) sind PLATZHALTER und müssen
|
||
// fachlich abgestimmt werden.
|
||
// - Mitarbeiterkapazität (Teilzeit/Vollzeit) existiert nicht – offener Punkt.
|
||
|
||
// AUFWAND_LPS: Phasen des Aufwandsmodells (LPH 1–8; "W+M" ist bewusst nicht
|
||
// enthalten, entspricht der Entscheidung "LP-Schema: lp1-8").
|
||
const AUFWAND_LPS = LPHS.slice(0, 8);
|
||
|
||
// LP_AUFWAND_VORLAGE: Standardwerte der Maske "Aufwand je Leistungsphase".
|
||
// Vorbefüllung beim Anlegen neuer Projekte sowie beim Öffnen der Maske für
|
||
// bestehende Projekte, die in einzelnen Feldern keine Werte haben – beim
|
||
// Speichern werden sie übernommen. Werte 0.0–1.0 je Rolle; 0 = kein Aufwand.
|
||
// Nicht gelistete Phasen/Rollen bleiben leer und zählen als Standard-Faktor 1,0.
|
||
// Hier im Code anpassen.
|
||
const LP_AUFWAND_VORLAGE = {
|
||
'LPH 1': { Planung: 0.4, Projektleitung: 0.2, Bauüberwachung: 0 },
|
||
'LPH 2': { Planung: 0.4, Projektleitung: 0.2, Bauüberwachung: 0 },
|
||
'LPH 3': { Planung: 1.0, Projektleitung: 0.3, Bauüberwachung: 0 },
|
||
'LPH 4': { Planung: 0.0, Projektleitung: 0.3, Bauüberwachung: 0 },
|
||
'LPH 5': { Planung: 1.0, Projektleitung: 0.4, Bauüberwachung: 0 },
|
||
'LPH 6': { Planung: 0.2, Projektleitung: 0.7, Bauüberwachung: 0.3 },
|
||
'LPH 7': { Planung: 0.1, Projektleitung: 0.3, Bauüberwachung: 0.5 },
|
||
'LPH 8': { Planung: 0, Projektleitung: 0.2, Bauüberwachung: 1.0 }
|
||
};
|
||
|
||
// PLATZHALTER! Ampel-Schwellen als Anteil des Maximalwerts LOAD_BAR_MAX
|
||
// (gelb ab 50 %, rot ab 75 %). Müssen vom Fachplaner bestätigt werden.
|
||
const THRESHOLD_RATIO_CRITICAL = 0.75;
|
||
const THRESHOLD_RATIO_ELEVATED = 0.50;
|
||
|
||
// lpActiveList: liefert die amtierenden Leistungsphasen eines Projekts,
|
||
// gefiltert auf das Aufwandsmodell (LPH 1–8). Parameter: pr = Projektobjekt.
|
||
// Rückgabe: Array von LP-Namen (leer, wenn keine aktive Phase passt).
|
||
function lpActiveList(pr){
|
||
const a = pr && pr.aktuelleLP;
|
||
if(Array.isArray(a)) return a.filter(l => AUFWAND_LPS.includes(l));
|
||
if(typeof a === 'string' && AUFWAND_LPS.includes(a)) return [a];
|
||
return [];
|
||
}
|
||
|
||
// aufwandMatrixWert: Rollenwert eines Projekts für eine Leistungsphase
|
||
// (Gewichtungsfaktor, 0,0–1,0). Liefert null, wenn keine (rollenspezifische) Matrix
|
||
// bzw. kein Wert für diese Phase/Rolle hinterlegt ist. 0 ist ein gültiger Wert.
|
||
function aufwandMatrixWert(projekt, lp, rolle){
|
||
const m = projekt && projekt.aufwandProLP;
|
||
const entry = (m && typeof m === 'object') ? m[lp] : undefined;
|
||
if(!entry || typeof entry !== 'object' || Array.isArray(entry)) return null;
|
||
const v = parseFloat(entry[rolle]);
|
||
return isNaN(v) ? null : v;
|
||
}
|
||
|
||
// berechneAuslastung: zentrale Auslastungsberechnung einer Zuordnung
|
||
// (Person/Rolle) zu einem Projekt für die amtierende Leistungsphase.
|
||
// Ohne gesetzte aktive LP zählt das Projekt 0 (nicht eingerechnet).
|
||
// Mit aktiver LP: Liegt aufwandProLP[aktuelleLP][rolle] vor, zählt dieser
|
||
// Faktor 1:1 – die Zuordnungsart (Haupt/Optional) skaliert bewusst nicht mehr.
|
||
// Fehlt der Matrix-Wert, gilt der Standard-Faktor 1,0.
|
||
// "In Anbahnung" wird nicht eingerechnet.
|
||
function berechneAuslastung(mitarbeiter, projekt, aktuelleLP, rolle, status){
|
||
if(!projekt || projekt.group === 'In Anbahnung') return { load: 0, anbahnung: true };
|
||
if(!aktuelleLP) return { load: 0 };
|
||
const wert = aufwandMatrixWert(projekt, aktuelleLP, rolle);
|
||
if(wert !== null) return { load: wert };
|
||
return { load: 1.0 };
|
||
}
|
||
|
||
// faktorFormat: formatiert einen Auslastungs-Faktor in deutscher Notation
|
||
// (Komma, max. 2 Nachkommastellen), z. B. 1.1 → "1,10". 1,0 = 100 % Kapazität.
|
||
function faktorFormat(x){
|
||
const n = Math.round((x || 0) * 100) / 100;
|
||
return n.toFixed(2).replace('.', ',');
|
||
}
|
||
|
||
// loadAmpelColor: Ampel-Farbe relativ zum Maximalwert (gelb ab 50 %,
|
||
// rot ab 75 % von LOAD_BAR_MAX; PLATZHALTER).
|
||
function loadAmpelColor(x){
|
||
return x >= LOAD_BAR_MAX * THRESHOLD_RATIO_CRITICAL ? '#c53030' : x >= LOAD_BAR_MAX * THRESHOLD_RATIO_ELEVATED ? '#d69e2e' : '#2f855a';
|
||
}
|
||
// pdfLoadAmpelColor: Ampel-Farbe für den PDF-Export (js/pdf.js) mit gleichen
|
||
// Schwellen wie loadAmpelColor, aber dunkleren, druckfreundlichen Farbtönen.
|
||
function pdfLoadAmpelColor(x){
|
||
return x >= LOAD_BAR_MAX * THRESHOLD_RATIO_CRITICAL ? '#D70015' : x >= LOAD_BAR_MAX * THRESHOLD_RATIO_ELEVATED ? '#B25000' : '#248A3D';
|
||
}
|
||
|
||
// ---------- LP-Aufwand Eingabemaske ----------
|
||
|
||
// lpModalProjectId: Projekt-ID des aktuell offenen LP-Aufwand-Modals (null = geschlossen).
|
||
let lpModalProjectId = null;
|
||
|
||
// lpRowsHtml: erzeugt die Aufwand-Maske als Matrix-Tabelle.
|
||
// Zeilen = Leistungsphasen (LPH 1–8), Spalten = Rollen (Planung/Projektleitung/
|
||
// Bauüberwachung). Die amtierende Leistungsphase wird pro Projekt im Tab
|
||
// "Projekte" gewählt (renderProjects / editProjectActiveLP).
|
||
// prefix: 'lp' = Bearbeiten-Modal, 'np' = Neues-Projekt-Modal (eindeutige IDs).
|
||
// Leere Felder werden mit den Standardwerten aus LP_AUFWAND_VORLAGE vorbefüllt.
|
||
// Die Feld-IDs bleiben identisch, damit collectLpRows() unverändert funkioniert.
|
||
function lpRowsHtml(p, prefix){
|
||
const head = ROLES.map(r => `<th>${esc(r)}</th>`).join('');
|
||
const rows = AUFWAND_LPS.map(l => {
|
||
const idx = l.replace(/[^\d]/g,'');
|
||
const row = (p.aufwandProLP && typeof p.aufwandProLP[l] === 'object') ? p.aufwandProLP[l] : {};
|
||
const cells = ROLES.map((r, ri) => {
|
||
const raw = row[r];
|
||
const vorlage = LP_AUFWAND_VORLAGE && LP_AUFWAND_VORLAGE[l] ? LP_AUFWAND_VORLAGE[l][r] : undefined;
|
||
const base = (raw !== undefined && raw !== null && raw !== '') ? raw
|
||
: (vorlage !== undefined && vorlage !== null && vorlage !== '') ? vorlage : '';
|
||
const val = base !== '' ? String(parseFloat(base)).replace('.', ',') : '';
|
||
return `<td><input type="text" inputmode="decimal" id="${prefix}Val${idx}R${ri}" value="${val}" placeholder="1,0"></td>`;
|
||
}).join('');
|
||
return `<tr><th class="lp-lph">${l}</th>${cells}</tr>`;
|
||
}).join('');
|
||
return `<table class="lp-matrix">
|
||
<thead><tr><th class="lp-lph">Leistungsphase</th>${head}</tr></thead>
|
||
<tbody>${rows}</tbody>
|
||
</table>`;
|
||
}
|
||
|
||
// collectLpRows: liest die Aufwand-Maske aus und validiert die Werte (0–1).
|
||
// Rückgabe: { aufwand, hasValue } oder null bei Eingabefehler.
|
||
function collectLpRows(prefix){
|
||
const aufwand = {};
|
||
let hasValue = false;
|
||
for(const l of AUFWAND_LPS){
|
||
const idx = l.replace(/[^\d]/g,'');
|
||
const entry = {};
|
||
let rowHasValue = false;
|
||
let invalid = false;
|
||
for(let ri = 0; ri < ROLES.length; ri++){
|
||
const r = ROLES[ri];
|
||
const input = document.getElementById(prefix + 'Val' + idx + 'R' + ri);
|
||
if(!input) continue;
|
||
const raw = input.value.trim().replace(',', '.');
|
||
if(raw === '') continue;
|
||
const v = parseFloat(raw);
|
||
if(isNaN(v) || v < 0 || v > 1){
|
||
alert('Bitte Werte zwischen 0 und 1 eintragen (z. B. 0,4) – oder das Feld leer lassen. (' + l + ', ' + r + ')');
|
||
invalid = true;
|
||
break;
|
||
}
|
||
entry[r] = v;
|
||
rowHasValue = true;
|
||
}
|
||
if(invalid) return null;
|
||
if(rowHasValue){ aufwand[l] = entry; hasValue = true; }
|
||
}
|
||
return { aufwand, hasValue };
|
||
}
|
||
|
||
// applyLpRows: übernimmt das Ergebnis von collectLpRows auf ein Projekt.
|
||
// Die Maske ist mit den Standardwerten (LP_AUFWAND_VORLAGE) vorbefüllt;
|
||
// Felder ohne Vorbefüllung, die leer bleiben, zählen bei gesetzter aktiver LP
|
||
// später als Standard-Faktor 1,0; ohne aktive LP zählt das Projekt 0.
|
||
// Die amtierende Leistungsphase wird separat über den Tab "Projekte" gesetzt.
|
||
function applyLpRows(p, lp){
|
||
if(!lp) return false;
|
||
p.aufwandProLP = lp.hasValue ? lp.aufwand : undefined;
|
||
return true;
|
||
}
|
||
|
||
// openLpModal: öffnet das Modal "Aufwand je Leistungsphase" für ein Projekt.
|
||
// Parameter: pid = Projekt-ID; gesperrte Wochen werden abgewiesen. Kein Rückgabewert.
|
||
function openLpModal(pid){
|
||
if(guardWeekLocked()) return;
|
||
const p = currentWeek().projects.find(x=>x.id===pid);
|
||
if(!p) return;
|
||
lpModalProjectId = pid;
|
||
const titleEl = document.getElementById('lpModalProject');
|
||
if(titleEl) titleEl.textContent = (p.nr ? p.nr + ' – ' : '') + (p.name || '');
|
||
const rowsEl = document.getElementById('lpModalRows');
|
||
if(rowsEl) rowsEl.innerHTML = lpRowsHtml(p, 'lp');
|
||
document.getElementById('lpModal').style.display = 'flex';
|
||
}
|
||
|
||
// closeLpModal: blendet das LP-Aufwand-Modal aus und setzt lpModalProjectId zurück.
|
||
function closeLpModal(){
|
||
document.getElementById('lpModal').style.display = 'none';
|
||
lpModalProjectId = null;
|
||
}
|
||
|
||
// saveLpModal: liest die LP-Maske aus, übernimmt sie auf das Projekt, speichert
|
||
// und rendert Board, Projekte und Auslastung neu; danach schließt sich das Modal.
|
||
function saveLpModal(){
|
||
if(guardWeekLocked()) return;
|
||
const p = currentWeek().projects.find(x=>x.id===lpModalProjectId);
|
||
if(!p) return;
|
||
const lp = collectLpRows('lp');
|
||
if(lp === null) return;
|
||
if(applyLpRows(p, lp)) save();
|
||
renderBoard(); renderProjects(); renderLoad();
|
||
closeLpModal();
|
||
}
|
||
|
||
// ---------- Neues Projekt (mit LP-Aufwand beim Anlegen) ----------
|
||
|
||
// openNewProjModal: öffnet das Modal "Neues Projekt" mit geleerten Eingaben,
|
||
// der Auswahl der aktiven LP und einer leeren Aufwand-Maske (prefix 'np').
|
||
function openNewProjModal(){
|
||
if(guardWeekLocked()) return;
|
||
document.getElementById('newProjNr').value = '';
|
||
document.getElementById('newProjName').value = '';
|
||
document.getElementById('newProjGroup').value = 'Aktive Projekte';
|
||
const lpSel = document.getElementById('newProjActiveLP');
|
||
if(lpSel){
|
||
lpSel.innerHTML = '<option value="">Keine</option>' + AUFWAND_LPS.map(l => `<option value="${l}">${l}</option>`).join('');
|
||
lpSel.value = '';
|
||
}
|
||
const rowsEl = document.getElementById('newProjLpRows');
|
||
if(rowsEl) rowsEl.innerHTML = lpRowsHtml({ aufwandProLP: {}, aktuelleLP: [] }, 'np');
|
||
document.getElementById('newProjModal').style.display = 'flex';
|
||
}
|
||
|
||
// closeNewProjModal: blendet das Neues-Projekt-Modal aus.
|
||
function closeNewProjModal(){
|
||
document.getElementById('newProjModal').style.display = 'none';
|
||
}
|
||
|
||
// saveNewProj: legt ein neues Projekt an (Nr., Name, Gruppe, aktive LP,
|
||
// optionaler LP-Aufwand), berechnet seine Reihenfolge in der Gruppe, speichert
|
||
// und rendert Projekte und Board neu. Kein Rückgabewert.
|
||
function saveNewProj(){
|
||
if(guardWeekLocked()) return;
|
||
const nr = document.getElementById('newProjNr').value.trim();
|
||
const name = document.getElementById('newProjName').value.trim();
|
||
if(!name){ alert("Bitte Projektbezeichnung eingeben."); return; }
|
||
const group = document.getElementById('newProjGroup').value;
|
||
const activeLP = document.getElementById('newProjActiveLP').value;
|
||
const lp = collectLpRows('np');
|
||
if(lp === null) return;
|
||
const w = currentWeek();
|
||
const nextOrder = w.projects
|
||
.filter(p=>p.group===group)
|
||
.reduce((max,p)=> Math.max(max, p.order!==undefined ? p.order : 0), -1) + 1;
|
||
const pr = {id:uid(),nr,name,group,status:'',lph:{},assign:{}, statusState: undefined, order: nextOrder, plan: null};
|
||
if(activeLP) pr.aktuelleLP = [activeLP];
|
||
applyLpRows(pr, lp);
|
||
w.projects.push(pr);
|
||
save(); renderProjects(); renderBoard();
|
||
closeNewProjModal();
|
||
}
|
||
|
||
// LOAD_BAR_MAX: Maximalwert der Balken-Skala im Auslastungs-Tab (und im
|
||
// PDF-Export). 1,0 = 100 % Kapazität; Werte > 1,0 = Überlastung (rot).
|
||
const LOAD_BAR_MAX = 8;
|
||
|
||
// renderLoad: berechnet die Belastung der Personen auf Basis des
|
||
// rollenspezifischen LP-Gewichtungsfaktors je amtierender Phase (0,0–1,0,
|
||
// Standard 1,0). Leere Matrix-Werte zählen bei gesetzter aktiver LP als 1,0;
|
||
// ohne gesetzte aktive LP zählt das Projekt 0 (nicht eingerechnet).
|
||
// Ampel: Schwellen relativ zum Maximalwert LOAD_BAR_MAX
|
||
// (gelb ab 50 %, rot ab 75 % – PLATZHALTER).
|
||
// Balken: Skala auf das feste Maximum LOAD_BAR_MAX (Standard 8).
|
||
function renderLoad(){
|
||
const scope = document.getElementById('loadScope').value;
|
||
const barMax = LOAD_BAR_MAX;
|
||
const selectedWeek = currentWeek();
|
||
const weeks = scope==='all' ? db.weeks : (selectedWeek ? [selectedWeek] : []);
|
||
if(weeks.length === 0){
|
||
document.getElementById('loadGrid').innerHTML = '<div class="hint">Keine Sitzung ausgewählt oder die Daten werden noch geladen.</div>';
|
||
return;
|
||
}
|
||
const grouped = scope==='all' ? peopleByRole(db.weeks) : peopleByRole(selectedWeek);
|
||
const stats = {};
|
||
ROLES.forEach(r=>{
|
||
grouped[r].forEach(entry=>{
|
||
stats[assignKey(entry.person.id, r)] = {load:0,projects:{},anbahnung:0};
|
||
});
|
||
});
|
||
|
||
weeks.forEach(w=>{
|
||
w.projects.forEach(pr=>{
|
||
const aktivePhase = lpActiveList(pr)[0];
|
||
Object.keys(pr.assign).forEach(aKey=>{
|
||
const s = stats[aKey];
|
||
if(!s) return;
|
||
const st = pr.assign[aKey];
|
||
const rolle = aKey.slice(aKey.indexOf('|') + 1);
|
||
const al = berechneAuslastung(null, pr, aktivePhase, rolle, st);
|
||
if(al.anbahnung){
|
||
if(st===1 || st===2) s.anbahnung++;
|
||
return;
|
||
}
|
||
if(al.load > 0){
|
||
s.load += al.load;
|
||
s.projects[pr.name] = (s.projects[pr.name]||0)+1;
|
||
}
|
||
});
|
||
});
|
||
});
|
||
|
||
// Hochgerechnete Auslastung: durchschnittliche Wochenlast als Faktor
|
||
// der Kapazität (1,0 = 100 %). Werte > 1,0 = Überlastung.
|
||
const nWeeks = Math.max(1, weeks.length);
|
||
const weekAvg = k => stats[k].load / nWeeks;
|
||
let html="";
|
||
ROLES.forEach(r=>{
|
||
html += `<div class="load-row"><div class="load-row-title">${r}</div>`;
|
||
if(grouped[r].length===0){
|
||
html += `<div class="hint">Keine Personen.</div>`;
|
||
}
|
||
grouped[r].forEach(entry=>{
|
||
const s = stats[assignKey(entry.person.id, r)];
|
||
const avg = weekAvg(assignKey(entry.person.id, r));
|
||
// Balken relativ zur einstellbaren Skala (Standard 8); Überlastung > 1,0
|
||
// bleibt über die Ampel-Farbe sichtbar, der Zahlenwert bleibt ungedeckelt.
|
||
const pct = Math.min(100, Math.round(avg / barMax * 100));
|
||
const detail = Object.keys(s.projects).map(k=>`<div><span>${esc(k)}</span><b>${s.projects[k]}×</b></div>`).join('') || '<div class="hint">keine Zuordnung</div>';
|
||
const anbahnungBadge = (s.anbahnung && s.anbahnung>0) ? `<span style="font-size:11px;color:#3182ce;font-weight:normal;margin-left:0px">(${s.anbahnung} in Anbahnung)</span>` : '';
|
||
html += `<div class="load-card">
|
||
<h3>${esc(entry.person.fullName)} <span style="font-size:11px;color:#888;font-weight:normal">(${r})</span></h3>
|
||
<h3>${anbahnungBadge}</h3>
|
||
<div class="load-num">${faktorFormat(avg)}</div>
|
||
<div class="bar" style="height:10px;margin-top:6px" title="Skala: 0 – ${faktorFormat(barMax)}"><div style="width:${pct}%;background:${loadAmpelColor(avg)}"></div></div>
|
||
<div class="load-detail">${detail}</div>
|
||
</div>`;
|
||
});
|
||
html += `</div>`;
|
||
});
|
||
document.getElementById('loadGrid').innerHTML=html;
|
||
} |