Search favorites or tracks by name

map/src/infoblock/components/InformationBlock.jsx

@@ -375,7 +375,10 @@ export default function InformationBlock({
     function closeMapObjectMenu() {
         ctx.setCloseMapObj(true);
         if (!isEmpty(ctx.gpxFiles) && ctx.gpxFiles[ctx.selectedGpxFile.name]) {
-            ctx.mutateGpxFiles((o) => (o[ctx.selectedGpxFile.name].mapObj = null));
+            ctx.mutateGpxFiles((o) => {
+                o[ctx.selectedGpxFile.name].mapObj = null;
+                o[ctx.selectedGpxFile.name].openedFromSearch = null;
+            });
         }
     }
 
@@ -446,7 +449,7 @@ export default function InformationBlock({
                                 track={ctx.selectedGpxFile}
                                 onClose={handleCloseTrackContextMenu}
                                 tabsObj={tabsObj}
-                                showBackButton={!ctx.selectedGpxFile?.mapObj}
+                                showBackButton={!ctx.selectedGpxFile?.mapObj || ctx.selectedGpxFile?.openedFromSearch}
                             />
                         )}
                     </>

map/src/manager/track/DeleteTrackManager.js

@@ -87,6 +87,17 @@ async function deleteCloudFile(name, type, ctx) {
                 return { ...o };
             });
 
+            // delete track from search results cache
+            ctx.setSearchResult((prevResult) => {
+                if (!prevResult?.features) {
+                    return prevResult;
+                }
+                return {
+                    ...prevResult,
+                    features: prevResult.features.filter((feature) => feature?.properties?.web_name !== name),
+                };
+            });
+
             await loadSmartFolders(ctx.setTracksGroups, ctx.setSmartFoldersCache);
         }
     }
