kbcrm/Client/Components/projekt.ts

import m from "mithril"
import {Form, iForm} from "./widgets/form"
import { Input, iInput} from "./widgets/inputs"
import {Select, iSelect, iSelectOption} from "./widgets/select"
import {Treenode, iTreenode, Treetable, iTreetable, TopbarButton, iTopbarButton} from "./widgets/Treetable_V2"
import {iProjekt, getProjekteByKundenId, getNewProjektId, addProjekt, updateProjekt} from "../models/projekt"
import {iKunde, getKunden} from "../models/kunde"

function createProjektTreenodes(kundenId: number | null = null): iTreenode[] {
    let filteredProjekte = getProjekteByKundenId(kundenId)

    return filteredProjekte.map((projekt: iProjekt) => {
        return new Treenode(projekt, true, [])
    })
}

export const projektliste: m.ClosureComponent = (vnode) => {
    let treenodes: iTreenode[] = createProjektTreenodes()
    let selectedNode: iTreenode | null = null
    let filterKundenId: number | null = null
    
    const handleRowMarked = (node: iTreenode) => {
        selectedNode = node
    }

    const addProjektRoute = () => {
        const params: any = {
            id: -1,
            kundenname: "",
            projektname: "",
            zweck: "",
            verantwortlicher: "",
            startdatum: ""
        }
        // Nur bei kundengefilterter Liste den Kunden vorbelegen.
        if (filterKundenId !== null) {
            const kunde = getKunden().find((k: iKunde) => k.id === filterKundenId)
            if (kunde) {
                params.kundenId = kunde.id
                params.kundenname = kunde.name
            }
        }
        m.route.set("/projekt", params)
    }
    
    const editProjekt = (projekt: iProjekt, e: Event) => {
        e.stopPropagation()
        m.route.set("/projekt", {
            id: projekt.id,
            kundenId: projekt.kundenId,
            kundenname: projekt.kundenName,
            projektname: projekt.projektname,
            zweck: projekt.zweck,
            verantwortlicher: projekt.verantwortlicher,
            startdatum: projekt.startdatum
        })
    }
    
    const showCallLogs = (projekt: iProjekt, e: Event) => {
        e.stopPropagation()
        m.route.set("/calllogliste", {projektId: projekt.id})
    }
    
    const addCallLog = (projekt: iProjekt, e: Event) => {
        e.stopPropagation()
        const now = new Date()
        const datum = now.toISOString().split('T')[0]
        const uhrzeit = now.toTimeString().split(':')[0] + ':' + now.toTimeString().split(':')[1]
        m.route.set("/call_log", {
            id: -1,
            kundenName: projekt.kundenName,
            projektId: projekt.id,
            projektName: projekt.projektname,
            datum: datum,
            uhrzeitBeginn: uhrzeit,
            dauer: "",
            betreff: "",
            nameAnsprechpartner: "",
            telefon: "",
            notiz: "",
            wiedervorlageDatum: "",
            erledigt: false
        })
    }
    
    const columnmapper: (node: iTreenode) => any[] = (node: iTreenode) => {
        let projekt: iProjekt = node.nodevalue
        const isSelected = selectedNode === node
        const cellStyle = isSelected ? {backgroundColor: '#e6f7ff'} : {}
        
        return [
            m("div", {style: cellStyle}, m("strong", projekt.kundenName)),
            m("span", {style: cellStyle}, projekt.projektname),
            m("span", {style: cellStyle}, projekt.zweck),
            m("span", {style: cellStyle}, projekt.verantwortlicher),
            m("span", {style: cellStyle}, projekt.startdatum),
            m("button.w3-button.w3-small", {style: cellStyle, onclick: (e: Event) => editProjekt(projekt, e)}, m("i.material-icons", "edit")),
            m("button.w3-button.w3-small", {title: "Gesprächsnotizen anzeigen", style: cellStyle, onclick: (e: Event) => showCallLogs(projekt, e)}, m("i.material-icons", "call_log")),
            m("button.w3-button.w3-small", {title: "Gesprächsnotiz hinzufügen", style: cellStyle, onclick: (e: Event) => addCallLog(projekt, e)}, m("i.material-icons", "add_call"))
        ]
    }
    
    const filterFunction = (node: iTreenode, searchvalue: string): boolean => {
        let projekt: iProjekt = node.nodevalue
        let searchLower = searchvalue.toLowerCase()
        return projekt.kundenName.toLowerCase().includes(searchLower) ||
               projekt.projektname.toLowerCase().includes(searchLower) ||
               projekt.zweck.toLowerCase().includes(searchLower) ||
               projekt.verantwortlicher.toLowerCase().includes(searchLower) ||
               projekt.startdatum.includes(searchLower)
    }
    
    return {
        oninit: (vnode) => {
            const routeParams = m.route.param()
            if (routeParams && routeParams.kundenId) {
                filterKundenId = parseInt(routeParams.kundenId)
            } else {
                filterKundenId = null
            }
            treenodes = createProjektTreenodes(filterKundenId)
        },
        view: (vnode) => {
            return m("div.w3-container.w3-auto", {
                style: {
                    display: 'flex', 
                    'flex-direction': 'column', 
                    height: 'inherit', 
                    'overflow-y': 'inherit'}},
                m("h1", "Projektliste"),
                m("div", {style: {flex: '1', 'overflow-y': 'inherit'}},
                    m(Treetable, 
                        {
                            treenodes: treenodes,
                            columnmapper: columnmapper,
                            filter: filterFunction,
                            onRowMarked: handleRowMarked
                        } as iTreetable,
                        m(TopbarButton, {onclick: addProjektRoute, tooltip: "Neues Projekt anlegen"} as iTopbarButton,
                            m("i.material-icons", "post_add")
                        )
                    )
                )
            )
        }
    }
}

