diff --git a/db/query/geometries.sql b/db/query/geometries.sql index 798e930..04c4a4c 100644 --- a/db/query/geometries.sql +++ b/db/query/geometries.sql @@ -80,6 +80,37 @@ WHERE g.is_deleted = false ) ORDER BY g.id DESC; +-- name: SearchGeometriesByEntityName :many +WITH matched_entities AS ( + SELECT + e.id, + e.name, + e.description + FROM entities e + WHERE e.is_deleted = false + AND (sqlc.narg('name')::text IS NULL OR e.name ILIKE '%' || sqlc.narg('name')::text || '%') + AND (sqlc.narg('cursor_id')::uuid IS NULL OR e.id < sqlc.narg('cursor_id')::uuid) + ORDER BY e.id DESC + LIMIT sqlc.arg('limit_count') +) +SELECT + me.id AS entity_id, + me.name AS entity_name, + me.description AS entity_description, + g.id AS geometry_id, + g.geo_type, + g.draw_geometry, + g.binding, + g.time_start, + g.time_end +FROM matched_entities me +LEFT JOIN entity_geometries eg + ON eg.entity_id = me.id +LEFT JOIN geometries g + ON g.id = eg.geometry_id + AND g.is_deleted = false +ORDER BY me.id DESC, g.id DESC; + -- name: BulkDeleteEntityGeometriesByEntityId :many DELETE FROM entity_geometries WHERE entity_id = $1 diff --git a/internal/controllers/geometryController.go b/internal/controllers/geometryController.go index 4647a8d..7093df1 100644 --- a/internal/controllers/geometryController.go +++ b/internal/controllers/geometryController.go @@ -81,3 +81,40 @@ func (h *GeometryController) SearchGeometries(c fiber.Ctx) error { Data: res, }) } + +// SearchGeometriesByEntityName handles searching entities by name and returning geometries linked to those entities. +// Cursor pagination is based on entity ID (uuid). +// @Summary Search geometries by entity name +// @Description Search entities by name (cursor pagination) and return their linked geometries +// @Tags Geometries +// @Accept json +// @Produce json +// @Param query query request.SearchGeometriesByEntityNameDto false "Search Query" +// @Success 200 {object} response.CommonResponse +// @Failure 500 {object} response.CommonResponse +// @Router /geometries/entity [get] +func (h *GeometryController) SearchGeometriesByEntityName(c fiber.Ctx) error { + ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second) + defer cancel() + + dto := &request.SearchGeometriesByEntityNameDto{} + if err := validator.ValidateQueryDto(c, dto); err != nil { + return c.Status(fiber.StatusBadRequest).JSON(response.CommonResponse{ + Status: false, + Errors: err, + }) + } + + res, err := h.service.SearchGeometriesByEntityName(ctx, dto) + if err != nil { + return c.Status(err.Code).JSON(response.CommonResponse{ + Status: false, + Message: err.Message, + }) + } + + return c.Status(fiber.StatusOK).JSON(response.CommonResponse{ + Status: true, + Data: res, + }) +} diff --git a/internal/dtos/request/geometry.go b/internal/dtos/request/geometry.go index d14845e..c96dee6 100644 --- a/internal/dtos/request/geometry.go +++ b/internal/dtos/request/geometry.go @@ -9,3 +9,11 @@ type SearchGeometryDto struct { EntityID *string `json:"entity_id" query:"entity_id" validate:"omitempty,uuid"` ProjectID *string `json:"project_id" query:"project_id" validate:"omitempty,uuid"` } + +type SearchGeometriesByEntityNameDto struct { + // Entity name keyword for searching. FE will render the result list by entity name. + Name string `json:"name" query:"name" validate:"required,max=255"` + // Cursor is entity UUID (id < cursor). + Cursor string `json:"cursor" query:"cursor" validate:"omitempty,uuid"` + Limit int `json:"limit" query:"limit" validate:"omitempty,min=1,max=100"` +} diff --git a/internal/dtos/response/geometryEntitySearch.go b/internal/dtos/response/geometryEntitySearch.go new file mode 100644 index 0000000..7763482 --- /dev/null +++ b/internal/dtos/response/geometryEntitySearch.go @@ -0,0 +1,26 @@ +package response + +import "encoding/json" + +// SearchGeometriesByEntityNameResponse groups geometries by matched entities. +// Cursor pagination is based on entity_id (descending). +type SearchGeometriesByEntityNameResponse struct { + Items []*EntityGeometriesSearchItem `json:"items"` + NextCursor string `json:"next_cursor,omitempty"` +} + +type EntityGeometriesSearchItem struct { + EntityID string `json:"entity_id"` + Name string `json:"name"` + Description string `json:"description"` + Geometries []*EntityGeometrySearchGeo `json:"geometries"` +} + +type EntityGeometrySearchGeo struct { + ID string `json:"id"` + GeoType int16 `json:"geo_type"` + DrawGeometry json.RawMessage `json:"draw_geometry"` + Binding json.RawMessage `json:"binding,omitempty"` + TimeStart *int32 `json:"time_start,omitempty"` + TimeEnd *int32 `json:"time_end,omitempty"` +} diff --git a/internal/repositories/geometryRepository.go b/internal/repositories/geometryRepository.go index 2ca279c..08d0ff5 100644 --- a/internal/repositories/geometryRepository.go +++ b/internal/repositories/geometryRepository.go @@ -21,6 +21,7 @@ type GeometryRepository interface { GetByID(ctx context.Context, id pgtype.UUID) (*models.GeometryEntity, error) GetByIDs(ctx context.Context, ids []string) ([]*models.GeometryEntity, error) Search(ctx context.Context, params sqlc.SearchGeometriesParams) ([]*models.GeometryEntity, error) + SearchByEntityName(ctx context.Context, name string, cursorID *pgtype.UUID, limit int32) ([]EntityGeometriesSearchRow, error) Create(ctx context.Context, params sqlc.CreateGeometryParams) (*models.GeometryEntity, error) Update(ctx context.Context, params sqlc.UpdateGeometryParams) (*models.GeometryEntity, error) Delete(ctx context.Context, id pgtype.UUID) error @@ -37,12 +38,14 @@ type GeometryRepository interface { type geometryRepository struct { q *sqlc.Queries c cache.Cache + db sqlc.DBTX } func NewGeometryRepository(db sqlc.DBTX, c cache.Cache) GeometryRepository { return &geometryRepository{ q: sqlc.New(db), c: c, + db: db, } } @@ -50,9 +53,24 @@ func (r *geometryRepository) WithTx(tx pgx.Tx) GeometryRepository { return &geometryRepository{ q: r.q.WithTx(tx), c: r.c, + db: tx, } } +// EntityGeometriesSearchRow is a "flattened" row shape for searching geometries by entity name. +// FE will display entity list by entity_name, while still having geometries in the same response. +type EntityGeometriesSearchRow struct { + EntityID string `json:"entity_id"` + EntityName string `json:"name"` + EntityDescription string `json:"description"` + GeometryID string `json:"id"` + GeoType int16 `json:"geo_type"` + DrawGeometry json.RawMessage `json:"draw_geometry"` + Binding json.RawMessage `json:"binding,omitempty"` + TimeStart *int32 `json:"time_start,omitempty"` + TimeEnd *int32 `json:"time_end,omitempty"` +} + func (r *geometryRepository) generateQueryKey(prefix string, params any) string { b, _ := json.Marshal(params) hash := fmt.Sprintf("%x", md5.Sum(b)) @@ -377,3 +395,122 @@ func (r *geometryRepository) DeleteEntityGeometry(ctx context.Context, entityID GeometryID: geometryID, }) } + +func (r *geometryRepository) SearchByEntityName( + ctx context.Context, + name string, + cursorID *pgtype.UUID, + limit int32, +) ([]EntityGeometriesSearchRow, error) { + // Cursor is entity_id (not geometry_id) so FE can render entities as the primary list. + const q = ` +WITH matched_entities AS ( + SELECT + e.id, + e.name, + e.description + FROM entities e + WHERE e.is_deleted = false + AND ($1::text = '' OR e.name ILIKE '%' || $1::text || '%') + AND ($2::uuid IS NULL OR e.id < $2::uuid) + ORDER BY e.id DESC + LIMIT $3 +) +SELECT + me.id AS entity_id, + me.name AS entity_name, + COALESCE(me.description, '') AS entity_description, + g.id AS geometry_id, + g.geo_type, + g.draw_geometry, + g.binding, + g.time_start, + g.time_end +FROM matched_entities me +LEFT JOIN entity_geometries eg + ON eg.entity_id = me.id +LEFT JOIN geometries g + ON g.id = eg.geometry_id + AND g.is_deleted = false +ORDER BY me.id DESC, g.id DESC +` + + var cursor pgtype.UUID + if cursorID != nil { + cursor = *cursorID + } else { + cursor = pgtype.UUID{Valid: false} + } + + rows, err := r.db.Query(ctx, q, name, cursor, limit) + if err != nil { + return nil, err + } + defer rows.Close() + + out := make([]EntityGeometriesSearchRow, 0) + for rows.Next() { + var entityID pgtype.UUID + var entityName pgtype.Text + var entityDesc pgtype.Text + var geoID pgtype.UUID + var geoType pgtype.Int2 + var draw json.RawMessage + var binding json.RawMessage + var timeStart pgtype.Int4 + var timeEnd pgtype.Int4 + + if err := rows.Scan( + &entityID, + &entityName, + &entityDesc, + &geoID, + &geoType, + &draw, + &binding, + &timeStart, + &timeEnd, + ); err != nil { + return nil, err + } + + var ts *int32 + if timeStart.Valid { + v := timeStart.Int32 + ts = &v + } + var te *int32 + if timeEnd.Valid { + v := timeEnd.Int32 + te = &v + } + + row := EntityGeometriesSearchRow{ + EntityID: convert.UUIDToString(entityID), + EntityName: entityName.String, + EntityDescription: entityDesc.String, + GeometryID: convert.UUIDToString(geoID), + GeoType: geoType.Int16, + DrawGeometry: draw, + Binding: binding, + TimeStart: ts, + TimeEnd: te, + } + + // Entity with no geometry will have NULL geometry_id. + if !geoID.Valid { + row.GeometryID = "" + row.GeoType = 0 + row.DrawGeometry = nil + row.Binding = nil + row.TimeStart = nil + row.TimeEnd = nil + } + + out = append(out, row) + } + if err := rows.Err(); err != nil { + return nil, err + } + return out, nil +} diff --git a/internal/routes/geometryRoute.go b/internal/routes/geometryRoute.go index 9bbc74f..3741cad 100644 --- a/internal/routes/geometryRoute.go +++ b/internal/routes/geometryRoute.go @@ -9,5 +9,6 @@ import ( func GeometryRoutes(router fiber.Router, geometryController *controllers.GeometryController) { geometry := router.Group("/geometries") geometry.Get("/", geometryController.SearchGeometries) + geometry.Get("/entity", geometryController.SearchGeometriesByEntityName) geometry.Get("/:id", geometryController.GetGeometryById) } diff --git a/internal/services/geometryService.go b/internal/services/geometryService.go index d627cfc..ed8ca34 100644 --- a/internal/services/geometryService.go +++ b/internal/services/geometryService.go @@ -16,6 +16,7 @@ import ( type GeometryService interface { GetGeometryByID(ctx context.Context, id string) (*response.GeometryResponse, *fiber.Error) SearchGeometries(ctx context.Context, req *request.SearchGeometryDto) ([]*response.GeometryResponse, *fiber.Error) + SearchGeometriesByEntityName(ctx context.Context, req *request.SearchGeometriesByEntityNameDto) (*response.SearchGeometriesByEntityNameResponse, *fiber.Error) } type geometryService struct { @@ -75,3 +76,74 @@ func (s *geometryService) SearchGeometries(ctx context.Context, req *request.Sea return models.GeometriesEntityToResponse(geometries), nil } + +func (s *geometryService) SearchGeometriesByEntityName( + ctx context.Context, + req *request.SearchGeometriesByEntityNameDto, +) (*response.SearchGeometriesByEntityNameResponse, *fiber.Error) { + limit := int32(req.Limit) + if limit <= 0 { + limit = 20 + } + + var cursorID *pgtype.UUID + if req.Cursor != "" { + id, err := convert.StringToUUID(req.Cursor) + if err != nil { + return nil, fiber.NewError(fiber.StatusBadRequest, "Invalid cursor format") + } + cursorID = &id + } + + rows, err := s.geometryRepo.SearchByEntityName(ctx, req.Name, cursorID, limit) + if err != nil { + return nil, fiber.NewError(fiber.StatusInternalServerError, "Failed to search geometries by entity name") + } + + byEntity := make(map[string]*response.EntityGeometriesSearchItem) + order := make([]string, 0) + + for _, row := range rows { + item := byEntity[row.EntityID] + if item == nil { + item = &response.EntityGeometriesSearchItem{ + EntityID: row.EntityID, + Name: row.EntityName, + Description: row.EntityDescription, + Geometries: make([]*response.EntityGeometrySearchGeo, 0), + } + byEntity[row.EntityID] = item + order = append(order, row.EntityID) + } + + // LEFT JOIN: entity might have no geometry. + if row.GeometryID == "" || len(row.DrawGeometry) == 0 { + continue + } + + item.Geometries = append(item.Geometries, &response.EntityGeometrySearchGeo{ + ID: row.GeometryID, + GeoType: row.GeoType, + DrawGeometry: row.DrawGeometry, + Binding: row.Binding, + TimeStart: row.TimeStart, + TimeEnd: row.TimeEnd, + }) + } + + items := make([]*response.EntityGeometriesSearchItem, 0, len(order)) + for _, entityID := range order { + items = append(items, byEntity[entityID]) + } + + nextCursor := "" + if len(order) > 0 { + // Use last entity id in the current page as the cursor for the next page (id < cursor). + nextCursor = order[len(order)-1] + } + + return &response.SearchGeometriesByEntityNameResponse{ + Items: items, + NextCursor: nextCursor, + }, nil +}