JohnCosta27/Haystack
1
0
Fork 0
Code Issues 7 Pull Requests Actions Packages Projects 1 Releases Wiki Activity

feat: implementing delete schema column function

Browse Source
This commit is contained in:
John Costa
2025-10-05 13:59:54 +01:00
parent 015a7cb5cd
commit ecd1529130
2 changed files with 87 additions and 20 deletions
Download Patch File Download Diff File Expand all files Collapse all files

31
backend/models/lists.go → backend/models/stacks.go
View File

@ -54,7 +54,7 @@ func (m StackModel) List(ctx context.Context, userId uuid.UUID) ([]StackWithItem
return lists, err
}
func (m StackModel) ListItems(ctx context.Context, listID uuid.UUID) ([]ImageWithSchema, error) {
func (m StackModel) ListItems(ctx context.Context, stackID uuid.UUID) ([]ImageWithSchema, error) {
getListItems := SELECT(
ImageStacks.AllColumns,
ImageSchemaItems.AllColumns,
@ -63,7 +63,7 @@ func (m StackModel) ListItems(ctx context.Context, listID uuid.UUID) ([]ImageWit
ImageStacks.
INNER_JOIN(ImageSchemaItems, ImageSchemaItems.ImageID.EQ(ImageStacks.ImageID)),
).
WHERE(ImageStacks.StackID.EQ(UUID(listID)))
WHERE(ImageStacks.StackID.EQ(UUID(stackID)))
listItems := make([]ImageWithSchema, 0)
err := getListItems.QueryContext(ctx, m.dbPool, &listItems)
@ -71,8 +71,8 @@ func (m StackModel) ListItems(ctx context.Context, listID uuid.UUID) ([]ImageWit
return listItems, err
}
func (m StackModel) Get(ctx context.Context, listID uuid.UUID) (model.Stacks, error) {
getStackStmt := Stacks.SELECT(Stacks.AllColumns).WHERE(Stacks.ID.EQ(UUID(listID)))
func (m StackModel) Get(ctx context.Context, stackID uuid.UUID) (model.Stacks, error) {
getStackStmt := Stacks.SELECT(Stacks.AllColumns).WHERE(Stacks.ID.EQ(UUID(stackID)))
stack := model.Stacks{}
err := getStackStmt.QueryContext(ctx, m.dbPool, &stack)
@ -146,10 +146,25 @@ func (m StackModel) SaveSchemaItems(ctx context.Context, imageID uuid.UUID, item
// DELETE methods
// ========================================
func (m StackModel) DeleteImage(ctx context.Context, listID uuid.UUID, imageID uuid.UUID) error {
func (m StackModel) DeleteSchemaItem(ctx context.Context, stackID uuid.UUID, schemaItemID uuid.UUID) error {
deleteImageListStmt := SchemaItems.DELETE().
WHERE(
SchemaItems.ID.EQ(UUID(schemaItemID)).
// The StackID check is a sanity check.
// We don't technically need it, but it adds extra protection
// in case we make a mistake later on
AND(SchemaItems.StackID.EQ(UUID(stackID))),
)
_, err := deleteImageListStmt.ExecContext(ctx, m.dbPool)
return err
}
func (m StackModel) DeleteImage(ctx context.Context, stackID uuid.UUID, imageID uuid.UUID) error {
deleteImageListStmt := ImageStacks.DELETE().
WHERE(
ImageStacks.StackID.EQ(UUID(listID)).
ImageStacks.StackID.EQ(UUID(stackID)).
AND(ImageStacks.ImageID.EQ(UUID(imageID))),
)
@ -158,8 +173,8 @@ func (m StackModel) DeleteImage(ctx context.Context, listID uuid.UUID, imageID u
return err
}
func (m StackModel) Delete(ctx context.Context, listID uuid.UUID, userID uuid.UUID) error {
deleteStackStmt := Stacks.DELETE().WHERE(Stacks.ID.EQ(UUID(listID)).AND(Stacks.UserID.EQ(UUID(userID))))
func (m StackModel) Delete(ctx context.Context, stackID uuid.UUID, userID uuid.UUID) error {
deleteStackStmt := Stacks.DELETE().WHERE(Stacks.ID.EQ(UUID(stackID)).AND(Stacks.UserID.EQ(UUID(userID))))
_, err := deleteStackStmt.ExecContext(ctx, m.dbPool)

76
backend/stacks/handler.go
View File

@ -50,14 +50,14 @@ func (h *StackHandler) getStackItems(w http.ResponseWriter, r *http.Request) {
return
}
listID, err := middleware.GetPathParamID(h.logger, "listID", w, r)
stackID, err := middleware.GetPathParamID(h.logger, "listID", w, r)
if err != nil {
return
}
// TODO: must check for permission here.
lists, err := h.stackModel.ListItems(ctx, listID)
lists, err := h.stackModel.ListItems(ctx, stackID)
if err != nil {
h.logger.Warn("could not get list items", "err", err)
w.WriteHeader(http.StatusBadRequest)
@ -83,12 +83,12 @@ func (h *StackHandler) deleteStack(w http.ResponseWriter, r *http.Request) {
return
}
listID, err := middleware.GetPathParamID(h.logger, "listID", w, r)
stackID, err := middleware.GetPathParamID(h.logger, "listID", w, r)
if err != nil {
return
}
err = h.stackModel.Delete(ctx, listID, userID)
err = h.stackModel.Delete(ctx, stackID, userID)
if err != nil {
h.logger.Warn("could not delete stack", "err", err)
w.WriteHeader(http.StatusBadRequest)
@ -101,8 +101,8 @@ func (h *StackHandler) deleteStack(w http.ResponseWriter, r *http.Request) {
func (h *StackHandler) deleteImageFromStack(w http.ResponseWriter, r *http.Request) {
ctx := r.Context()
stringListID := chi.URLParam(r, "stackID")
stringImageID := chi.URLParam(r, "imageID")
stringListID := chi.URLParam(r, "listID")
imageID, err := uuid.Parse(stringImageID)
if err != nil {
@ -110,7 +110,7 @@ func (h *StackHandler) deleteImageFromStack(w http.ResponseWriter, r *http.Reque
return
}
listID, err := uuid.Parse(stringListID)
stackID, err := uuid.Parse(stringListID)
if err != nil {
w.WriteHeader(http.StatusBadRequest)
return
@ -123,7 +123,7 @@ func (h *StackHandler) deleteImageFromStack(w http.ResponseWriter, r *http.Reque
return
}
stack, err := h.stackModel.Get(ctx, listID)
stack, err := h.stackModel.Get(ctx, stackID)
if err != nil {
w.WriteHeader(http.StatusInternalServerError)
return
@ -134,7 +134,58 @@ func (h *StackHandler) deleteImageFromStack(w http.ResponseWriter, r *http.Reque
return
}
err = h.stackModel.DeleteImage(ctx, listID, imageID)
err = h.stackModel.DeleteImage(ctx, stackID, imageID)
if err != nil {
h.logger.Warn("failed to delete image from list", "error", err)
w.WriteHeader(http.StatusInternalServerError)
return
}
w.WriteHeader(http.StatusOK)
}
func (h *StackHandler) deleteImageStackSchemaItem(w http.ResponseWriter, r *http.Request) {
ctx := r.Context()
stringImageID := chi.URLParam(r, "stackID")
stringSchemaItemID := chi.URLParam(r, "schemaItemID")
imageID, err := uuid.Parse(stringImageID)
if err != nil {
w.WriteHeader(http.StatusBadRequest)
return
}
schemaItemID, err := uuid.Parse(stringSchemaItemID)
if err != nil {
w.WriteHeader(http.StatusBadRequest)
return
}
// TODO: this should be extracted into a middleware of sorts
userID, err := middleware.GetUserID(ctx, h.logger, w)
if err != nil {
w.WriteHeader(http.StatusUnauthorized)
return
}
stack, err := h.stackModel.Get(ctx, schemaItemID)
if err != nil {
w.WriteHeader(http.StatusInternalServerError)
return
}
if stack.UserID != userID {
w.WriteHeader(http.StatusUnauthorized)
return
}
// TODO:
// The code above is repeated, because it contains stack & image
// manipulations. So we could create a middleware.
// If you repeat this 3 times, then organise it :)
err = h.stackModel.DeleteSchemaItem(ctx, schemaItemID, imageID)
if err != nil {
h.logger.Warn("failed to delete image from list", "error", err)
w.WriteHeader(http.StatusInternalServerError)
@ -175,12 +226,13 @@ func (h *StackHandler) CreateRoutes(r chi.Router) {
r.Use(middleware.SetJson)
r.Get("/", h.getAllStacks)
r.Get("/{listID}", h.getStackItems)
r.Get("/{stackID}", h.getStackItems)
r.Post("/", middleware.WithLimit(h.logger, h.limitsManager.HasReachedStackLimit, middleware.WithValidatedPost(h.createStack)))
r.Patch("/{listID}", middleware.WithValidatedPost(h.editStack))
r.Delete("/{listID}", h.deleteStack)
r.Delete("/{listID}/{imageID}", h.deleteImageFromStack)
r.Patch("/{stackID}", middleware.WithValidatedPost(h.editStack))
r.Delete("/{stackID}", h.deleteStack)
r.Delete("/{stackID}/{imageID}", h.deleteImageFromStack)
r.Delete("/{stackID}/{schemaItemID}", h.deleteImageStackSchemaItem)
})
}