From 3d170bc8fcb8cc05c111296cc8a0d5346ec5535e Mon Sep 17 00:00:00 2001 From: Peter Hornburger Date: Sun, 21 Jan 2024 18:55:01 +0100 Subject: [PATCH] Sonntag 19:00 --- src/constclass.ts | 2 + src/database/simontabelledbclass.ts | 160 ++++++++++++++++++ ...tabellebesondereleistungstruktur_server.ts | 22 +++ .../simontabelleeintragstruktur_server.ts | 19 +++ .../simontabellestruktur_server.ts | 42 +++++ src/index.ts | 5 + src/routes/simontabellerouts.ts | 133 +++++++++++++++ 7 files changed, 383 insertions(+) create mode 100644 src/database/simontabelledbclass.ts create mode 100644 src/datenstrukturen/simontabellebesondereleistungstruktur_server.ts create mode 100644 src/datenstrukturen/simontabelleeintragstruktur_server.ts create mode 100644 src/datenstrukturen/simontabellestruktur_server.ts create mode 100644 src/routes/simontabellerouts.ts diff --git a/src/constclass.ts b/src/constclass.ts index 8416210..dbaa352 100644 --- a/src/constclass.ts +++ b/src/constclass.ts @@ -12,6 +12,7 @@ export class Constclass { public readonly LOPListecollectionName: string; public readonly EmailcollectionName: string; public readonly NotizenkapitelcollectionName: string; + public readonly SimontabellencollectionName: string; public readonly BAESiteID: string; public readonly FestlegungskategoriecollectionName: string; @@ -29,6 +30,7 @@ export class Constclass { this.LOPListecollectionName = 'lopliste'; this.EmailcollectionName = 'email'; this.NotizenkapitelcollectionName = 'notizenkapitel'; + this.SimontabellencollectionName = 'simontabellen'; this.FestlegungskategoriecollectionName = 'festlegungskategorie'; this.BAESiteID = 'baeeu.sharepoint.com,1b93d6ea-3f8b-4416-9ff1-a50aaba6f8ca,134790cc-e062-4882-ae5e-18813809cc87'; // Projekte Seite } diff --git a/src/database/simontabelledbclass.ts b/src/database/simontabelledbclass.ts new file mode 100644 index 0000000..1468589 --- /dev/null +++ b/src/database/simontabelledbclass.ts @@ -0,0 +1,160 @@ +import {Document, model} from "mongoose"; +import {DebugClass} from "../debug"; +import {Constclass} from "../constclass"; +import * as mongoose from "mongoose"; +import {ISimontabellestruktur, Simontabelleshema} from "../datenstrukturen/simontabellestruktur_server"; + +export class SimontabelleDBClass { + + private Debug: DebugClass; + private Const: Constclass; + + constructor() { + + this.Debug = new DebugClass(); + this.Const = new Constclass(); + } + + public ReadSimontabelleliste(projektkey: string): Promise { + + try { + + let SimontabellemodelClass: mongoose.Model; + let Liste: ISimontabellestruktur[] = []; + + return new Promise((resolve, reject) => { + + SimontabellemodelClass = model(this.Const.SimontabellencollectionName, Simontabelleshema); + + SimontabellemodelClass.find( { Deleted: false, Projektkey: projektkey } ).then((data: any) => { + + data.forEach((simontabelle) => { + + Liste.push(simontabelle._doc); + }); + + resolve(Liste); + + }).catch((error: any) => { + + reject(error); + }); + + }); + + } catch (error) { + + this.Debug.ShowErrorMessage(error.message, error, 'SimontabelleDBClass', 'ReadSimontabelleliste'); + } + } + + public RemoveSimontabelle(simontabelle: ISimontabellestruktur): Promise { + + try { + + let SimontabellemodelClass: mongoose.Model; + + return new Promise((resolve, reject) => { + + SimontabellemodelClass = model(this.Const.SimontabellencollectionName, Simontabelleshema); + + SimontabellemodelClass.deleteOne({_id: simontabelle._id}).then((result: any) => { + + resolve(true); + + }).catch((error) => { + + reject(error); + }); + + }); + + } catch (error) { + + this.Debug.ShowErrorMessage(error.message, error, 'SimontabelleDBClass', 'RemoveSimontabelle'); + } + } + + public AddSimontabelle(data: ISimontabellestruktur):Promise { + + try { + + let Simontabellemodel: mongoose.Document; + + return new Promise((resolve, reject) => { + + delete data._id; + + Simontabellemodel = this.GetSimontabelleModel(data); + + Simontabellemodel.save().then((result: Document) => { + + resolve(result); + + }).catch((error) => { + + reject(error); + }); + }); + + } catch (error) { + + this.Debug.ShowErrorMessage(error.message, error, 'SimontabelleDBClass', 'AddSimontabelle'); + } + } + + public UpdateSimontabelle(data: ISimontabellestruktur):Promise { + + try { + + let SImontabellemodelClass: mongoose.Model; + + return new Promise((resolve, reject) => { + + SImontabellemodelClass = model(this.Const.SimontabellencollectionName, Simontabelleshema); + + SImontabellemodelClass.findById(data._id).then((simontabelle: mongoose.Document) => { + + if(simontabelle) { + + simontabelle.set(data); + simontabelle.save().then((result: Document) => { + + resolve(result); + + }).catch((error) => { + + reject(error); + }); + } + else { + + resolve(null); + } + }).catch((error) => { + + reject(error); + }); + }); + + } catch (error) { + + this.Debug.ShowErrorMessage(error.message, error, 'SimontabelleDBClass', 'UpdateSimontabelle'); + } + } + + public GetSimontabelleModel(data: ISimontabellestruktur): mongoose.Document { + + try { + + const SimontabellemodelClass = model(this.Const.SimontabellencollectionName, Simontabelleshema); + const Simontabellemodel: mongoose.Document = new SimontabellemodelClass(data); + + return Simontabellemodel; + } + catch (error) { + + this.Debug.ShowErrorMessage(error.message, error, 'SimontabelleDBClass', 'GetSimontabelleModel'); + } + } +} diff --git a/src/datenstrukturen/simontabellebesondereleistungstruktur_server.ts b/src/datenstrukturen/simontabellebesondereleistungstruktur_server.ts new file mode 100644 index 0000000..991022a --- /dev/null +++ b/src/datenstrukturen/simontabellebesondereleistungstruktur_server.ts @@ -0,0 +1,22 @@ +import mongoose from "mongoose"; + +interface ISimontabellebesondereleistungstruktur { + + LeistungID: string; + Nummer: string; + Titel: string; + Beschreibung: string; + Honorar: number; +}; + +const Simontabellebesondereleistungshema = new mongoose.Schema({ + + LeistungID: {type: String, required: false}, + Nummer: {type: String, required: false}, + Titel: {type: String, required: false}, + Beschreibung: {type: String, required: false}, + Honorar: {type: Number, required: false, default: 0}, + +}, {_id: false} ); + +export { ISimontabellebesondereleistungstruktur, Simontabellebesondereleistungshema }; diff --git a/src/datenstrukturen/simontabelleeintragstruktur_server.ts b/src/datenstrukturen/simontabelleeintragstruktur_server.ts new file mode 100644 index 0000000..4549632 --- /dev/null +++ b/src/datenstrukturen/simontabelleeintragstruktur_server.ts @@ -0,0 +1,19 @@ +import mongoose from "mongoose"; + +interface ISimontabelleeintragstruktur { + + Buchstabe: string; + Beschreibung: string; + Von: number; + Bis: number; + Vertrag: number; +}; + +const Simontabelleeintragshema = new mongoose.Schema({ + + Buchstabe: {type: String, required: false}, + Vertrag: {type: String, required: false}, + +}, {_id: false}); + +export { ISimontabelleeintragstruktur, Simontabelleeintragshema }; diff --git a/src/datenstrukturen/simontabellestruktur_server.ts b/src/datenstrukturen/simontabellestruktur_server.ts new file mode 100644 index 0000000..09beadf --- /dev/null +++ b/src/datenstrukturen/simontabellestruktur_server.ts @@ -0,0 +1,42 @@ +import mongoose from "mongoose"; +import {Bautagebucheintragshema} from "./bautagebucheintragstruktur_server"; +import {IVerfasserstruktur, Verfassershema} from "./verfasserstruktur_server"; +import {ISimontabelleeintragstruktur, Simontabelleeintragshema} from "./simontabelleeintragstruktur_server"; +import { + ISimontabellebesondereleistungstruktur, + Simontabellebesondereleistungshema +} from "./simontabellebesondereleistungstruktur_server"; + +interface ISimontabellestruktur { + + _id: string; + Projektkey: string; + Leistungsphase: string; + Anlagengruppe: number; + Durchschnittswert: number; + Verfasser: IVerfasserstruktur; + Eintraegeliste: ISimontabelleeintragstruktur[]; + Deleted: boolean; + Kosten: number; + Honorar: number; + Umbauzuschlag: number; + Nebenkosten: number; + Besondereleistungenliste: ISimontabellebesondereleistungstruktur[]; +}; + +const Simontabelleshema = new mongoose.Schema({ + + Projektkey: {type: String, required: false}, + Leistungsphase: {type: String, required: false}, + Kosten: {type: Number, required: false, default: 0}, + Honorar: {type: Number, required: false, default: 0}, + Umbauzuschlag: {type: Number, required: false, default: 0}, + Nebenkosten: {type: Number, required: false, default: 0}, + Besondereleistungenliste: [Simontabellebesondereleistungshema], + Anlagengruppe: {type: Number, required: false}, + Deleted: {type: Boolean, required: false, default: true}, + Verfasser: Verfassershema, + Eintraegeliste: [Simontabelleeintragshema], +}); + +export { ISimontabellestruktur, Simontabelleshema }; diff --git a/src/index.ts b/src/index.ts index dbd9181..b5a7cc9 100644 --- a/src/index.ts +++ b/src/index.ts @@ -53,6 +53,7 @@ import {SendLOPListeroutsClass} from "./routes/sendloplisterouts"; import {SaveLOPListeroutsClass} from "./routes/saveloplisterouts"; import {SendReminderroutsClass} from "./routes/sendreminderrouts"; import {FestlegungskategorieouterClass} from "./routes/festlegungskategorierouts"; +import {SimontabelleroutsClass} from "./routes/simontabellerouts"; const app: Application = express(); @@ -88,6 +89,7 @@ const SendReminderrouts: SendReminderroutsClass = new SendReminderroutsClass(); const SendLOPListerouter: SendLOPListeroutsClass = new SendLOPListeroutsClass(); const SaveFestlegungenrouts: SaveFestlegungenroutsClass = new SaveFestlegungenroutsClass(); const Addsubscriptionrouts: AddsubscriptionroutsClass = new AddsubscriptionroutsClass(); +const Simontabellenrouts: SimontabelleroutsClass = new SimontabelleroutsClass(); const NONE = 'NONE'; let Port: string = 'none'; @@ -178,6 +180,7 @@ SendReminderrouts.Init(Config); SaveFestlegungenrouts.Init(Config); SaveLOPListerouter.Init(Config); Addsubscriptionrouts.Init(Config); +Simontabellenrouts.Init(Config); Homerouter.SetRoutes(); Errorrouter.SetRoutes(); @@ -207,6 +210,7 @@ Emailrouter.SetRoutes(); Addsubscriptionrouts.SetRoutes(); Notizenkapitelroutes.SetRoutes(); Festlegungskategorieroutes.SetRoutes(); +Simontabellenrouts.SetRoutes(); app.use('/', Homerouter.homerouter); app.use('/.auth/login/aad/callback', Homerouter.homerouter); @@ -237,6 +241,7 @@ app.use('/email', Emailrouter.emailrouter); app.use('/subscription', Addsubscriptionrouts.subscriptionrouter); app.use('/notizenkapitel', Notizenkapitelroutes.notizenkapitelrouter); app.use('/festlegungskategorie', Festlegungskategorieroutes.festlegungskategorierouter); +app.use('/simontabellen', Simontabellenrouts.simontabellerouter); // eventcallback diff --git a/src/routes/simontabellerouts.ts b/src/routes/simontabellerouts.ts new file mode 100644 index 0000000..a3dce5d --- /dev/null +++ b/src/routes/simontabellerouts.ts @@ -0,0 +1,133 @@ +import {Request, Response, Router} from 'express'; +import {DebugClass} from "../debug"; +import {AuthenticationClass} from "../middleware/authentication"; +import {SimontabelleDBClass} from "../database/simontabelledbclass"; +import {ISimontabellestruktur} from "../datenstrukturen/simontabellestruktur_server"; +import {ConfigClass} from "../configclass"; + +export class SimontabelleroutsClass { + + public simontabellerouter: any; + private Debug: DebugClass; + private Database: SimontabelleDBClass; + private Authentication: AuthenticationClass; + private Config: ConfigClass; + + constructor() { + + this.Debug = new DebugClass(); + this.Database = new SimontabelleDBClass(); + this.simontabellerouter = Router(); + this.Authentication = new AuthenticationClass(); + } + + + Init(config: ConfigClass) { + + try { + + this.Config = config; + + } catch (error) { + + this.Debug.ShowErrorMessage(error, 'AddsubscriptionroutsClass', 'Init', this.Debug.Typen.Class); + } + } + + public SetRoutes() { + + try { + + this.simontabellerouter.get('/', this.Authentication.authenticate, (req: Request, res: Response) => { + + let query = req.query; + let Projektkey = query.projektkey; + + console.log('Read Simontabellen: '); + console.log('Projektkey: ' + Projektkey); + + this.Database.ReadSimontabelleliste(Projektkey).then((liste: ISimontabellestruktur[]) => { + + res.status(200).send(liste); + + }).catch((error) => { + + res.status(400).send(error.message); + + }); + }); + + this.simontabellerouter.put('/', (req: Request, res: Response) => { + + // PUT ist für Update + + console.log('Simontabelle PUT'); + + const data = req.body; + const Simontabelle: ISimontabellestruktur = data.Simontabelle; + const Delete: boolean = data.Delete; + + console.log('Simontabelle: ' + JSON.stringify(Simontabelle)); + + if(Delete === false) { + + // Update + + this.Database.UpdateSimontabelle(Simontabelle).then((result) => { + + if(result !== null) { + + res.status(200).send({ message: 'Saved: ' + data.Titel, Simontabelle: Simontabelle }); + } + else { + + res.status(404).send({ message: 'Simontabelle not found.', data: null }); + } + + }).catch((error) => { + + res.status(400).send({ message: error.message }); + }); + } + else { + + this.Database.RemoveSimontabelle(Simontabelle).then(() => { + + res.status(200).send({ message: 'Simontabelle wurde gelöscht', Simontabelle: Simontabelle }); + + }).catch((error) => { + + res.status(400).send({message: error.message}); + }) + } + + }); + + this.simontabellerouter.post('/', (req: Request, res: Response) => { + + // POST ist für neuen Eintrag + + console.log('Simontabelle POST'); + + const data = req.body; + + console.dir('Daten: ' + JSON.stringify(data)); + + this.Database.AddSimontabelle(data).then((result) => { + + res.status(200).send({ message: 'Simontabelle added', Simontabelle: result._doc }); + + }).catch((error) => { + + res.status(400).send({ message: error.message }); + }); + }); + + } catch (error) { + + this.Debug.ShowErrorMessage(error.message, error, 'SimontabelleroutsClass', 'SetRoutes'); + } + } +} + +