@@ -101,6 +112,8 @@ export async function deleteTrackFolder(folder, ctx) {
         dataOnErrors: true,
     });
     if (res && res?.data?.status === 'ok') {
+        // Clear search results cache when folder is deleted
+        ctx.setSearchResult(null);
         refreshGlobalFiles({ ctx }).then();
     } else {
         ctx.setTrackErrorMsg({

map/src/manager/track/TracksManager.js

@@ -11,6 +11,7 @@ import {
     OBJECT_TYPE_CLOUD_TRACK,
     OBJECT_TYPE_LOCAL_TRACK,
     OBJECT_TYPE_SHARE_FILE,
+    OBJECT_SEARCH,
 } from '../../context/AppContext';
 import { confirm } from '../../dialogs/GlobalConfirmationDialog';
 import { saveTrackToLocal } from './SaveTrackManager';
@@ -1545,6 +1546,7 @@ export async function openTrackOnMap({
             track.name = file.name;
             track.key = track.name;
             track.mapObj = file.mapObj;
+            track.openedFromSearch = file.openedFromSearch;
             Object.keys(track).forEach((t) => {
                 oneGpxFile[t] = track[t];
             });
@@ -1630,7 +1632,7 @@ function showInfoBlock({ hasUrl, file, ctx, smartf, recentSaver }) {
         allFiles = ctx.gpxFiles;
 
         // not set for track analyzer, because we need to keep the current object type
-        if (ctx.currentObjectType !== OBJECT_TRACK_ANALYZER) {
+        if (ctx.currentObjectType !== OBJECT_TRACK_ANALYZER && (ctx.currentObjectType !== OBJECT_SEARCH || file?.mapObj)) {
             ctx.setCurrentObjectType(OBJECT_TYPE_CLOUD_TRACK);
         }
     }

map/src/map/layers/SearchLayer.js

@@ -44,6 +44,7 @@ export const SEARCH_ICON_MAP_LOCATION = 'location';
 export const SEARCH_ICON_MAP_BUILDING = 'house';
 export const SEARCH_ICON_MAP_STREET = 'street';
 export const SEARCH_ICON_MAP_INTERSECTION = 'intersection';
+export const SEARCH_ICON_MAP_GPX_TRACK = 'gpx_track';
 
 export const ZOOM_TO_MAP = 17;
 
@@ -57,13 +58,15 @@ export const searchTypeMap = {
     CITY: 'CITY',
     TOWN: 'TOWN',
     VILLAGE: 'VILLAGE',
+    GPX_TRACK: 'GPX_TRACK',
 };
 
 export const typeIconMap = {
     [searchTypeMap.LOCATION]: SEARCH_ICON_MAP_LOCATION,
     [searchTypeMap.HOUSE]: SEARCH_ICON_MAP_BUILDING,
     [searchTypeMap.STREET]: SEARCH_ICON_MAP_STREET,
     [searchTypeMap.INTERSECTION]: SEARCH_ICON_MAP_INTERSECTION,
+    [searchTypeMap.GPX_TRACK]: SEARCH_ICON_MAP_GPX_TRACK,
 };
 
 export function getObjIdSearch(obj) {

map/src/map/util/MapManager.js

@@ -48,6 +48,7 @@ export const iconPathMap = {
     street: '/map/images/map_icons/ic_action_street_name.svg',
     intersection: '/map/images/map_icons/ic_action_intersection.svg',
     ic_action_transport_bus: '/map/images/map_icons/ic_action_transport_bus.svg',
+    gpx_track: '/map/images/map_icons/ic_action_polygom_dark.svg',
 };
 
 export async function getIconFromMap(name) {

map/src/menu/search/search/SearchResultItem.jsx

@@ -33,6 +33,8 @@ import useSearchNav from '../../../util/hooks/search/useSearchNav';
 import { POI_OBJECTS_KEY, useRecentDataSaver } from '../../../util/hooks/menu/useRecentDataSaver';
 import i18n from 'i18next';
 import { useNavigate } from 'react-router-dom';
+import { getDist, getTime, openTrackOnMap, updateTracks } from '../../../manager/track/TracksManager';
+import { convertMeters, getLargeLengthUnit, LARGE_UNIT } from '../../settings/units/UnitsConverter';
 
 export function getFirstSubstring(inputString) {
     if (inputString?.includes(SEPARATOR)) {
@@ -73,6 +75,8 @@ export function getPropsFromSearchResultItem(props, t = null, lang = null) {
             type = poiType;
         }
         type = preparedType(type, t);
+    } else if (props[CATEGORY_TYPE] === searchTypeMap.GPX_TRACK) {
+        name = props[CATEGORY_NAME];
     } else {
         name = props[CATEGORY_NAME];
         if (props[CATEGORY_TYPE] === searchTypeMap.POI_TYPE) {
@@ -161,6 +165,14 @@ export default function SearchResultItem({ item, typeItem, index }) {
         const bearing = item.bearing;
         const isUserLocation = item.isUserLocation;
         const icon = item.icon;
+        if (item.properties[CATEGORY_TYPE] === searchTypeMap.GPX_TRACK) {
+            const fileName = item.properties?.[CATEGORY_NAME];
+            const trackFile = ctx.listFiles?.uniqueFiles.find((f) => f.name === fileName);
+            const dist = `${convertMeters(getDist(trackFile), ctx.unitsSettings.len, LARGE_UNIT)?.toFixed(2)} ${t(getLargeLengthUnit(ctx))}`;
+            const time = getTime(trackFile);
+            const info = `${dist}${time ? ` · ${time}` : ''}`;
+            return { ...res, icon, distance, bearing, isUserLocation, info };
+        }
         return { ...res, icon, distance, bearing, isUserLocation };
     }
 
@@ -176,6 +188,23 @@ export default function SearchResultItem({ item, typeItem, index }) {
     })();
 
     async function clickHandler() {
+        if (item.properties?.[CATEGORY_TYPE] === searchTypeMap.GPX_TRACK) {
+            const fileName = item.properties?.[CATEGORY_NAME];
+            const file = ctx.listFiles?.uniqueFiles?.find((f) => f?.name === fileName);
+            if (!file) return;
+            file.mapObj = true; 
+            file.openedFromSearch = true;
+            const newTracks = await openTrackOnMap({
+                file,
+                showOnMap: true,
+                showInfo: true,
+                zoomToTrack: true,
+                ctx,
+                recentSaver,
+            });
+            updateTracks(ctx, null, newTracks);
+            return;
+        }
         if (item.geometry.coordinates[0] !== 0 && item.geometry.coordinates[1] !== 0) {
             const type = item.properties[WEB_PREFIX + TYPE];
             let options;

tests/selenium/src/tests/search/36-search-track.mjs

@@ -0,0 +1,58 @@
+import { By } from 'selenium-webdriver';
+import { assert, clickBy, sendKeysBy, waitBy, waitByRemoved } from '../../lib.mjs';
+
+import actionOpenMap from '../../actions/map/actionOpenMap.mjs';
+import actionLogIn from '../../actions/login/actionLogIn.mjs';
+import actionUploadGpx from '../../actions/actionUploadGpx.mjs';
+import actionLocalToCloud from '../../actions/tracks/actionLocalToCloud.mjs';
+import actionDeleteTracksByPattern from '../../actions/tracks/actionDeleteTracksByPattern.mjs';
+import actionFinish from '../../actions/actionFinish.mjs';
+import { deleteTrack } from '../../util.mjs';
+
+
+export default async function test() {
+    await actionOpenMap();
+    await actionLogIn();
+
+    const trackName = 'test-track-wpt';
+
+    await actionDeleteTracksByPattern(trackName);
+
+    await actionUploadGpx({ mask: `${trackName}.gpx` });
+    await clickBy(By.id('se-show-menu-planroute'));
+    await actionLocalToCloud({ mask: trackName });
+
+    await searchForTrack(trackName);
+
+    await waitBy(By.id('se-search-results'));
+    const trackResultId = `se-${trackName}.gpx`;
+    await clickBy(By.id(trackResultId));
+    await waitBy(By.id('se-track-context-menu'));
+    await waitBy(By.id(`se-track-${trackName}`));
+
+    await clickBy(By.id('se-button-back'));
+
+    await waitBy(By.id('se-search-results'));
+    await waitBy(By.id(trackResultId));
+
+    await clickBy(By.id('se-show-menu-tracks'));
+    await waitBy(By.id(`se-cloud-track-${trackName}`));
+    await deleteTrack(trackName);
+
+    await searchForTrack(trackName);
+
+    await waitBy(By.id('se-empty-search'));
+    const deletedTrackResult = await waitBy(By.id(trackResultId), { optional: true, idle: true });
+    await assert(!deletedTrackResult, `Deleted track "${trackName}" should be absent in search results`);
+
+    await actionFinish();
+}
+
+async function searchForTrack(trackName) {
+    await clickBy(By.id('se-show-main-menu'), { optional: true });
+    await clickBy(By.id('se-show-menu-search'));
+    await waitBy(By.id('se-search-input'));
+    await clickBy(By.id('se-search-input-cancel'), { optional: true });
+    await sendKeysBy(By.id('se-search-input'), `${trackName}\n`);
+    await waitByRemoved(By.id('se-loading-page'), { optional: true });
+}