export const Projekt: m.ClosureComponent = (vnode) => {
    // currentProjekt hält den Formularzustand. kundenId referenziert den
    // Kunden eindeutig, kundenname dient der Anzeige.
    let currentProjekt: {
        id: number
        kundenId: number
        kundenname: string
        projektname: string
        zweck: string
        verantwortlicher: string
        startdatum: string
    } = {
        id: -1,
        kundenId: -1,
        kundenname: "",
        projektname: "",
        zweck: "",
        verantwortlicher: "",
        startdatum: ""
    }
    // Ist der Kunde voreingestellt (gefilterte Projektliste)?
    let kundeVoreingestellt: boolean = false

    return {
        oninit: (vnode) => {
            const routeParams = m.route.param()
            if (routeParams) {
                const kundenId = routeParams.kundenId ? parseInt(routeParams.kundenId) : -1
                kundeVoreingestellt = kundenId !== -1
                currentProjekt = {
                    id: routeParams.id ? parseInt(routeParams.id) : -1,
                    kundenId: kundenId,
                    kundenname: routeParams.kundenname || "",
                    projektname: routeParams.projektname || "",
                    zweck: routeParams.zweck || "",
                    verantwortlicher: routeParams.verantwortlicher || "",
                    startdatum: routeParams.startdatum || ""
                }
            }
        },
        view: (vnode) => {
            const submit = (form: HTMLFormElement): boolean => {
                const formData = new FormData(form)
                const kundenId = parseInt(formData.get("kundenId") as string)
                // Kundennamen zur gewählten kundenId auflösen.
                const kunde = getKunden().find((k: iKunde) => k.id === kundenId)
                const gespeichertesProjekt: iProjekt = {
                    id: currentProjekt.id,
                    kundenId: kundenId,
                    kundenName: kunde ? kunde.name : "",
                    projektname: (formData.get("projektname") as string) || "",
                    zweck: (formData.get("zweck") as string) || "",
                    verantwortlicher: (formData.get("verantwortlicher") as string) || "",
                    startdatum: (formData.get("startdatum") as string) || ""
                }
                if (currentProjekt.id === -1) {
                    gespeichertesProjekt.id = getNewProjektId()
                    addProjekt(gespeichertesProjekt)
                } else {
                    updateProjekt(gespeichertesProjekt)
                }
                m.route.set("/projektliste")
                return true
            }
            const cancel = (e: Event) => {
                m.route.set("/projektliste")
            }
            // Select-Optionen aus der Kundenliste aufbauen.
            const kundenOptionen: iSelectOption[] = getKunden().map((k: iKunde) => {
                return {value: k.id, label: k.name}
            })
            return m("div.w3-container.w3-auto",
                m("h1", currentProjekt.id === -1 ? "Neues Projekt anlegen" : "Projekt-Stammblatt"),
                m(Form, {showButtons: true, onsubmit: submit, oncancel: cancel} as iForm, [
                    m("label", "Kunde",
                        m(Select, {
                            name: "kundenId",
                            value: currentProjekt.kundenId,
                            options: kundenOptionen,
                            readonly: kundeVoreingestellt,
                            required: true
                        } as iSelect)),
                    m("label", "Projektname", m(Input, {name: "projektname", value: currentProjekt.projektname, type: "text", required: true} as iInput)),
                    m("label", "Zweck", m(Input, {name: "zweck", value: currentProjekt.zweck, type: "text"} as iInput)),
                    m("label", "Verantwortlicher", m(Input, {name: "verantwortlicher", value: currentProjekt.verantwortlicher, type: "text"} as iInput)),
                    m("label", "Startdatum", m(Input, {name: "startdatum", value: currentProjekt.startdatum, type: "date"} as iInput))
                ])
            )
        }
    }
}