This commit is contained in:
Lars committed 2026-07-06 19:08:24 +02:00
1 parent 911dcace72
commit 9c68c414d8
53 files changed
+2919 -469

No files matched your search

+1
View File
@@ -1,5 +1,6 @@
export * from './types'
export { db } from './schema'
export * from './queries'
export {
seedIfEmpty,
seedFeedbackStructureIfEmpty,
+6
View File
@@ -0,0 +1,6 @@
import { rpc } from '../rpcClient'
export const getRatingTrendWeightStep = (): Promise<number> => rpc('appSettings', 'getRatingTrendWeightStep')
export const getOrSeedRatingTrendWeightStep = (): Promise<number> => rpc('appSettings', 'getOrSeedRatingTrendWeightStep')
export const saveRatingTrendWeightStep = (weightStep: number): Promise<number> =>
rpc('appSettings', 'saveRatingTrendWeightStep', weightStep)
+13
View File
@@ -0,0 +1,13 @@
import { rpc } from '../rpcClient'
import type { Assessment } from '../types'
export const listAssessmentsAll = (): Promise<Assessment[]> => rpc('assessments', 'listAssessmentsAll')
export const listAssessmentsForMeeting = (meetingInstanceId: number): Promise<Assessment[]> =>
rpc('assessments', 'listAssessmentsForMeeting', meetingInstanceId)
export const listAssessmentsForMeetings = (meetingInstanceIds: number[]): Promise<Assessment[]> =>
rpc('assessments', 'listAssessmentsForMeetings', meetingInstanceIds)
export const addAssessment = (a: Omit<Assessment, 'id'>): Promise<number> => rpc('assessments', 'addAssessment', a)
export const updateAssessment = (id: number, patch: Partial<Assessment>): Promise<number> =>
rpc('assessments', 'updateAssessment', id, patch)
export const deleteAssessmentsForMeeting = (meetingInstanceId: number): Promise<number> =>
rpc('assessments', 'deleteAssessmentsForMeeting', meetingInstanceId)
+41
View File
@@ -0,0 +1,41 @@
import { rpc } from '../rpcClient'
import type { FeedbackDraft, AssignmentFeedback, FeedbackCategoryRating, FeedbackDimensionText } from '../types'
export const getFeedbackDraft = (assignmentId: number, instituteeId: number): Promise<FeedbackDraft | undefined> =>
rpc('assignmentFeedback', 'getFeedbackDraft', assignmentId, instituteeId)
export const addFeedbackDraft = (d: Omit<FeedbackDraft, 'id'>): Promise<number> => rpc('assignmentFeedback', 'addFeedbackDraft', d)
export const updateFeedbackDraft = (id: number, patch: Partial<FeedbackDraft>): Promise<number> =>
rpc('assignmentFeedback', 'updateFeedbackDraft', id, patch)
export const getAssignmentFeedback = (assignmentId: number, instituteeId: number): Promise<AssignmentFeedback | undefined> =>
rpc('assignmentFeedback', 'getAssignmentFeedback', assignmentId, instituteeId)
export const getAssignmentFeedbackById = (id: number): Promise<AssignmentFeedback | undefined> =>
rpc('assignmentFeedback', 'getAssignmentFeedbackById', id)
export const addAssignmentFeedback = (f: Omit<AssignmentFeedback, 'id'>): Promise<number> =>
rpc('assignmentFeedback', 'addAssignmentFeedback', f)
export const updateAssignmentFeedback = (id: number, patch: Partial<AssignmentFeedback>): Promise<number> =>
rpc('assignmentFeedback', 'updateAssignmentFeedback', id, patch)
export const getOrCreateAssignmentFeedback = (
assignmentId: number,
instituteeId: number,
): Promise<AssignmentFeedback | undefined> => rpc('assignmentFeedback', 'getOrCreateAssignmentFeedback', assignmentId, instituteeId)
export const listFeedbackCategoryRatings = (assignmentFeedbackId: number): Promise<FeedbackCategoryRating[]> =>
rpc('assignmentFeedback', 'listFeedbackCategoryRatings', assignmentFeedbackId)
export const addFeedbackCategoryRating = (r: Omit<FeedbackCategoryRating, 'id'>): Promise<number> =>
rpc('assignmentFeedback', 'addFeedbackCategoryRating', r)
export const updateFeedbackCategoryRating = (id: number, patch: Partial<FeedbackCategoryRating>): Promise<number> =>
rpc('assignmentFeedback', 'updateFeedbackCategoryRating', id, patch)
export const listFeedbackDimensionTexts = (assignmentFeedbackId: number): Promise<FeedbackDimensionText[]> =>
rpc('assignmentFeedback', 'listFeedbackDimensionTexts', assignmentFeedbackId)
export const getFeedbackDimensionText = (
assignmentFeedbackId: number,
feedbackDimensionId: number,
): Promise<FeedbackDimensionText | undefined> =>
rpc('assignmentFeedback', 'getFeedbackDimensionText', assignmentFeedbackId, feedbackDimensionId)
export const addFeedbackDimensionText = (t: Omit<FeedbackDimensionText, 'id'>): Promise<number> =>
rpc('assignmentFeedback', 'addFeedbackDimensionText', t)
export const updateFeedbackDimensionText = (id: number, patch: Partial<FeedbackDimensionText>): Promise<number> =>
rpc('assignmentFeedback', 'updateFeedbackDimensionText', id, patch)
+23
View File
@@ -0,0 +1,23 @@
import { rpc } from '../rpcClient'
import type { AssignmentType, PhaseTemplate } from '../types'
export const listAssignmentTypes = (): Promise<AssignmentType[]> => rpc('assignmentTypes', 'listAssignmentTypes')
export const getAssignmentType = (id: number): Promise<AssignmentType | undefined> => rpc('assignmentTypes', 'getAssignmentType', id)
export const addAssignmentType = (type: Omit<AssignmentType, 'id'>): Promise<number> =>
rpc('assignmentTypes', 'addAssignmentType', type)
export const updateAssignmentType = (id: number, patch: Partial<AssignmentType>): Promise<number> =>
rpc('assignmentTypes', 'updateAssignmentType', id, patch)
/** Löscht nur, wenn keine Assignments mehr diesen Typ referenzieren (Cascade auf phaseTemplates sonst). */
export const deleteAssignmentType = (id: number): Promise<{ ok: true } | { ok: false; assignmentCount: number }> =>
rpc('assignmentTypes', 'deleteAssignmentType', id)
export const listPhaseTemplates = (): Promise<PhaseTemplate[]> => rpc('assignmentTypes', 'listPhaseTemplates')
export const getPhaseTemplate = (id: number): Promise<PhaseTemplate | undefined> => rpc('assignmentTypes', 'getPhaseTemplate', id)
export const listPhaseTemplatesForType = (assignmentTypeId: number): Promise<PhaseTemplate[]> =>
rpc('assignmentTypes', 'listPhaseTemplatesForType', assignmentTypeId)
export const addPhaseTemplate = (tmpl: Omit<PhaseTemplate, 'id'>): Promise<number> =>
rpc('assignmentTypes', 'addPhaseTemplate', tmpl)
export const updatePhaseTemplate = (id: number, patch: Partial<PhaseTemplate>): Promise<number> =>
rpc('assignmentTypes', 'updatePhaseTemplate', id, patch)
export const deletePhaseTemplate = (id: number): Promise<void> => rpc('assignmentTypes', 'deletePhaseTemplate', id)
+17
View File
@@ -0,0 +1,17 @@
import { rpc } from '../rpcClient'
import type { Assignment } from '../types'
export const listAssignments = (): Promise<Assignment[]> => rpc('assignments', 'listAssignments')
export const listAssignmentsNewestFirst = (): Promise<Assignment[]> => rpc('assignments', 'listAssignmentsNewestFirst')
export const getAssignment = (id: number): Promise<Assignment | undefined> => rpc('assignments', 'getAssignment', id)
export const addAssignment = (a: Omit<Assignment, 'id'>): Promise<number> => rpc('assignments', 'addAssignment', a)
export const updateAssignment = (id: number, patch: Partial<Assignment>): Promise<number> =>
rpc('assignments', 'updateAssignment', id, patch)
export interface AssignmentWithDetails extends Assignment {
typeName: string
instituteeNames: string[]
}
/** Für die Dashboard-Liste: Assignments mit aufgelöstem Typ- und Institutee-Namen, neueste zuerst. */
export const listAssignmentsWithDetails = (): Promise<AssignmentWithDetails[]> => rpc('assignments', 'listAssignmentsWithDetails')
+12
View File
@@ -0,0 +1,12 @@
import { rpc } from '../rpcClient'
import type { Group, Consultant } from '../types'
export const listGroups = (): Promise<Group[]> => rpc('consultants', 'listGroups')
export const addGroup = (group: Omit<Group, 'id'>): Promise<number> => rpc('consultants', 'addGroup', group)
export const listConsultants = (): Promise<Consultant[]> => rpc('consultants', 'listConsultants')
export const getConsultant = (id: number): Promise<Consultant | undefined> => rpc('consultants', 'getConsultant', id)
export const getConsultantsByIds = (ids: number[]): Promise<Consultant[]> => rpc('consultants', 'getConsultantsByIds', ids)
export const addConsultant = (consultant: Omit<Consultant, 'id'>): Promise<number> => rpc('consultants', 'addConsultant', consultant)
export const updateConsultant = (id: number, patch: Partial<Consultant>): Promise<number> => rpc('consultants', 'updateConsultant', id, patch)
export const deleteConsultant = (id: number): Promise<void> => rpc('consultants', 'deleteConsultant', id)
+21
View File
@@ -0,0 +1,21 @@
import { rpc } from '../rpcClient'
import type { ConversationEntry, ConversationSkillScore } from '../types'
export const listConversationEntriesForMeeting = (meetingInstanceId: number): Promise<ConversationEntry[]> =>
rpc('conversationEntries', 'listConversationEntriesForMeeting', meetingInstanceId)
export const listConversationEntriesForMeetings = (meetingInstanceIds: number[]): Promise<ConversationEntry[]> =>
rpc('conversationEntries', 'listConversationEntriesForMeetings', meetingInstanceIds)
export const addConversationEntry = (e: Omit<ConversationEntry, 'id'>): Promise<number> =>
rpc('conversationEntries', 'addConversationEntry', e)
export const updateConversationEntry = (id: number, patch: Partial<ConversationEntry>): Promise<number> =>
rpc('conversationEntries', 'updateConversationEntry', id, patch)
export const deleteConversationEntry = (id: number): Promise<void> => rpc('conversationEntries', 'deleteConversationEntry', id)
export const listConversationSkillScoresAll = (): Promise<ConversationSkillScore[]> =>
rpc('conversationEntries', 'listConversationSkillScoresAll')
export const addConversationSkillScore = (s: Omit<ConversationSkillScore, 'id'>): Promise<number> =>
rpc('conversationEntries', 'addConversationSkillScore', s)
export const updateConversationSkillScore = (id: number, patch: Partial<ConversationSkillScore>): Promise<number> =>
rpc('conversationEntries', 'updateConversationSkillScore', id, patch)
export const deleteConversationSkillScoresForEntry = (conversationEntryId: number): Promise<number> =>
rpc('conversationEntries', 'deleteConversationSkillScoresForEntry', conversationEntryId)
+56
View File
@@ -0,0 +1,56 @@
import { rpc } from '../rpcClient'
import type { FeedbackDimension, FeedbackCategory, FeedbackCriterionItem } from '../types'
export interface FeedbackStructure {
dimensions: FeedbackDimension[]
categories: FeedbackCategory[]
items: FeedbackCriterionItem[]
}
/** Vollständige, nach `order` sortierte Feedback-Taxonomie. */
export const loadFeedbackStructure = (): Promise<FeedbackStructure> => rpc('feedbackStructure', 'loadFeedbackStructure')
/** Unsortierte Rohtabellen — für Stellen, die selbst filtern/sortieren (z.B. MeetingView, AssignmentDetail). */
export const listFeedbackCategoriesOrdered = (): Promise<FeedbackCategory[]> => rpc('feedbackStructure', 'listFeedbackCategoriesOrdered')
export const listFeedbackCategoriesAll = (): Promise<FeedbackCategory[]> => rpc('feedbackStructure', 'listFeedbackCategoriesAll')
export const listFeedbackCriterionItemsAll = (): Promise<FeedbackCriterionItem[]> => rpc('feedbackStructure', 'listFeedbackCriterionItemsAll')
export const getFeedbackCriterionItemsByIds = (ids: number[]): Promise<FeedbackCriterionItem[]> =>
rpc('feedbackStructure', 'getFeedbackCriterionItemsByIds', ids)
/**
* "AssignmentType.criteriaIds restrict die sichtbaren Kriterien" — identische Filterlogik, die zuvor
* in MeetingView.tsx und AssignmentDetail.tsx dupliziert war. Leere/undefined criteriaIds = alles sichtbar.
* Reine Client-Berechnung, kein Server-Roundtrip nötig.
*/
export function filterVisibleFeedbackStructure<
C extends { id?: number },
I extends { id?: number; categoryId: number },
>(allCategories: C[], allItems: I[], criteriaIds: number[] | undefined): { categories: C[]; items: I[] } {
const itemFilter = criteriaIds?.length ? new Set(criteriaIds) : null
const items = itemFilter ? allItems.filter(i => itemFilter.has(i.id!)) : allItems
const visibleCatIds = new Set(items.map(i => i.categoryId))
const categories = itemFilter ? allCategories.filter(c => visibleCatIds.has(c.id!)) : allCategories
return { categories, items }
}
export const addFeedbackDimension = (d: Omit<FeedbackDimension, 'id'>): Promise<number> =>
rpc('feedbackStructure', 'addFeedbackDimension', d)
export const updateFeedbackDimension = (id: number, patch: Partial<FeedbackDimension>): Promise<number> =>
rpc('feedbackStructure', 'updateFeedbackDimension', id, patch)
/** Cascade: Items der Kategorien → Kategorien → Dimension. */
export const deleteFeedbackDimension = (id: number): Promise<void> => rpc('feedbackStructure', 'deleteFeedbackDimension', id)
export const addFeedbackCategory = (c: Omit<FeedbackCategory, 'id'>): Promise<number> =>
rpc('feedbackStructure', 'addFeedbackCategory', c)
export const updateFeedbackCategory = (id: number, patch: Partial<FeedbackCategory>): Promise<number> =>
rpc('feedbackStructure', 'updateFeedbackCategory', id, patch)
/** Cascade: Items der Kategorie → Kategorie. */
export const deleteFeedbackCategory = (id: number): Promise<void> => rpc('feedbackStructure', 'deleteFeedbackCategory', id)
export const addFeedbackCriterionItem = (i: Omit<FeedbackCriterionItem, 'id'>): Promise<number> =>
rpc('feedbackStructure', 'addFeedbackCriterionItem', i)
export const updateFeedbackCriterionItem = (id: number, patch: Partial<FeedbackCriterionItem>): Promise<number> =>
rpc('feedbackStructure', 'updateFeedbackCriterionItem', id, patch)
export const deleteFeedbackCriterionItem = (id: number): Promise<void> => rpc('feedbackStructure', 'deleteFeedbackCriterionItem', id)
+9
View File
@@ -0,0 +1,9 @@
export * from './appSettings'
export * from './consultants'
export * from './assignmentTypes'
export * from './assignments'
export * from './feedbackStructure'
export * from './meetings'
export * from './conversationEntries'
export * from './assessments'
export * from './assignmentFeedback'
+39
View File
@@ -0,0 +1,39 @@
import { rpc } from '../rpcClient'
import type {
MeetingInstance, PhaseTemplate, Assignment, Consultant,
ConversationEntry, ConversationSkillScore, Assessment,
} from '../types'
export const getMeetingInstance = (id: number): Promise<MeetingInstance | undefined> => rpc('meetings', 'getMeetingInstance', id)
export const listMeetingInstancesForAssignment = (assignmentId: number): Promise<MeetingInstance[]> =>
rpc('meetings', 'listMeetingInstancesForAssignment', assignmentId)
/**
* Kanonischer Filter für Aggregationen über mehrere Meetings: Papierkorb-/unfertige Meetings ausschließen,
* chronologisch sortiert. Siehe CLAUDE.md — immer diese Funktion nutzen, nicht erneut inline filtern.
*/
export const listDoneMeetingsChronological = (assignmentId: number): Promise<MeetingInstance[]> =>
rpc('meetings', 'listDoneMeetingsChronological', assignmentId)
export const addMeetingInstance = (m: Omit<MeetingInstance, 'id'>): Promise<number> => rpc('meetings', 'addMeetingInstance', m)
export const updateMeetingInstance = (id: number, patch: Partial<MeetingInstance>): Promise<number> =>
rpc('meetings', 'updateMeetingInstance', id, patch)
export const softDeleteMeetingInstance = (id: number): Promise<number> => rpc('meetings', 'softDeleteMeetingInstance', id)
export const restoreMeetingInstance = (id: number): Promise<number> => rpc('meetings', 'restoreMeetingInstance', id)
/** Cascade: conversationSkillScores der Entries → conversationEntries → assessments → meetingInstance. */
export const hardDeleteMeetingInstance = (id: number): Promise<void> => rpc('meetings', 'hardDeleteMeetingInstance', id)
export interface MeetingExportData {
meeting: MeetingInstance
template: PhaseTemplate | undefined
assignment: Assignment | undefined
consultants: Consultant[]
entries: ConversationEntry[]
allScores: ConversationSkillScore[]
assessments: Assessment[]
}
/** Gebündelte Rohdaten für Markdown-/JSON-Export eines Meetings — vorher in meetingExport.ts dupliziert. */
export const getMeetingExportData = (meetingId: number): Promise<MeetingExportData> =>
rpc('meetings', 'getMeetingExportData', meetingId)
+17
View File
@@ -0,0 +1,17 @@
/**
* Bridge zum lokalen Server (server/index.ts) — ersetzt den bisherigen direkten Dexie-Zugriff
* in src/db/queries/*.ts. Ein Endpunkt statt ~80 REST-Routen: `{ module, fn, args }` → Server
* ruft `rpcModules[module][fn](...args)` auf. Relativer Pfad `/api/rpc`, damit derselbe Code
* unverändert über den Vite-Dev-Proxy UND später hinter einem Reverse Proxy/Docker funktioniert.
*/
export async function rpc<T>(module: string, fn: string, ...args: unknown[]): Promise<T> {
const res = await fetch('/api/rpc', {
method: 'POST',
headers: { 'Content-Type': 'application/json' },
body: JSON.stringify({ module, fn, args }),
})
if (!res.ok) throw new Error(`RPC-Fehler: ${res.status} ${res.statusText}`)
const body = await res.json() as { ok: boolean; result?: T; error?: string }
if (!body.ok) throw new Error(body.error ?? 'RPC-Fehler')
return body.result as T
}
-7
View File
@@ -3,13 +3,6 @@ import { createRoot } from 'react-dom/client'
import { BrowserRouter } from 'react-router-dom'
import './index.css'
import App from './App.tsx'
import { seedIfEmpty, seedFeedbackStructureIfEmpty, seedCriterionMappingsIfEmpty, migrateToUnifiedCriteriaIfNeeded } from './db/index.ts'
seedIfEmpty()
seedFeedbackStructureIfEmpty().then(() => {
seedCriterionMappingsIfEmpty()
migrateToUnifiedCriteriaIfNeeded()
})
createRoot(document.getElementById('root')!).render(
<StrictMode>
+13 -8
View File
@@ -1,6 +1,11 @@
import { useEffect, useState } from 'react'
import { useNavigate } from 'react-router-dom'
import { db, type AssignmentType, type PhaseTemplate, type Consultant, type Group } from '../db'
import {
type AssignmentType, type PhaseTemplate, type Consultant, type Group,
listAssignmentTypes, listPhaseTemplatesForType,
listGroups, listConsultants, addGroup, addConsultant,
addAssignment,
} from '../db'
export default function AssignmentCreate() {
const navigate = useNavigate()
@@ -24,9 +29,9 @@ export default function AssignmentCreate() {
const reload = async () => {
const [t, g, c] = await Promise.all([
db.assignmentTypes.toArray(),
db.groups.toArray(),
db.consultants.toArray(),
listAssignmentTypes(),
listGroups(),
listConsultants(),
])
setTypes(t)
setGroups(g)
@@ -37,7 +42,7 @@ export default function AssignmentCreate() {
useEffect(() => {
if (!form.assignmentTypeId) { setPhases([]); return }
db.phaseTemplates.where('assignmentTypeId').equals(form.assignmentTypeId).sortBy('order').then(setPhases)
listPhaseTemplatesForType(form.assignmentTypeId).then(setPhases)
}, [form.assignmentTypeId])
const groupConsultants = consultants.filter(c => c.groupId === form.selectedGroupId)
@@ -55,10 +60,10 @@ export default function AssignmentCreate() {
let groupId = form.selectedGroupId
if (!groupId) {
// Erstelle eine Standardgruppe falls keine vorhanden
groupId = await db.groups.add({ name: 'Neue Gruppe', cohortYear: new Date().getFullYear() })
groupId = await addGroup({ name: 'Neue Gruppe', cohortYear: new Date().getFullYear() })
setForm(p => ({ ...p, selectedGroupId: groupId }))
}
const id = await db.consultants.add({ groupId, firstName: newFirst.trim(), lastName: newLast.trim() })
const id = await addConsultant({ groupId, firstName: newFirst.trim(), lastName: newLast.trim() })
await reload()
setForm(p => ({ ...p, instituteeIds: [...p.instituteeIds, id] }))
setNewFirst('')
@@ -68,7 +73,7 @@ export default function AssignmentCreate() {
const create = async () => {
if (!form.title.trim() || !form.client.trim() || !form.assignmentNumber.trim() || !form.assignmentTypeId || form.instituteeIds.length === 0) return
const id = await db.assignments.add({
const id = await addAssignment({
title: form.title,
client: form.client,
leadName: form.leadName,
+31 -38
View File
@@ -1,7 +1,16 @@
import { useEffect, useState } from 'react'
import { useNavigate, useParams } from 'react-router-dom'
import { db, type Assignment, type AssignmentType, type PhaseTemplate, type MeetingInstance, type Consultant, type Assessment, type FeedbackRating, type FeedbackCategory, type FeedbackCriterionItem } from '../db'
import {
type Assignment, type AssignmentType, type PhaseTemplate, type MeetingInstance, type Consultant, type Assessment, type FeedbackRating, type FeedbackCategory, type FeedbackCriterionItem,
getAssignment, getAssignmentType,
listPhaseTemplatesForType,
listMeetingInstancesForAssignment, addMeetingInstance, softDeleteMeetingInstance, restoreMeetingInstance, hardDeleteMeetingInstance,
getConsultantsByIds,
listAssessmentsForMeetings,
listFeedbackCategoriesAll, listFeedbackCriterionItemsAll, filterVisibleFeedbackStructure,
} from '../db'
import { exportMeetingAsMarkdown, exportMeetingAsJson, downloadFile } from '../utils/meetingExport'
import { weightedAverageRating } from '../utils/ratingTrend'
const RATING_BG: Record<FeedbackRating, string> = {
na: 'bg-gray-400 text-white',
@@ -11,10 +20,6 @@ const RATING_BG: Record<FeedbackRating, string> = {
client_ready: 'bg-green-700 text-white',
}
const NUM_MAP: Record<FeedbackRating, number> = { na: 0, not_client_ready: 1, partially_client_ready: 2, nearly_client_ready: 3, client_ready: 4 }
const avgToRating = (avg: number): FeedbackRating =>
avg < 1.5 ? 'not_client_ready' : avg < 2.5 ? 'partially_client_ready' : avg < 3.5 ? 'nearly_client_ready' : 'client_ready'
interface PhaseRow {
template: PhaseTemplate
instances: MeetingInstance[]
@@ -41,15 +46,15 @@ export default function AssignmentDetail() {
const [fbItems, setFbItems] = useState<FeedbackCriterionItem[]>([])
const load = async () => {
const a = await db.assignments.get(assignmentId)
const a = await getAssignment(assignmentId)
if (!a) return
setAssignment(a)
const [aType, templates, instances, cons] = await Promise.all([
db.assignmentTypes.get(a.assignmentTypeId),
db.phaseTemplates.where('assignmentTypeId').equals(a.assignmentTypeId).sortBy('order'),
db.meetingInstances.where('assignmentId').equals(assignmentId).toArray(),
db.consultants.where('id').anyOf(a.instituteeIds).toArray(),
getAssignmentType(a.assignmentTypeId),
listPhaseTemplatesForType(a.assignmentTypeId),
listMeetingInstancesForAssignment(assignmentId),
getConsultantsByIds(a.instituteeIds),
])
setAssignmentType(aType ?? null)
@@ -64,23 +69,21 @@ export default function AssignmentDetail() {
})))
const instIds = active.map(i => i.id!)
const [asmts, allCats, allItems, aType2] = await Promise.all([
instIds.length > 0 ? db.assessments.where('meetingInstanceId').anyOf(instIds).toArray() : Promise.resolve([]),
db.feedbackCategories.toArray(),
db.feedbackCriterionItems.toArray(),
db.assignmentTypes.get(a.assignmentTypeId),
listAssessmentsForMeetings(instIds),
listFeedbackCategoriesAll(),
listFeedbackCriterionItemsAll(),
getAssignmentType(a.assignmentTypeId),
])
setAllAssessments(asmts)
const itemFilter = aType2?.criteriaIds?.length ? new Set(aType2.criteriaIds) : null
const filteredItems = itemFilter ? allItems.filter(i => itemFilter.has(i.id!)) : allItems
setFbItems(filteredItems)
const visibleCatIds = new Set(filteredItems.map(i => i.categoryId))
setFbCategories(itemFilter ? allCats.filter(c => visibleCatIds.has(c.id!)) : allCats)
const { categories: visibleCats, items: visibleItems } = filterVisibleFeedbackStructure(allCats, allItems, aType2?.criteriaIds)
setFbItems(visibleItems)
setFbCategories(visibleCats)
}
useEffect(() => { load() }, [assignmentId])
const startMeeting = async (templateId: number, existingCount: number) => {
const mid = await db.meetingInstances.add({
const mid = await addMeetingInstance({
assignmentId,
phaseTemplateId: templateId,
phaseIndex: existingCount + 1,
@@ -113,24 +116,18 @@ export default function AssignmentDetail() {
}
const softDeleteMeeting = async (instId: number) => {
await db.meetingInstances.update(instId, { deletedAt: new Date().toISOString() })
await softDeleteMeetingInstance(instId)
setConfirmSoftDelete(null)
await load()
}
const restoreMeeting = async (instId: number) => {
await db.meetingInstances.update(instId, { deletedAt: undefined })
await restoreMeetingInstance(instId)
await load()
}
const hardDeleteMeeting = async (instId: number) => {
await db.conversationSkillScores
.where('conversationEntryId')
.anyOf((await db.conversationEntries.where('meetingInstanceId').equals(instId).primaryKeys()))
.delete()
await db.conversationEntries.where('meetingInstanceId').equals(instId).delete()
await db.assessments.where('meetingInstanceId').equals(instId).delete()
await db.meetingInstances.delete(instId)
await hardDeleteMeetingInstance(instId)
setConfirmHardDelete(null)
await load()
}
@@ -258,19 +255,15 @@ export default function AssignmentDetail() {
{institutees.map(c => {
const chips = fbCategories.map(cat => {
const catItems = fbItems.filter(i => i.categoryId === cat.id)
const scored = catItems.map(item => {
const mode = weightedAverageRating(catItems, itemId => {
const asmt = allAssessments.find(a =>
a.meetingInstanceId === inst.id &&
a.instituteeId === c.id &&
a.criteriaId === item.id &&
a.score !== null && a.score !== 'na'
a.criteriaId === itemId
)
return asmt ? { score: asmt.score as FeedbackRating, w: item.weight ?? 1 } : null
}).filter(Boolean) as { score: FeedbackRating; w: number }[]
if (scored.length === 0) return null
const wSum = scored.reduce((s, x) => s + x.w, 0)
const avg = scored.reduce((s, x) => s + NUM_MAP[x.score] * x.w, 0) / wSum
return { cat, mode: avgToRating(avg) }
return asmt?.score ?? null
})
return mode ? { cat, mode } : null
}).filter(Boolean) as { cat: FeedbackCategory; mode: FeedbackRating }[]
if (chips.length === 0) return null
+8 -5
View File
@@ -1,6 +1,9 @@
import { useEffect, useState } from 'react'
import { useNavigate, useParams } from 'react-router-dom'
import { db, type Assignment, type AssignmentType, type Consultant } from '../db'
import {
type Assignment, type AssignmentType, type Consultant,
getAssignment, updateAssignment, listAssignmentTypes, listConsultants,
} from '../db'
export default function AssignmentEdit() {
const { id } = useParams()
@@ -27,9 +30,9 @@ export default function AssignmentEdit() {
useEffect(() => {
const loadData = async () => {
const [a, types, cons] = await Promise.all([
db.assignments.get(assignmentId),
db.assignmentTypes.toArray(),
db.consultants.toArray(),
getAssignment(assignmentId),
listAssignmentTypes(),
listConsultants(),
])
if (!a) return
setAssignment(a)
@@ -50,7 +53,7 @@ export default function AssignmentEdit() {
}, [assignmentId])
const handleSave = async () => {
await db.assignments.update(assignmentId, {
await updateAssignment(assignmentId, {
assignmentNumber: assignmentNumber.trim() || undefined,
title,
client,
+37 -50
View File
@@ -1,7 +1,6 @@
import { useCallback, useEffect, useRef, useState } from 'react'
import { useNavigate, useParams } from 'react-router-dom'
import {
db,
type Assignment,
type Consultant,
type FeedbackDimension,
@@ -11,8 +10,16 @@ import {
type FeedbackCategoryRating,
type FeedbackDimensionText,
type FeedbackRating,
getAssignment, getConsultant,
loadFeedbackStructure,
listMeetingInstancesForAssignment, listDoneMeetingsChronological,
listAssessmentsForMeetings, listConversationEntriesForMeetings,
getRatingTrendWeightStep,
getOrCreateAssignmentFeedback, updateAssignmentFeedback,
listFeedbackCategoryRatings, addFeedbackCategoryRating, updateFeedbackCategoryRating,
listFeedbackDimensionTexts, getFeedbackDimensionText, addFeedbackDimensionText, updateFeedbackDimensionText,
} from '../db'
import { RATING_OPTIONS, RATING_NUM_MAP, AI_CONFIG, DEFAULT_RATING_TREND_WEIGHT_STEP } from '../config/constants'
import { RATING_OPTIONS, RATING_NUM_MAP, AI_CONFIG } from '../config/constants'
import { buildGroupMeetingScores, computeTrend, numberToRating, type TrendResult } from '../utils/ratingTrend'
import { splitNoteLines } from '../utils/notationParser'
@@ -51,12 +58,12 @@ async function buildAiPrompt(
ratings: FeedbackCategoryRating[],
catTrends: Map<number, TrendResult>,
): Promise<string> {
const meetings = await db.meetingInstances.where('assignmentId').equals(assignment.id!).toArray()
const meetings = await listMeetingInstancesForAssignment(assignment.id!)
const meetingIds = meetings.map(m => m.id!)
const [allAssessments, allEntries] = await Promise.all([
db.assessments.where('meetingInstanceId').anyOf(meetingIds).toArray(),
db.conversationEntries.where('meetingInstanceId').anyOf(meetingIds).toArray(),
listAssessmentsForMeetings(meetingIds),
listConversationEntriesForMeetings(meetingIds),
])
const instAssessments = allAssessments.filter(a => a.instituteeId === institutee.id)
@@ -187,28 +194,24 @@ export default function AssignmentFeedbackPage() {
const saveTimer = useRef<Map<string, ReturnType<typeof setTimeout>>>(new Map())
const load = useCallback(async () => {
const [a, cons, dims, cats, itms] = await Promise.all([
db.assignments.get(assignmentId),
db.consultants.get(instId),
db.feedbackDimensions.orderBy('order').toArray(),
db.feedbackCategories.orderBy('order').toArray(),
db.feedbackCriterionItems.orderBy('order').toArray(),
const [a, cons, structure] = await Promise.all([
getAssignment(assignmentId),
getConsultant(instId),
loadFeedbackStructure(),
])
setAssignment(a ?? null)
setInstitutee(cons ?? null)
setDimensions(dims)
setCategories(cats)
setItems(itms)
setDimensions(structure.dimensions)
setCategories(structure.categories)
setItems(structure.items)
const { dimensions: dims, categories: cats, items: itms } = structure
const meetings = (await db.meetingInstances.where('assignmentId').equals(assignmentId).toArray())
.filter(m => !m.deletedAt && m.status === 'done')
.sort((x, y) => new Date(x.date).getTime() - new Date(y.date).getTime())
const meetings = await listDoneMeetingsChronological(assignmentId)
const meetingIds = meetings.map(m => m.id!)
const [meetingAssessments, settings] = await Promise.all([
meetingIds.length > 0 ? db.assessments.where('meetingInstanceId').anyOf(meetingIds).toArray() : Promise.resolve([]),
db.appSettings.get(1),
const [meetingAssessments, weightStep] = await Promise.all([
listAssessmentsForMeetings(meetingIds),
getRatingTrendWeightStep(),
])
const weightStep = settings?.ratingTrendWeightStep ?? DEFAULT_RATING_TREND_WEIGHT_STEP
const instAssessments = meetingAssessments.filter(as => as.instituteeId === instId)
const getScore = (meetingId: number, itemId: number): FeedbackRating | null =>
instAssessments.find(as => as.meetingInstanceId === meetingId && as.criteriaId === itemId)?.score ?? null
@@ -221,23 +224,13 @@ export default function AssignmentFeedbackPage() {
}
setCatTrends(trends)
let fb = await db.assignmentFeedbacks
.where('assignmentId').equals(assignmentId)
.filter(f => f.instituteeId === instId)
.first()
if (!fb) {
const fbId = await db.assignmentFeedbacks.add({
assignmentId, instituteeId: instId,
status: 'draft', aiModel: '', updatedAt: new Date().toISOString(),
})
fb = await db.assignmentFeedbacks.get(fbId)
}
const fb = await getOrCreateAssignmentFeedback(assignmentId, instId)
setFeedback(fb ?? null)
if (fb?.id) {
const [rs, txts] = await Promise.all([
db.feedbackCategoryRatings.where('assignmentFeedbackId').equals(fb.id).toArray(),
db.feedbackDimensionTexts.where('assignmentFeedbackId').equals(fb.id).toArray(),
listFeedbackCategoryRatings(fb.id),
listFeedbackDimensionTexts(fb.id),
])
setRatings(rs)
setDimTexts(txts)
@@ -255,10 +248,10 @@ export default function AssignmentFeedbackPage() {
if (!feedback?.id) return
const existing = ratings.find(r => r.feedbackCategoryId === categoryId)
if (existing?.id) {
await db.feedbackCategoryRatings.update(existing.id, { rating })
await updateFeedbackCategoryRating(existing.id, { rating })
setRatings(prev => prev.map(r => r.feedbackCategoryId === categoryId ? { ...r, rating } : r))
} else {
const newId = await db.feedbackCategoryRatings.add({
const newId = await addFeedbackCategoryRating({
assignmentFeedbackId: feedback.id, feedbackCategoryId: categoryId, rating,
})
setRatings(prev => [...prev, { id: newId, assignmentFeedbackId: feedback.id!, feedbackCategoryId: categoryId, rating }])
@@ -281,14 +274,11 @@ export default function AssignmentFeedbackPage() {
if (prev) clearTimeout(prev)
saveTimer.current.set(key, setTimeout(async () => {
if (!feedback?.id) return
const existing = await db.feedbackDimensionTexts
.where('assignmentFeedbackId').equals(feedback.id)
.filter(t => t.feedbackDimensionId === dimId)
.first()
const existing = await getFeedbackDimensionText(feedback.id, dimId)
if (existing?.id) {
await db.feedbackDimensionTexts.update(existing.id, { [field]: value })
await updateFeedbackDimensionText(existing.id, { [field]: value })
} else {
await db.feedbackDimensionTexts.add({
await addFeedbackDimensionText({
assignmentFeedbackId: feedback.id,
feedbackDimensionId: dimId,
achievements: field === 'achievements' ? value : '',
@@ -349,17 +339,14 @@ export default function AssignmentFeedbackPage() {
for (const item of parsed.dimensions) {
const dim = dimensions.find(d => d.name === item.name || item.name.includes(d.name.split(',')[0]))
if (!dim?.id) continue
const existing = await db.feedbackDimensionTexts
.where('assignmentFeedbackId').equals(feedback.id)
.filter(t => t.feedbackDimensionId === dim.id)
.first()
const existing = await getFeedbackDimensionText(feedback.id, dim.id)
if (existing?.id) {
await db.feedbackDimensionTexts.update(existing.id, {
await updateFeedbackDimensionText(existing.id, {
achievements: item.achievements,
developmentNeeds: item.developmentNeeds,
})
} else {
await db.feedbackDimensionTexts.add({
await addFeedbackDimensionText({
assignmentFeedbackId: feedback.id,
feedbackDimensionId: dim.id,
achievements: item.achievements,
@@ -367,7 +354,7 @@ export default function AssignmentFeedbackPage() {
})
}
}
await db.assignmentFeedbacks.update(feedback.id, { aiModel: settings.model, updatedAt: new Date().toISOString() })
await updateAssignmentFeedback(feedback.id, { aiModel: settings.model, updatedAt: new Date().toISOString() })
await load()
} catch (e) {
setAiError(e instanceof Error ? e.message : 'Unbekannter Fehler')
@@ -379,7 +366,7 @@ export default function AssignmentFeedbackPage() {
const toggleFinal = async () => {
if (!feedback?.id) return
const next = feedback.status === 'final' ? 'draft' : 'final'
await db.assignmentFeedbacks.update(feedback.id, { status: next, updatedAt: new Date().toISOString() })
await updateAssignmentFeedback(feedback.id, { status: next, updatedAt: new Date().toISOString() })
setFeedback(prev => prev ? { ...prev, status: next } : null)
}
+23 -22
View File
@@ -1,5 +1,10 @@
import { useEffect, useState } from 'react'
import { db, type AssignmentType, type PhaseTemplate, type FeedbackDimension, type FeedbackCategory, type FeedbackCriterionItem } from '../db'
import {
type AssignmentType, type PhaseTemplate, type FeedbackDimension, type FeedbackCategory, type FeedbackCriterionItem,
listAssignmentTypes, listPhaseTemplates, loadFeedbackStructure,
addAssignmentType, updateAssignmentType, deleteAssignmentType,
addPhaseTemplate, updatePhaseTemplate, deletePhaseTemplate,
} from '../db'
export default function AssignmentTypeConfig() {
const [types, setTypes] = useState<AssignmentType[]>([])
@@ -18,18 +23,16 @@ export default function AssignmentTypeConfig() {
}>>({})
const load = async () => {
const [t, tmpl, dims, cats, itms] = await Promise.all([
db.assignmentTypes.toArray(),
db.phaseTemplates.toArray(),
db.feedbackDimensions.orderBy('order').toArray(),
db.feedbackCategories.orderBy('order').toArray(),
db.feedbackCriterionItems.orderBy('order').toArray(),
const [t, tmpl, structure] = await Promise.all([
listAssignmentTypes(),
listPhaseTemplates(),
loadFeedbackStructure(),
])
setTypes(t)
setTemplates(tmpl)
setDimensions(dims)
setCategories(cats)
setItems(itms)
setDimensions(structure.dimensions)
setCategories(structure.categories)
setItems(structure.items)
}
useEffect(() => { load() }, [])
@@ -39,25 +42,23 @@ export default function AssignmentTypeConfig() {
const addType = async () => {
const name = newTypeName.trim()
if (!name) return
const id = await db.assignmentTypes.add({ name, defaultPhaseKeys: [], criteriaIds: [] })
const id = await addAssignmentType({ name, defaultPhaseKeys: [], criteriaIds: [] })
setNewTypeName('')
await load()
setExpanded(id)
}
const updateTypeName = async (id: number, name: string) => {
await db.assignmentTypes.update(id, { name })
await updateAssignmentType(id, { name })
setTypes(prev => prev.map(t => t.id === id ? { ...t, name } : t))
}
const deleteType = async (id: number) => {
const count = await db.assignments.where('assignmentTypeId').equals(id).count()
if (count > 0) {
setTypeError(prev => ({ ...prev, [id]: `Kann nicht gelöscht werden — ${count} Assignment(s) verwenden diesen Typ.` }))
const result = await deleteAssignmentType(id)
if (!result.ok) {
setTypeError(prev => ({ ...prev, [id]: `Kann nicht gelöscht werden — ${result.assignmentCount} Assignment(s) verwenden diesen Typ.` }))
return
}
await db.phaseTemplates.where('assignmentTypeId').equals(id).delete()
await db.assignmentTypes.delete(id)
await load()
}
@@ -66,7 +67,7 @@ export default function AssignmentTypeConfig() {
const toggleItem = async (type: AssignmentType, itemId: number) => {
const current = type.criteriaIds ?? []
const next = current.includes(itemId) ? current.filter(id => id !== itemId) : [...current, itemId]
await db.assignmentTypes.update(type.id!, { criteriaIds: next })
await updateAssignmentType(type.id!, { criteriaIds: next })
setTypes(prev => prev.map(t => t.id === type.id ? { ...t, criteriaIds: next } : t))
}
@@ -77,7 +78,7 @@ export default function AssignmentTypeConfig() {
const next = allSelected
? current.filter(id => !catItemIds.includes(id))
: [...new Set([...current, ...catItemIds])]
await db.assignmentTypes.update(type.id!, { criteriaIds: next })
await updateAssignmentType(type.id!, { criteriaIds: next })
setTypes(prev => prev.map(t => t.id === type.id ? { ...t, criteriaIds: next } : t))
}
@@ -87,7 +88,7 @@ export default function AssignmentTypeConfig() {
const np = newPhase[typeId]
if (!np?.label.trim()) return
const existing = templates.filter(t => t.assignmentTypeId === typeId)
await db.phaseTemplates.add({
await addPhaseTemplate({
assignmentTypeId: typeId,
phaseKey: np.label.trim().toLowerCase().replace(/\s+/g, '_'),
label: np.label.trim(),
@@ -103,12 +104,12 @@ export default function AssignmentTypeConfig() {
}
const updatePhase = async (id: number, patch: Partial<PhaseTemplate>) => {
await db.phaseTemplates.update(id, patch)
await updatePhaseTemplate(id, patch)
setTemplates(prev => prev.map(t => t.id === id ? { ...t, ...patch } : t))
}
const deletePhase = async (id: number) => {
await db.phaseTemplates.delete(id)
await deletePhaseTemplate(id)
await load()
}
+56 -9
View File
@@ -1,35 +1,55 @@
import { useEffect, useState } from 'react'
import { db, type Consultant, type Group } from '../db'
import {
type Consultant, type Group,
listGroups, listConsultants, addGroup as addGroupQuery, addConsultant as addConsultantQuery,
updateConsultant as updateConsultantQuery, deleteConsultant as deleteConsultantQuery,
} from '../db'
export default function Consultants() {
const [groups, setGroups] = useState<Group[]>([])
const [consultants, setConsultants] = useState<Consultant[]>([])
const [newGroup, setNewGroup] = useState({ name: '', cohortYear: new Date().getFullYear() })
const [newCons, setNewCons] = useState({ groupId: 0, firstName: '', lastName: '' })
const [editingId, setEditingId] = useState<number | null>(null)
const [editValues, setEditValues] = useState({ firstName: '', lastName: '' })
const load = async () => {
setGroups(await db.groups.toArray())
setConsultants(await db.consultants.toArray())
setGroups(await listGroups())
setConsultants(await listConsultants())
}
useEffect(() => { load() }, [])
const addGroup = async () => {
if (!newGroup.name.trim()) return
await db.groups.add({ ...newGroup })
await addGroupQuery({ ...newGroup })
setNewGroup({ name: '', cohortYear: new Date().getFullYear() })
load()
}
const addConsultant = async () => {
if (!newCons.firstName.trim() || !newCons.lastName.trim() || !newCons.groupId) return
await db.consultants.add({ ...newCons })
await addConsultantQuery({ ...newCons })
setNewCons(p => ({ ...p, firstName: '', lastName: '' }))
load()
}
const deleteConsultant = async (id: number) => {
await db.consultants.delete(id)
await deleteConsultantQuery(id)
load()
}
const startEdit = (c: Consultant) => {
setEditingId(c.id!)
setEditValues({ firstName: c.firstName, lastName: c.lastName })
}
const cancelEdit = () => setEditingId(null)
const saveEdit = async () => {
if (!editValues.firstName.trim() || !editValues.lastName.trim() || editingId === null) return
await updateConsultantQuery(editingId, { ...editValues })
setEditingId(null)
load()
}
@@ -77,9 +97,36 @@ export default function Consultants() {
<div key={g.id} className="bg-white rounded-xl shadow-sm border border-gray-100 p-4">
<h3 className="font-semibold text-gray-700 mb-2">{g.name}</h3>
{members.map(c => (
<div key={c.id} className="flex items-center justify-between py-1 text-sm text-gray-700 border-b border-gray-50 last:border-0">
<span>{c.firstName} {c.lastName}</span>
<button onClick={() => deleteConsultant(c.id!)} className="text-red-400 text-xs hover:text-red-600">×</button>
<div key={c.id} className="flex items-center justify-between py-1 text-sm text-gray-700 border-b border-gray-50 last:border-0 gap-2">
{editingId === c.id ? (
<>
<div className="flex gap-2 flex-1">
<input
className="flex-1 border border-gray-200 rounded-lg px-2 py-1 text-sm"
value={editValues.firstName}
onChange={e => setEditValues(p => ({ ...p, firstName: e.target.value }))}
onKeyDown={e => e.key === 'Enter' && saveEdit()}
autoFocus
/>
<input
className="flex-1 border border-gray-200 rounded-lg px-2 py-1 text-sm"
value={editValues.lastName}
onChange={e => setEditValues(p => ({ ...p, lastName: e.target.value }))}
onKeyDown={e => e.key === 'Enter' && saveEdit()}
/>
</div>
<button onClick={saveEdit} className="text-brand text-xs hover:underline">Speichern</button>
<button onClick={cancelEdit} className="text-gray-400 text-xs hover:text-gray-600">Abbrechen</button>
</>
) : (
<>
<span>{c.firstName} {c.lastName}</span>
<div className="flex gap-2">
<button onClick={() => startEdit(c)} className="text-gray-400 text-xs hover:text-brand">Bearbeiten</button>
<button onClick={() => deleteConsultant(c.id!)} className="text-red-400 text-xs hover:text-red-600">×</button>
</div>
</>
)}
</div>
))}
</div>
+3 -23
View File
@@ -1,35 +1,15 @@
import { useEffect, useMemo, useState } from 'react'
import { useNavigate } from 'react-router-dom'
import { db, type Assignment, type AssignmentType, type Consultant } from '../db'
interface AssignmentRow extends Assignment {
typeName: string
instituteeNames: string[]
}
import { listAssignmentsWithDetails, type AssignmentWithDetails } from '../db'
export default function Dashboard() {
const [assignments, setAssignments] = useState<AssignmentRow[]>([])
const [assignments, setAssignments] = useState<AssignmentWithDetails[]>([])
const [query, setQuery] = useState('')
const [statusFilter, setStatusFilter] = useState<'all' | 'active' | 'done'>('all')
const navigate = useNavigate()
useEffect(() => {
const load = async () => {
const raw = await db.assignments.orderBy('createdAt').reverse().toArray()
const types = await db.assignmentTypes.toArray()
const consultants = await db.consultants.toArray()
const typeMap = new Map<number, AssignmentType>(types.map(t => [t.id!, t]))
const consMap = new Map<number, Consultant>(consultants.map(c => [c.id!, c]))
setAssignments(raw.map(a => ({
...a,
typeName: typeMap.get(a.assignmentTypeId)?.name ?? '—',
instituteeNames: a.instituteeIds.map(id => {
const c = consMap.get(id)
return c ? `${c.firstName} ${c.lastName}` : '?'
}),
})))
}
load()
listAssignmentsWithDetails().then(setAssignments)
}, [])
const filtered = useMemo(() => {
+14 -15
View File
@@ -1,12 +1,16 @@
import { useEffect, useState } from 'react'
import { useNavigate } from 'react-router-dom'
import {
db,
type Assignment, type Consultant,
type FeedbackDimension, type FeedbackCategory,
type FeedbackRating,
listAssignments, listConsultants,
loadFeedbackStructure,
listAssessmentsAll,
getRatingTrendWeightStep,
listDoneMeetingsChronological,
} from '../db'
import { RATING_OPTIONS, DEFAULT_RATING_TREND_WEIGHT_STEP } from '../config/constants'
import { RATING_OPTIONS } from '../config/constants'
import { buildGroupMeetingScores, computeTrend, type TrendResult } from '../utils/ratingTrend'
interface CatScore {
@@ -57,25 +61,20 @@ export default function Evaluation() {
useEffect(() => {
const load = async () => {
const [assignments, consultants, dims, cats, items, assessments, settings] = await Promise.all([
db.assignments.toArray(),
db.consultants.toArray(),
db.feedbackDimensions.orderBy('order').toArray(),
db.feedbackCategories.orderBy('order').toArray(),
db.feedbackCriterionItems.orderBy('order').toArray(),
db.assessments.toArray(),
db.appSettings.get(1),
const [assignments, consultants, structure, assessments, weightStep] = await Promise.all([
listAssignments(),
listConsultants(),
loadFeedbackStructure(),
listAssessmentsAll(),
getRatingTrendWeightStep(),
])
const { dimensions: dims, categories: cats, items } = structure
setDimensions(dims)
setCategories(cats)
const weightStep = settings?.ratingTrendWeightStep ?? DEFAULT_RATING_TREND_WEIGHT_STEP
const rows: InstScore[] = []
for (const a of assignments) {
const meetings = (await db.meetingInstances
.where('assignmentId').equals(a.id!).toArray()
).filter(m => !m.deletedAt && m.status === 'done')
.sort((x, y) => new Date(x.date).getTime() - new Date(y.date).getTime())
const meetings = await listDoneMeetingsChronological(a.id!)
const meetingIds = meetings.map(m => m.id!)
for (const instId of a.instituteeIds) {
+18 -18
View File
@@ -1,13 +1,18 @@
import { useCallback, useEffect, useRef, useState } from 'react'
import { useNavigate, useParams } from 'react-router-dom'
import {
db,
type Assignment,
type Consultant,
type FeedbackCategory,
type FeedbackCriterionItem,
type FeedbackDraft,
type FeedbackRating,
getAssignment, getConsultant,
listFeedbackCategoriesOrdered, getFeedbackCriterionItemsByIds,
listMeetingInstancesForAssignment,
listAssessmentsForMeetings,
listConversationEntriesForMeetings,
getFeedbackDraft, addFeedbackDraft, updateFeedbackDraft,
} from '../db'
import { RATING_OPTIONS, RATING_NUM_MAP } from '../config/constants'
import { numberToRating } from '../utils/ratingTrend'
@@ -49,20 +54,20 @@ export default function FeedbackDraftPage() {
const load = useCallback(async () => {
const [a, cons, cats] = await Promise.all([
db.assignments.get(assignmentId),
db.consultants.get(instId),
db.feedbackCategories.orderBy('order').toArray(),
getAssignment(assignmentId),
getConsultant(instId),
listFeedbackCategoriesOrdered(),
])
setAssignment(a ?? null)
setInstitutee(cons ?? null)
setCategories(cats)
const meetings = await db.meetingInstances.where('assignmentId').equals(assignmentId).toArray()
const meetings = await listMeetingInstancesForAssignment(assignmentId)
const meetingIds = meetings.map(m => m.id!)
const [allAssessments, allEntries] = await Promise.all([
db.assessments.where('meetingInstanceId').anyOf(meetingIds).toArray(),
db.conversationEntries.where('meetingInstanceId').anyOf(meetingIds).toArray(),
listAssessmentsForMeetings(meetingIds),
listConversationEntriesForMeetings(meetingIds),
])
const instAssessments = allAssessments.filter(a => a.instituteeId === instId)
@@ -73,9 +78,7 @@ export default function FeedbackDraftPage() {
...instAssessments.map(a => a.criteriaId),
...allLineTags.map(t => t.criterionItemId),
])]
const crits = criteriaIds.length > 0
? await db.feedbackCriterionItems.where('id').anyOf(criteriaIds).toArray()
: []
const crits = await getFeedbackCriterionItemsByIds(criteriaIds)
const sum: CriterionSummary[] = crits.map(crit => {
const relevant = instAssessments.filter(a => a.criteriaId === crit.id && a.score !== null && a.score !== 'na')
@@ -90,10 +93,7 @@ export default function FeedbackDraftPage() {
})
setSummary(sum)
const existing = await db.feedbackDrafts
.where('assignmentId').equals(assignmentId)
.filter(d => d.instituteeId === instId)
.first()
const existing = await getFeedbackDraft(assignmentId, instId)
if (existing) {
setDraft(existing)
setContent(existing.content)
@@ -134,10 +134,10 @@ export default function FeedbackDraftPage() {
const now = new Date().toISOString()
if (draft?.id) {
await db.feedbackDrafts.update(draft.id, { content: text, updatedAt: now })
await updateFeedbackDraft(draft.id, { content: text, updatedAt: now })
setDraft(prev => prev ? { ...prev, content: text, updatedAt: now } : null)
} else {
const newId = await db.feedbackDrafts.add({
const newId = await addFeedbackDraft({
assignmentId, instituteeId: instId, content: text, updatedAt: now,
})
setDraft({ id: newId, assignmentId, instituteeId: instId, content: text, updatedAt: now })
@@ -150,9 +150,9 @@ export default function FeedbackDraftPage() {
saveTimer.current = setTimeout(async () => {
const now = new Date().toISOString()
if (draft?.id) {
await db.feedbackDrafts.update(draft.id, { content: val, updatedAt: now })
await updateFeedbackDraft(draft.id, { content: val, updatedAt: now })
} else {
const newId = await db.feedbackDrafts.add({
const newId = await addFeedbackDraft({
assignmentId, instituteeId: instId, content: val, updatedAt: now,
})
setDraft({ id: newId, assignmentId, instituteeId: instId, content: val, updatedAt: now })
+23 -27
View File
@@ -1,5 +1,11 @@
import { useEffect, useState } from 'react'
import { db, type FeedbackDimension, type FeedbackCategory, type FeedbackCriterionItem } from '../db'
import {
type FeedbackDimension, type FeedbackCategory, type FeedbackCriterionItem,
loadFeedbackStructure,
addFeedbackDimension, updateFeedbackDimension, deleteFeedbackDimension,
addFeedbackCategory, updateFeedbackCategory, deleteFeedbackCategory,
addFeedbackCriterionItem, updateFeedbackCriterionItem, deleteFeedbackCriterionItem,
} from '../db'
export default function FeedbackStructureConfig() {
const [dimensions, setDimensions] = useState<FeedbackDimension[]>([])
@@ -14,14 +20,10 @@ export default function FeedbackStructureConfig() {
const [newItemName, setNewItemName] = useState<Record<number, string>>({})
const load = async () => {
const [dims, cats, itms] = await Promise.all([
db.feedbackDimensions.orderBy('order').toArray(),
db.feedbackCategories.orderBy('order').toArray(),
db.feedbackCriterionItems.orderBy('order').toArray(),
])
setDimensions(dims)
setCategories(cats)
setItems(itms)
const structure = await loadFeedbackStructure()
setDimensions(structure.dimensions)
setCategories(structure.categories)
setItems(structure.items)
}
useEffect(() => { load() }, [])
@@ -31,24 +33,19 @@ export default function FeedbackStructureConfig() {
const addDimension = async () => {
if (!newDimName.trim()) return
const maxOrder = dimensions.reduce((m, d) => Math.max(m, d.order), 0)
const id = await db.feedbackDimensions.add({ name: newDimName.trim(), order: maxOrder + 1 })
const id = await addFeedbackDimension({ name: newDimName.trim(), order: maxOrder + 1 })
setNewDimName('')
await load()
setExpanded(prev => new Set([...prev, id]))
}
const updateDimension = async (id: number, name: string) => {
await db.feedbackDimensions.update(id, { name })
await updateFeedbackDimension(id, { name })
setDimensions(prev => prev.map(d => d.id === id ? { ...d, name } : d))
}
const deleteDimension = async (id: number) => {
const cats = await db.feedbackCategories.where('dimensionId').equals(id).toArray()
for (const cat of cats) {
await db.feedbackCriterionItems.where('categoryId').equals(cat.id!).delete()
}
await db.feedbackCategories.where('dimensionId').equals(id).delete()
await db.feedbackDimensions.delete(id)
await deleteFeedbackDimension(id)
await load()
}
@@ -57,8 +54,8 @@ export default function FeedbackStructureConfig() {
const idx = sorted.findIndex(d => d.id === dim.id)
const other = sorted[idx + dir]
if (!other) return
await db.feedbackDimensions.update(dim.id!, { order: other.order })
await db.feedbackDimensions.update(other.id!, { order: dim.order })
await updateFeedbackDimension(dim.id!, { order: other.order })
await updateFeedbackDimension(other.id!, { order: dim.order })
await load()
}
@@ -69,20 +66,19 @@ export default function FeedbackStructureConfig() {
if (!name) return
const dimCats = categories.filter(c => c.dimensionId === dimId)
const maxOrder = dimCats.reduce((m, c) => Math.max(m, c.order), 0)
const id = await db.feedbackCategories.add({ dimensionId: dimId, name, order: maxOrder + 1 })
const id = await addFeedbackCategory({ dimensionId: dimId, name, order: maxOrder + 1 })
setNewCatName(prev => ({ ...prev, [dimId]: '' }))
await load()
setExpandedCat(prev => new Set([...prev, id]))
}
const updateCategory = async (id: number, name: string) => {
await db.feedbackCategories.update(id, { name })
await updateFeedbackCategory(id, { name })
setCategories(prev => prev.map(c => c.id === id ? { ...c, name } : c))
}
const deleteCategory = async (id: number) => {
await db.feedbackCriterionItems.where('categoryId').equals(id).delete()
await db.feedbackCategories.delete(id)
await deleteFeedbackCategory(id)
await load()
}
@@ -93,23 +89,23 @@ export default function FeedbackStructureConfig() {
if (!name) return
const catItems = items.filter(i => i.categoryId === catId)
const maxOrder = catItems.reduce((m, i) => Math.max(m, i.order), 0)
await db.feedbackCriterionItems.add({ categoryId: catId, name, order: maxOrder + 1 })
await addFeedbackCriterionItem({ categoryId: catId, name, order: maxOrder + 1 })
setNewItemName(prev => ({ ...prev, [catId]: '' }))
await load()
}
const updateItem = async (id: number, name: string) => {
await db.feedbackCriterionItems.update(id, { name })
await updateFeedbackCriterionItem(id, { name })
setItems(prev => prev.map(i => i.id === id ? { ...i, name } : i))
}
const deleteItem = async (id: number) => {
await db.feedbackCriterionItems.delete(id)
await deleteFeedbackCriterionItem(id)
setItems(prev => prev.filter(i => i.id !== id))
}
const updateItemWeight = async (id: number, weight: number) => {
await db.feedbackCriterionItems.update(id, { weight })
await updateFeedbackCriterionItem(id, { weight })
setItems(prev => prev.map(i => i.id === id ? { ...i, weight } : i))
}
+3 -11
View File
@@ -1,5 +1,5 @@
import { useEffect, useState } from 'react'
import { db } from '../db'
import { getOrSeedRatingTrendWeightStep, saveRatingTrendWeightStep } from '../db'
import { DEFAULT_RATING_TREND_WEIGHT_STEP } from '../config/constants'
import { previewWeights } from '../utils/ratingTrend'
@@ -8,19 +8,11 @@ export default function RatingWeightConfig() {
const [saved, setSaved] = useState(false)
useEffect(() => {
const load = async () => {
let settings = await db.appSettings.get(1)
if (!settings) {
await db.appSettings.add({ id: 1, ratingTrendWeightStep: DEFAULT_RATING_TREND_WEIGHT_STEP })
settings = await db.appSettings.get(1)
}
setWeightStep(settings?.ratingTrendWeightStep ?? DEFAULT_RATING_TREND_WEIGHT_STEP)
}
load()
getOrSeedRatingTrendWeightStep().then(setWeightStep)
}, [])
const save = async () => {
await db.appSettings.put({ id: 1, ratingTrendWeightStep: weightStep })
await saveRatingTrendWeightStep(weightStep)
setSaved(true)
setTimeout(() => setSaved(false), 2500)
}
+2 -13
View File
@@ -5,7 +5,7 @@ import type {
} from '../../db'
import { INST_COLORS, RATING_OPTIONS, RATING_NUM_MAP } from '../../config/constants'
import { detectNotationRating } from '../../utils/notationParser'
import { numberToRating } from '../../utils/ratingTrend'
import { numberToRating, weightedAverageRating } from '../../utils/ratingTrend'
interface Props {
institutees: Consultant[]
@@ -27,18 +27,7 @@ function catMode(
fbItems: FeedbackCriterionItem[],
getScore: (itemId: number) => FeedbackRating | null,
): FeedbackRating | null {
const scored = fbItems
.filter(i => i.categoryId === cat.id)
.map(i => ({ score: getScore(i.id!), w: i.weight ?? 1 }))
.filter((x): x is { score: FeedbackRating; w: number } => x.score !== null && x.score !== 'na')
if (scored.length === 0) return null
const wSum = scored.reduce((s, x) => s + x.w, 0)
if (wSum === 0) return null // alle beteiligten Kriterien auf Gewicht 0 → keine Aussage möglich, sonst NaN < x ist überall false und fällt auf "Fully" durch
const avg = scored.reduce((s, x) => s + RATING_NUM_MAP[x.score] * x.w, 0) / wSum
if (avg < 1.5) return 'not_client_ready'
if (avg < 2.5) return 'partially_client_ready'
if (avg < 3.5) return 'nearly_client_ready'
return 'client_ready'
return weightedAverageRating(fbItems.filter(i => i.categoryId === cat.id), getScore)
}
function suggestedRating(entries: ConversationEntry[], instituteeId: number, itemId: number): FeedbackRating | null {
+46 -40
View File
@@ -1,10 +1,18 @@
import { useCallback, useEffect, useRef, useState } from 'react'
import { useNavigate, useParams } from 'react-router-dom'
import {
db,
type Assignment, type MeetingInstance, type PhaseTemplate,
type FeedbackCategory, type FeedbackCriterionItem, type FeedbackRating,
type Consultant, type ConversationEntry, type ConversationSkillScore, type Assessment,
getMeetingInstance, updateMeetingInstance, softDeleteMeetingInstance,
getAssignmentType,
getAssignment,
getPhaseTemplate,
getConsultantsByIds,
listFeedbackCategoriesAll, listFeedbackCriterionItemsAll, filterVisibleFeedbackStructure,
listConversationEntriesForMeeting, addConversationEntry, updateConversationEntry, deleteConversationEntry,
listConversationSkillScoresAll, addConversationSkillScore, updateConversationSkillScore, deleteConversationSkillScoresForEntry,
listAssessmentsForMeeting, addAssessment, updateAssessment,
} from '../../db'
import { exportMeetingAsMarkdown, exportMeetingAsJson, downloadFile } from '../../utils/meetingExport'
import { NotationText, splitNoteLines } from '../../utils/notationParser'
@@ -52,38 +60,36 @@ export default function MeetingView() {
entries.filter(e => e.instituteeId === instId).reduce((s, e) => s + (e.fillerCount ?? 0), 0)
const loadData = useCallback(async () => {
const m = await db.meetingInstances.get(meetingId)
const m = await getMeetingInstance(meetingId)
if (!m) return
setMeeting(m)
setGeneralNotes(m.generalNotes ?? '')
const [tmpl, a] = await Promise.all([
db.phaseTemplates.get(m.phaseTemplateId),
db.assignments.get(m.assignmentId),
getPhaseTemplate(m.phaseTemplateId),
getAssignment(m.assignmentId),
])
setTemplate(tmpl ?? null)
setAssignment(a ?? null)
if (a) {
const cons = await db.consultants.where('id').anyOf(a.instituteeIds).toArray()
const cons = await getConsultantsByIds(a.instituteeIds)
setInstitutees(a.instituteeIds.map(cid => cons.find(c => c.id === cid)!).filter(Boolean))
}
const [allCats, allItems, aType] = await Promise.all([
db.feedbackCategories.toArray(),
db.feedbackCriterionItems.toArray(),
a ? db.assignmentTypes.get(a.assignmentTypeId) : Promise.resolve(undefined),
listFeedbackCategoriesAll(),
listFeedbackCriterionItemsAll(),
a ? getAssignmentType(a.assignmentTypeId) : Promise.resolve(undefined),
])
const itemFilter = aType?.criteriaIds?.length ? new Set(aType.criteriaIds) : null
const filteredItems = itemFilter ? allItems.filter(i => itemFilter.has(i.id!)) : allItems
const visibleCatIds = new Set(filteredItems.map(i => i.categoryId))
setFbItems(filteredItems)
setFbCategories(itemFilter ? allCats.filter(c => visibleCatIds.has(c.id!)) : allCats)
const { categories: visibleCats, items: visibleItems } = filterVisibleFeedbackStructure(allCats, allItems, aType?.criteriaIds)
setFbItems(visibleItems)
setFbCategories(visibleCats)
const [convEntries, convScores, asmts] = await Promise.all([
db.conversationEntries.where('meetingInstanceId').equals(meetingId).sortBy('sequenceIndex'),
db.conversationSkillScores.toArray(),
db.assessments.where('meetingInstanceId').equals(meetingId).toArray(),
listConversationEntriesForMeeting(meetingId),
listConversationSkillScoresAll(),
listAssessmentsForMeeting(meetingId),
])
setEntries(convEntries)
setScores(convScores)
@@ -97,13 +103,13 @@ export default function MeetingView() {
const activateInstitutee = async (instId: number) => {
if (activeEntryId !== null) {
if (entryNote.trim() === '') {
await db.conversationEntries.delete(activeEntryId)
await deleteConversationEntry(activeEntryId)
} else {
await db.conversationEntries.update(activeEntryId, { note: entryNote, updatedAt: new Date().toISOString() })
await updateConversationEntry(activeEntryId, { note: entryNote, updatedAt: new Date().toISOString() })
}
}
const maxSeq = entries.reduce((m, e) => Math.max(m, e.sequenceIndex), 0)
const eid = await db.conversationEntries.add({
const eid = await addConversationEntry({
meetingInstanceId: meetingId, instituteeId: instId,
sequenceIndex: maxSeq + 1, note: '', fillerCount: 0, updatedAt: new Date().toISOString(),
})
@@ -126,7 +132,7 @@ export default function MeetingView() {
const saveEntryNote = async () => {
if (activeEntryId === null) return
await db.conversationEntries.update(activeEntryId, { note: entryNote, updatedAt: new Date().toISOString() })
await updateConversationEntry(activeEntryId, { note: entryNote, updatedAt: new Date().toISOString() })
setEntries(prev => prev.map(e => e.id === activeEntryId ? { ...e, note: entryNote } : e))
}
@@ -134,13 +140,13 @@ export default function MeetingView() {
if (activeEntryId === null) return
const entry = entries.find(e => e.id === activeEntryId)
const newCount = (entry?.fillerCount ?? 0) + 1
await db.conversationEntries.update(activeEntryId, { fillerCount: newCount })
await updateConversationEntry(activeEntryId, { fillerCount: newCount })
setEntries(prev => prev.map(e => e.id === activeEntryId ? { ...e, fillerCount: newCount } : e))
}
const closeActiveEntry = async () => {
if (activeEntryId !== null && entryNote.trim() === '') {
await db.conversationEntries.delete(activeEntryId)
await deleteConversationEntry(activeEntryId)
} else {
await saveEntryNote()
}
@@ -156,7 +162,7 @@ export default function MeetingView() {
const entry = entries.find(e => e.id === entryId)
const currentLines = splitNoteLines(editNote)
const prunedTags = (entry?.lineTags ?? []).filter(t => currentLines.includes(t.text))
await db.conversationEntries.update(entryId, { note: editNote, lineTags: prunedTags, updatedAt: new Date().toISOString() })
await updateConversationEntry(entryId, { note: editNote, lineTags: prunedTags, updatedAt: new Date().toISOString() })
setEntries(prev => prev.map(e => e.id === entryId ? { ...e, note: editNote, lineTags: prunedTags } : e))
setEditingId(null)
}
@@ -167,24 +173,24 @@ export default function MeetingView() {
const currentLines = splitNoteLines(entry.note)
const kept = (entry.lineTags ?? []).filter(t => t.text !== lineText && currentLines.includes(t.text))
const nextTags = criterionItemId === null ? kept : [...kept, { text: lineText, criterionItemId }]
await db.conversationEntries.update(entryId, { lineTags: nextTags })
await updateConversationEntry(entryId, { lineTags: nextTags })
setEntries(prev => prev.map(e => e.id === entryId ? { ...e, lineTags: nextTags } : e))
}
const deleteEntry = async (entryId: number) => {
await db.conversationSkillScores.where('conversationEntryId').equals(entryId).delete()
await db.conversationEntries.delete(entryId)
await deleteConversationSkillScoresForEntry(entryId)
await deleteConversationEntry(entryId)
setEntries(prev => prev.filter(e => e.id !== entryId))
}
const adjustFiller = async (entry: ConversationEntry, delta: number) => {
const newCount = Math.max(0, (entry.fillerCount ?? 0) + delta)
await db.conversationEntries.update(entry.id!, { fillerCount: newCount })
await updateConversationEntry(entry.id!, { fillerCount: newCount })
setEntries(prev => prev.map(e => e.id === entry.id ? { ...e, fillerCount: newCount } : e))
}
const changeEntrySpeaker = async (entryId: number, instituteeId: number) => {
await db.conversationEntries.update(entryId, { instituteeId })
await updateConversationEntry(entryId, { instituteeId })
setEntries(prev => prev.map(e => e.id === entryId ? { ...e, instituteeId } : e))
}
@@ -194,11 +200,11 @@ export default function MeetingView() {
const setEntryScore = async (entryId: number, categoryId: number, score: FeedbackRating) => {
const existing = scores.find(s => s.conversationEntryId === entryId && s.criteriaId === categoryId)
if (existing?.id) {
await db.conversationSkillScores.update(existing.id, { score })
await updateConversationSkillScore(existing.id, { score })
} else {
await db.conversationSkillScores.add({ conversationEntryId: entryId, criteriaId: categoryId, score })
await addConversationSkillScore({ conversationEntryId: entryId, criteriaId: categoryId, score })
}
setScores(await db.conversationSkillScores.toArray())
setScores(await listConversationSkillScoresAll())
}
// ── Assessment handlers ───────────────────────────────────────────────────
@@ -210,22 +216,22 @@ export default function MeetingView() {
const existing = assessments.find(a => a.instituteeId === instituteeId && a.criteriaId === itemId)
const now = new Date().toISOString()
if (existing?.id) {
await db.assessments.update(existing.id, { score, updatedAt: now })
await updateAssessment(existing.id, { score, updatedAt: now })
} else {
await db.assessments.add({ meetingInstanceId: meetingId, instituteeId, criteriaId: itemId, score, note: '', updatedAt: now })
await addAssessment({ meetingInstanceId: meetingId, instituteeId, criteriaId: itemId, score, note: '', updatedAt: now })
}
setAssessments(await db.assessments.where('meetingInstanceId').equals(meetingId).toArray())
setAssessments(await listAssessmentsForMeeting(meetingId))
}
const saveAssessmentNote = async (instituteeId: number, itemId: number, note: string) => {
const existing = assessments.find(a => a.instituteeId === instituteeId && a.criteriaId === itemId)
const now = new Date().toISOString()
if (existing?.id) {
await db.assessments.update(existing.id, { note, updatedAt: now })
await updateAssessment(existing.id, { note, updatedAt: now })
} else {
await db.assessments.add({ meetingInstanceId: meetingId, instituteeId, criteriaId: itemId, score: null, note, updatedAt: now })
await addAssessment({ meetingInstanceId: meetingId, instituteeId, criteriaId: itemId, score: null, note, updatedAt: now })
}
setAssessments(await db.assessments.where('meetingInstanceId').equals(meetingId).toArray())
setAssessments(await listAssessmentsForMeeting(meetingId))
}
const autoCalcAssessment = async (instituteeId: number) => {
@@ -248,7 +254,7 @@ export default function MeetingView() {
const saveGeneralNotes = (val: string) => {
setGeneralNotes(val)
if (notesTimer.current) clearTimeout(notesTimer.current)
notesTimer.current = setTimeout(() => db.meetingInstances.update(meetingId, { generalNotes: val }), 600)
notesTimer.current = setTimeout(() => updateMeetingInstance(meetingId, { generalNotes: val }), 600)
}
const buildFilename = (ext: string) => {
@@ -273,13 +279,13 @@ export default function MeetingView() {
const handleDeleteMeeting = async () => {
await saveEntryNote()
await db.meetingInstances.update(meetingId, { deletedAt: new Date().toISOString() })
await softDeleteMeetingInstance(meetingId)
navigate(`/assignment/${assignment?.id}`)
}
const finishMeeting = async () => {
await saveEntryNote()
await db.meetingInstances.update(meetingId, { status: 'done' })
await updateMeetingInstance(meetingId, { status: 'done' })
navigate(`/assignment/${assignment?.id}`)
}
+3 -50
View File
@@ -1,32 +1,6 @@
import { db } from '../db'
import { rpc } from '../db/rpcClient'
import { downloadFile } from './meetingExport'
// Muss mit den Tabellen in db/schema.ts synchron gehalten werden — eine neue Tabelle dort
// landet nicht automatisch im Backup, sondern muss hier manuell ergänzt werden.
const TABLE_NAMES = [
'categories',
'criteria',
'assignmentTypes',
'phaseTemplates',
'groups',
'consultants',
'assignments',
'meetingInstances',
'conversationEntries',
'conversationSkillScores',
'assessments',
'feedbackDrafts',
'feedbackDimensions',
'feedbackCategories',
'feedbackCriterionItems',
'assignmentFeedbacks',
'feedbackCategoryRatings',
'feedbackDimensionTexts',
'criterionCategoryMappings',
'criterionLevelDescriptions',
'appSettings',
] as const
export interface DbBackup {
version: number
exportedAt: string
@@ -34,16 +8,7 @@ export interface DbBackup {
}
export async function exportFullBackup(): Promise<void> {
const tables: Record<string, unknown[]> = {}
for (const name of TABLE_NAMES) {
// eslint-disable-next-line @typescript-eslint/no-explicit-any
tables[name] = await (db as any)[name].toArray()
}
const backup: DbBackup = {
version: 1,
exportedAt: new Date().toISOString(),
tables,
}
const backup = await rpc<DbBackup>('backup', 'exportAll')
const date = new Date().toLocaleDateString('de-DE').replace(/\./g, '-')
downloadFile(JSON.stringify(backup, null, 2), `assignment-monitor-backup-${date}.json`, 'application/json')
}
@@ -57,19 +22,7 @@ export async function importFullBackup(file: File): Promise<{ ok: boolean; error
return { ok: false, error: 'Ungültiges Backup-Format' }
}
// Clear all tables and reimport in dependency order
await db.transaction('rw', TABLE_NAMES.map(n => (db as any)[n]), async () => {
for (const name of [...TABLE_NAMES].reverse()) {
await (db as any)[name].clear()
}
for (const name of TABLE_NAMES) {
const rows = backup.tables[name]
if (Array.isArray(rows) && rows.length > 0) {
await (db as any)[name].bulkAdd(rows)
}
}
})
await rpc('backup', 'importAll', backup.tables)
return { ok: true }
} catch (e) {
return { ok: false, error: e instanceof Error ? e.message : String(e) }
+4 -37
View File
@@ -1,24 +1,9 @@
import { db } from '../db'
import { getMeetingExportData, getFeedbackCriterionItemsByIds } from '../db'
export async function exportMeetingAsMarkdown(meetingId: number): Promise<string> {
const meeting = await db.meetingInstances.get(meetingId)
if (!meeting) throw new Error('Meeting nicht gefunden')
const [template, assignment] = await Promise.all([
db.phaseTemplates.get(meeting.phaseTemplateId),
db.assignments.get(meeting.assignmentId),
])
const { meeting, template, assignment, consultants, entries, allScores, assessments } = await getMeetingExportData(meetingId)
const instituteeIds = assignment?.instituteeIds ?? []
const [consultants, entries, allScores, assessments] = await Promise.all([
instituteeIds.length > 0
? db.consultants.where('id').anyOf(instituteeIds).toArray()
: Promise.resolve([]),
db.conversationEntries.where('meetingInstanceId').equals(meetingId).sortBy('sequenceIndex'),
db.conversationSkillScores.toArray(),
db.assessments.where('meetingInstanceId').equals(meetingId).toArray(),
])
const critIds = [
...new Set([
...(template?.criteriaIds ?? []),
@@ -26,9 +11,7 @@ export async function exportMeetingAsMarkdown(meetingId: number): Promise<string
...entries.flatMap(e => (e.lineTags ?? []).map(t => t.criterionItemId)),
]),
]
const criteria = critIds.length > 0
? await db.feedbackCriterionItems.where('id').anyOf(critIds).toArray()
: []
const criteria = await getFeedbackCriterionItemsByIds(critIds)
const institutees = instituteeIds
.map(id => consultants.find(c => c.id === id))
@@ -124,23 +107,7 @@ export async function exportMeetingAsMarkdown(meetingId: number): Promise<string
}
export async function exportMeetingAsJson(meetingId: number): Promise<string> {
const meeting = await db.meetingInstances.get(meetingId)
if (!meeting) throw new Error('Meeting nicht gefunden')
const [template, assignment] = await Promise.all([
db.phaseTemplates.get(meeting.phaseTemplateId),
db.assignments.get(meeting.assignmentId),
])
const instituteeIds = assignment?.instituteeIds ?? []
const [consultants, entries, allScores, assessments] = await Promise.all([
instituteeIds.length > 0
? db.consultants.where('id').anyOf(instituteeIds).toArray()
: Promise.resolve([]),
db.conversationEntries.where('meetingInstanceId').equals(meetingId).sortBy('sequenceIndex'),
db.conversationSkillScores.toArray(),
db.assessments.where('meetingInstanceId').equals(meetingId).toArray(),
])
const { meeting, template, assignment, consultants, entries, allScores, assessments } = await getMeetingExportData(meetingId)
const entryIds = entries.map(e => e.id!)
const entryScores = allScores.filter(s => entryIds.includes(s.conversationEntryId))
+31 -9
View File
@@ -14,6 +14,33 @@ export interface TrendResult {
delta: number | null
}
/**
* Gewichteter Rohwert (0–4) über eine Menge von Kriterien, N/A ausgeschlossen.
* `null` wenn nichts bewertet ist oder Σweight===0 (sonst NaN < x überall false → fällt auf "Fully" durch).
* Einzige Implementierung dieser Regel — nicht pro Callsite neu schreiben, siehe CLAUDE.md.
*/
export function weightedAverageScore(
items: { id?: number; weight?: number }[],
getScore: (itemId: number) => FeedbackRating | null,
): number | null {
const rated = items
.map(i => ({ score: getScore(i.id!), w: i.weight ?? 1 }))
.filter((x): x is { score: FeedbackRating; w: number } => x.score !== null && x.score !== 'na')
if (rated.length === 0) return null
const wSum = rated.reduce((s, x) => s + x.w, 0)
if (wSum === 0) return null
return rated.reduce((s, x) => s + RATING_NUM_MAP[x.score] * x.w, 0) / wSum
}
/** Wie weightedAverageScore, aber als FeedbackRating-Bucket statt Rohwert. */
export function weightedAverageRating(
items: { id?: number; weight?: number }[],
getScore: (itemId: number) => FeedbackRating | null,
): FeedbackRating | null {
const avg = weightedAverageScore(items, getScore)
return avg === null ? null : numberToRating(avg)
}
/**
* Ein Wert pro Meeting für eine Gruppe von Kriterien (eine Kategorie oder alle Items für "overall").
* Meetings ohne bewertetes Item aus der Gruppe werden übersprungen — ein Delivery-Call, der eine
@@ -21,19 +48,14 @@ export interface TrendResult {
*/
export function buildGroupMeetingScores(
items: FeedbackCriterionItem[],
meetingsChronological: { id: number; date: string }[],
meetingsChronological: { id?: number; date: string }[],
getScore: (meetingId: number, itemId: number) => FeedbackRating | null,
): MeetingScorePoint[] {
const points: MeetingScorePoint[] = []
for (const meeting of meetingsChronological) {
const rated = items
.map(i => ({ score: getScore(meeting.id, i.id!), w: i.weight ?? 1 }))
.filter((x): x is { score: FeedbackRating; w: number } => x.score !== null && x.score !== 'na')
if (rated.length === 0) continue
const wSum = rated.reduce((s, x) => s + x.w, 0)
if (wSum === 0) continue // alle beteiligten Kriterien auf Gewicht 0 → keine Aussage möglich, sonst NaN < x ist überall false und fällt auf "Fully" durch
const score = rated.reduce((s, x) => s + RATING_NUM_MAP[x.score] * x.w, 0) / wSum
points.push({ meetingId: meeting.id, date: meeting.date, score })
const score = weightedAverageScore(items, itemId => getScore(meeting.id!, itemId))
if (score === null) continue
points.push({ meetingId: meeting.id!, date: meeting.date, score })
}
return points
}