fix: update (hotels&airports)

intern/parser/form/form.go

@@ -9,6 +9,8 @@ import (
 	"reflect"
 	"strconv"
 	"strings"
+
+	"github.com/google/uuid"
 )
 
 // Unmarshal parses the url.Values data and stores the result
@@ -93,6 +95,13 @@ func Unmarshal(input url.Values, target any) error {
 			if err := Unmarshal(newInput, fieldVal.Addr().Interface()); err != nil {
 				return err
 			}
+		case reflect.TypeOf(uuid.UUID{}).Kind():
+			if fieldValRaw == "" {
+				continue
+			}
+			parsedUUID := uuid.MustParse(fieldValRaw)
+
+			fieldVal.Set(reflect.ValueOf(parsedUUID))
 		default:
 			panic(fmt.Sprintf("unsupported type: %s", field.Type.String()))
 		}

intern/parser/form/form_test.go

@@ -0,0 +1,92 @@
+// Copyright (C) 2024 the lets-party maintainers
+// See root-dir/LICENSE for more information
+
+package form
+
+import (
+	"net/url"
+	"reflect"
+	"testing"
+
+	"github.com/google/uuid"
+)
+
+type TestStruct struct {
+	UUIDField   uuid.UUID   `form:"uuid_field"`
+	StringField string      `form:"string_field"`
+	BoolField   bool        `form:"bool_field"`
+	IntField    int         `form:"int_field"`
+	FloatField  float64     `form:"float_field"`
+	SliceField  []string    `form:"slice_field"`
+	StructField FieldStruct `form:"struct_field"`
+}
+
+type FieldStruct struct {
+	StringField string `form:"field_struct_strfield"`
+	BoolField   bool   `form:"field_struct_boolfield"`
+}
+
+func TestUnmarshal(t *testing.T) {
+	testCases := []struct {
+		name        string
+		input       url.Values
+		expected    TestStruct
+		expectedErr bool
+	}{
+		{
+			name: "Valid input data",
+			input: url.Values{
+				"uuid_field":                          {"ca07d617-c87c-4ac3-affc-27a5e941b28f"},
+				"string_field":                        {"test_string"},
+				"bool_field":                          {"true"},
+				"int_field":                           {"42"},
+				"float_field":                         {"3.14"},
+				"slice_field":                         {"1", "2", "3"},
+				"struct_field.field_struct_strfield":  {"stringfield"},
+				"struct_field.field_struct_boolfield": {"true"},
+			},
+			expected: TestStruct{
+				UUIDField:   uuid.MustParse("ca07d617-c87c-4ac3-affc-27a5e941b28f"),
+				StringField: "test_string",
+				BoolField:   true,
+				IntField:    42,
+				FloatField:  3.14,
+				SliceField:  []string{"1", "2", "3"},
+				StructField: FieldStruct{
+					StringField: "stringfield",
+					BoolField:   true,
+				},
+			},
+			expectedErr: false,
+		},
+		{
+			name:        "Empty input",
+			input:       url.Values{},
+			expected:    TestStruct{},
+			expectedErr: false,
+		},
+		{
+			name: "Missing fields",
+			input: url.Values{
+				"string_field": {"test_string"},
+			},
+			expected: TestStruct{
+				StringField: "test_string",
+			},
+			expectedErr: false,
+		},
+	}
+
+	for _, tc := range testCases {
+		t.Run(tc.name, func(t *testing.T) {
+			var target TestStruct
+			err := Unmarshal(tc.input, &target)
+			if (err != nil) != tc.expectedErr {
+				t.Errorf("Unexpected error: %v", err)
+			}
+			if !reflect.DeepEqual(target, tc.expected) {
+				t.Errorf("Unmarshal did not produce expected result. got: %+v, expected: %+v", target, tc.expected)
+			}
+		})
+	}
+}

intern/server/templates/handler.go

@@ -854,20 +854,22 @@ func (p *GuestHandler) UpdateEvent(c *gin.Context) {
 			p.logger.ErrorContext(ctx, "could not parse other location", "error", err)
 			continue
 		}
-		lID, err := uuid.Parse(id)
+		var err error
+		// INFO: workaround(l.ID) until Unmarshal method is fully implemented
+		l.ID, err = uuid.Parse(id)
 		if err != nil {
 			span.RecordError(err)
 			span.SetStatus(codes.Error, "invalid uuid")
 			p.logger.ErrorContext(ctx, "invalid uuid", "error", err)
 			continue
 		}
 		for i := 0; i < len(e.Airports); i++ {
-			if lID == e.Airports[i].ID {
+			if l.ID == e.Airports[i].ID {
 				e.Airports[i] = &l
 			}
 		}
 		for i := 0; i < len(e.Hotels); i++ {
-			if lID == e.Hotels[i].ID {
+			if l.ID == e.Hotels[i].ID {
 				e.Hotels[i] = &l
 			}
 		}