kocoded/vt
1
0
Fork 0
Code Issues 1 Pull Requests Actions Packages Projects Releases Wiki Activity

Bulk commit: November work

Browse Source
This commit is contained in:
Konstantin Hintermayer
2025-11-06 11:46:35 +01:00
parent cf82dede3b
commit 183875baf4
60 changed files with 16590 additions and 102 deletions
Download Patch File Download Diff File Expand all files Collapse all files

13
routers/ansprechpartner.go
View File

@ -14,12 +14,13 @@ type ansprechpartnerRouter struct {
func RegisterAnsprechpartnerRouter(group fiber.Router, appCtx utils.Application) {
router := &ansprechpartnerRouter{Application: appCtx}
group.Post("/new", router.createAnsprechpartner)
group.Get("/all", router.getAllAnsprechpartners)
group.Get("/:id<int>", router.getAnsprechpartner)
group.Get("/:id<int>/firmen", router.getAnsprechpartnerFirmen)
group.Put("/:id<int>", router.updateAnsprechpartner)
group.Delete("/:id<int>", router.deleteAnsprechpartner)
r := group.Use(utils.IsAuthenticated(appCtx))
r.Post("/new", router.createAnsprechpartner)
r.Get("/all", router.getAllAnsprechpartners)
r.Get("/:id<int>", router.getAnsprechpartner)
r.Get("/:id<int>/firmen", router.getAnsprechpartnerFirmen)
r.Put("/:id<int>", router.updateAnsprechpartner)
r.Delete("/:id<int>", router.deleteAnsprechpartner)
}
func (r *ansprechpartnerRouter) createAnsprechpartner(c *fiber.Ctx) error {

11
routers/firma.go
View File

@ -14,11 +14,12 @@ type firmaRouter struct {
func RegisterFirmaRouter(group fiber.Router, appCtx utils.Application) {
router := &firmaRouter{Application: appCtx}
group.Post("/new", router.createFirma)
group.Get("/all", router.getAllFirmen)
group.Get("/:id<int>", router.getFirma)
group.Put("/:id<int>", router.updateFirma)
group.Delete("/:id<int>", router.deleteFirma)
r := group.Use(utils.IsAuthenticated(appCtx))
r.Post("/new", router.createFirma)
r.Get("/all", router.getAllFirmen)
r.Get("/:id<int>", router.getFirma)
r.Put("/:id<int>", router.updateFirma)
r.Delete("/:id<int>", router.deleteFirma)
}
func (r *firmaRouter) createFirma(c *fiber.Ctx) error {

7
routers/mandant.go
View File

@ -15,9 +15,10 @@ type mandantRouter struct {
func RegisterMandantRouter(group fiber.Router, appCtx utils.Application) {
router := &mandantRouter{currentMandant: 1, Application: appCtx}
group.Get("/current", router.getCurrentMandant)
group.Put("/current", router.setCurrentMandant)
group.Get("/all", router.getAllMandant)
r := group.Use(utils.IsAuthenticated(appCtx))
r.Get("/current", router.getCurrentMandant)
r.Put("/current", router.setCurrentMandant)
r.Get("/all", router.getAllMandant)
}
func (r *mandantRouter) getCurrentMandant(c *fiber.Ctx) error {

171
routers/project.go Normal file
View File

@ -0,0 +1,171 @@
package routers
import (
"strconv"
"git.kocoder.xyz/kocoded/vt/model"
"git.kocoder.xyz/kocoded/vt/query"
"git.kocoder.xyz/kocoded/vt/utils"
"github.com/gofiber/fiber/v2"
)
type projectRouter struct {
utils.Application
currentMandant uint
}
func RegisterProjectRouter(group fiber.Router, appCtx utils.Application) {
router := &projectRouter{currentMandant: 1, Application: appCtx}
r := group.Use(utils.IsAuthenticated(appCtx))
r.Get("/all", router.getAllProjects)
r.Post("/new", router.createNewProject)
r.Get("/:id<int>", router.getProject)
r.Post("/:id<int>/edit", router.editProject)
r.Delete("/:id<int>/delete", router.deleteProject)
}
func (r *projectRouter) getAllProjects(c *fiber.Ctx) error {
p := query.Projekt
pph := c.Get("X-PER-PAGE")
ofh := c.Get("X-OFFSET")
params := struct {
Id string `params:"id"`
Desc bool `params:"desc"`
}{}
if err := c.QueryParser(&params); err != nil {
r.Logger.Warn("Param Parser Error: ", "err", err)
}
var pp, of int
pp, err := strconv.Atoi(pph)
if err != nil {
r.Logger.Warn("Per Page header not found.", "error", err)
return c.SendStatus(fiber.StatusInternalServerError)
}
of, err = strconv.Atoi(ofh)
if err != nil {
r.Logger.Warn("Offset header not found.", "error", err)
return c.SendStatus(fiber.StatusInternalServerError)
}
query := p.Where().Limit(pp).Offset(of)
if params.Id != "" {
f, ok := p.GetFieldByName(params.Id)
if ok {
if params.Desc {
query = query.Order(f.Desc())
} else {
query = query.Order(f.Asc())
}
}
} else {
query = query.Order(p.ID.Asc())
}
projects, err := query.Order(p.Name.Asc()).Find()
if err != nil {
r.Logger.Warn("Current mandant not found.", "error", err)
return c.SendStatus(fiber.StatusInternalServerError)
}
cnt, err := p.Count()
if err != nil {
r.Logger.Warn("Current mandant not found.", "error", err)
return c.SendStatus(fiber.StatusInternalServerError)
}
res := &PaginatedProjects{Data: projects, Meta: struct {
TotalProjectsCount int64 `json:"totalProjectsCount"`
}{TotalProjectsCount: cnt}}
return c.JSON(res)
}
type PaginatedProjects struct {
Data []*model.Projekt `json:"data"`
Meta struct {
TotalProjectsCount int64 `json:"totalProjectsCount"`
} `json:"meta"`
}
func (r *projectRouter) getProject(c *fiber.Ctx) error {
ids := c.Params("id")
id, err := strconv.ParseUint(ids, 10, 32)
if err != nil {
r.Logger.Warn("Id is not an int.", "error", err)
return c.SendStatus(fiber.StatusInternalServerError)
}
p := query.Projekt
currentProject, err := p.Where(p.ID.Eq(uint(id))).First()
if err != nil {
r.Logger.Warn("Current mandant not found.", "error", err)
return c.SendStatus(fiber.StatusInternalServerError)
}
return c.JSON(currentProject)
}
func (r *projectRouter) createNewProject(c *fiber.Ctx) error {
p := query.Projekt
project := &model.Projekt{}
if err := c.BodyParser(project); err != nil {
return err
}
err := p.Create(project)
if err != nil {
r.Logger.Warn("Couldn't create Projejct.", "error", err)
return c.SendStatus(fiber.StatusInternalServerError)
}
utils.MessageBus.SendMBObject(int(project.MandantID), utils.MessageBusObject{Entity: []string{"projects", "list"}})
utils.MessageBus.SendMBObject(int(project.MandantID), utils.MessageBusObject{Entity: []string{"projects", "get"}, Id: int(project.ID)})
return c.JSON(project)
}
func (r *projectRouter) editProject(c *fiber.Ctx) error {
p := query.Projekt
project := &model.Projekt{}
if err := c.BodyParser(project); err != nil {
return err
}
res, err := p.Where(p.ID.Eq(project.ID)).Updates(project)
if err != nil {
r.Logger.Warn("Couldn't create Projejct.", "error", err)
return c.SendStatus(fiber.StatusInternalServerError)
}
utils.MessageBus.SendMBObject(int(project.MandantID), utils.MessageBusObject{Entity: []string{"projects", "list"}})
utils.MessageBus.SendMBObject(int(project.MandantID), utils.MessageBusObject{Entity: []string{"projects", "get"}, Id: int(project.ID)})
return c.JSON(res)
}
func (r *projectRouter) deleteProject(c *fiber.Ctx) error {
ids := c.Params("id")
id, err := strconv.ParseUint(ids, 10, 32)
if err != nil {
r.Logger.Warn("Id is not an int.", "error", err)
return c.SendStatus(fiber.StatusInternalServerError)
}
p := query.Projekt
res, err := p.Where(p.ID.Eq(uint(id))).Delete()
if err != nil {
r.Logger.Warn("Couldn't create Projejct.", "error", err)
return c.SendStatus(fiber.StatusInternalServerError)
}
return c.JSON(res)
}

32
routers/user.go Normal file
View File

@ -0,0 +1,32 @@
package routers
import (
"git.kocoder.xyz/kocoded/vt/query"
"git.kocoder.xyz/kocoded/vt/utils"
"github.com/gofiber/fiber/v2"
)
type userRouter struct {
utils.Application
}
func RegisterUserRouter(group fiber.Router, appCtx utils.Application) {
router := &userRouter{Application: appCtx}
r := group.Use(utils.IsAuthenticated(appCtx))
r.Get("/current", router.getCurrentUserInfo)
}
func (r *userRouter) getCurrentUserInfo(c *fiber.Ctx) error {
u := query.User
session := c.Locals("USER_KEY").(*utils.Session)
currentUser, err := u.Where(u.ID.Eq(session.UserID)).First()
if err != nil {
r.Logger.Warn("Current mandant not found.", "error", err)
return c.SendStatus(fiber.StatusInternalServerError)
}
return c.JSON(currentUser)
}