package server import ( "crypto/sha256" "database/sql" "encoding/hex" "errors" "fmt" "net/url" "path" "strings" ) type cityAutoPlanItem struct { Path string `json:"path"` PageUUID string `json:"page_uuid"` Quartier, Street, Spot string QuartierPath, StreetPath, SpotPath string `json:",omitempty"` Undefined bool `json:"undefined_spot"` Action string `json:"action"` } func cityAutoName(raw, prefix string) string { decoded, err := url.PathUnescape(raw) if err == nil { raw = decoded } name := citySuggestionName(raw) if len(name) >= 2 { return name } sum := sha256.Sum256([]byte(raw)) return prefix + "-" + hex.EncodeToString(sum[:4]) } // Names are identifiers, not ownership. In particular Spot names are unique // across the entire Domain, even when their Streets differ. func (s *Server) availableCityAutoName(domain, kind, parent, base, boundary string) (string, error) { for attempt := 0; attempt < 32; attempt++ { name := base if attempt > 0 { sum := sha256.Sum256([]byte(fmt.Sprintf("%s:%s:%d", kind, boundary, attempt))) stem := base if len(stem) > 47 { stem = stem[:47] } name = stem + "-" + hex.EncodeToString(sum[:8]) } var exists bool var err error if kind == "spot" { err = s.store.DB.QueryRow(`SELECT EXISTS(SELECT 1 FROM spots WHERE domain_uuid=? AND name=? AND state!='archived')`, domain, name).Scan(&exists) } else if kind == "quartier" { err = s.store.DB.QueryRow(`SELECT EXISTS(SELECT 1 FROM zones WHERE domain_uuid=? AND kind='quartier' AND name=? AND state!='archived')`, domain, name).Scan(&exists) } else { err = s.store.DB.QueryRow(`SELECT EXISTS(SELECT 1 FROM zones WHERE domain_uuid=? AND parent_uuid=? AND name=? AND state!='archived')`, domain, parent, name).Scan(&exists) } if err != nil { return "", err } if !exists { return name, nil } } return "", errors.New("unable to allocate unique generated City name") } func (s *Server) buildCityAutoPlan(domainUUID string) ([]cityAutoPlanItem, error) { rows, err := s.store.DB.Query(`SELECT p.path,p.object_uuid FROM paths p WHERE p.domain_uuid=? AND p.path LIKE '/%' AND p.path!='/u' AND p.path NOT LIKE '/u/%' AND NOT EXISTS(SELECT 1 FROM city_page_overrides ov JOIN spots dest ON dest.uuid=ov.spot_uuid AND dest.domain_uuid=ov.domain_uuid AND dest.state!='archived' WHERE ov.domain_uuid=p.domain_uuid AND ov.page_uuid=p.object_uuid) ORDER BY p.path`, domainUUID) if err != nil { return nil, err } defer rows.Close() var out []cityAutoPlanItem for rows.Next() { var semanticPath, pageUUID string if err := rows.Scan(&semanticPath, &pageUUID); err != nil { return nil, err } parts := strings.Split(strings.Trim(semanticPath, "/"), "/") if len(parts) < 3 || parts[0] == "system" { continue } item := cityAutoPlanItem{Path: semanticPath, PageUUID: pageUUID, Quartier: cityAutoName(parts[0], "quartier"), Street: cityAutoName(parts[1], "street"), QuartierPath: "/" + parts[0], StreetPath: "/" + parts[0] + "/" + parts[1]} if len(parts) >= 4 { item.Spot = cityAutoName(parts[2], "spot") item.SpotPath = item.StreetPath + "/" + parts[2] } else { item.Undefined = true item.Spot = item.Street + "-undefined" item.SpotPath = item.StreetPath + "/_undefined" } item.Action = "create" if q, e := s.store.CityNodeOverlappingPath(domainUUID, "quartier", "", item.QuartierPath); e == nil { item.Quartier = q.Name item.Action = "merge" if st, e := s.store.CityNodeOverlappingPath(domainUUID, "street", q.UUID, item.StreetPath); e == nil { item.Street = st.Name if spot, e := s.store.CityNodeOverlappingPath(domainUUID, "spot", st.UUID, item.SpotPath); e == nil { item.Spot = spot.Name } } } out = append(out, item) } return out, rows.Err() } func (s *Server) applyCityAutoPlan(domainUUID, actor string) (int, error) { plan, err := s.buildCityAutoPlan(domainUUID) if err != nil { return 0, err } quartiers, streets, spots := map[string]string{}, map[string]string{}, map[string]string{} applied := 0 for _, item := range plan { qID := quartiers[item.QuartierPath] if qID == "" { if q, e := s.store.CityNodeOverlappingPath(domainUUID, "quartier", "", item.QuartierPath); e == nil { qID = q.UUID } else { if !errors.Is(e, sql.ErrNoRows) { return applied, e } name, err := s.availableCityAutoName(domainUUID, "quartier", "", item.Quartier, item.QuartierPath) if err != nil { return applied, err } qID, e = s.store.CreateZoneAtPath(domainUUID, actor, "quartier", "", name, item.Quartier, "Generated from URL Paths", item.QuartierPath) if e != nil { return applied, e } } quartiers[item.QuartierPath] = qID } streetKey := qID + item.StreetPath streetID := streets[streetKey] if streetID == "" { if st, e := s.store.CityNodeOverlappingPath(domainUUID, "street", qID, item.StreetPath); e == nil { streetID = st.UUID } else { if !errors.Is(e, sql.ErrNoRows) { return applied, e } name, err := s.availableCityAutoName(domainUUID, "street", qID, item.Street, item.StreetPath) if err != nil { return applied, err } streetID, e = s.store.CreateZoneAtPath(domainUUID, actor, "street", qID, name, item.Street, "", item.StreetPath) if e != nil { return applied, e } } streets[streetKey] = streetID } spotKey := streetID + item.SpotPath spotID := spots[spotKey] if spotID == "" { if spot, e := s.store.CityNodeOverlappingPath(domainUUID, "spot", streetID, item.SpotPath); e == nil { spotID = spot.UUID } else { if !errors.Is(e, sql.ErrNoRows) { return applied, e } name, err := s.availableCityAutoName(domainUUID, "spot", streetID, item.Spot, item.SpotPath) if err != nil { return applied, err } spotID, e = s.store.CreateSpotAtPath(domainUUID, actor, streetID, name, item.Spot, "Generated from URL Paths", item.SpotPath) if e != nil { return applied, e } } spots[spotKey] = spotID } if err := s.store.AddSpotPage(domainUUID, actor, spotID, item.PageUUID, item.Path, "primary", path.Base(item.Path)); err != nil && !errors.Is(err, sql.ErrNoRows) { return applied, err } applied++ } return applied, nil }