feat(web, mobile): Options to show archived assets in map (#4293)

* Add include archive setting to map on web * open api * better naming for web isArchived variable * add withArchived setting to mobile * (e2e): tests for mapMarker endpoint and isArchived * isArchived to mobile * chore: cleanup test * chore: optimize e2e --------- Co-authored-by: shalong-tanwen <139912620+shalong-tanwen@users.noreply.github.com> Co-authored-by: Jason Rasmussen <jrasm91@gmail.com>
2024-11-15 09:59:00 -07:00 · 2023-10-04 15:51:07 +02:00 · 2023-10-04 15:51:07 +02:00 · e571880c16
commit e571880c16
parent e5b4d09827
22 changed files with 184 additions and 34 deletions
--- a/cli/src/api/open-api/api.ts
+++ b/cli/src/api/open-api/api.ts
@ -6278,13 +6278,14 @@ export const AssetApiAxiosParamCreator = function (configuration?: Configuration
        },
        /**
         * 
+         * @param {boolean} [isArchived] 
         * @param {boolean} [isFavorite] 
         * @param {string} [fileCreatedAfter] 
         * @param {string} [fileCreatedBefore] 
         * @param {*} [options] Override http request option.
         * @throws {RequiredError}
         */
-        getMapMarkers: async (isFavorite?: boolean, fileCreatedAfter?: string, fileCreatedBefore?: string, options: AxiosRequestConfig = {}): Promise<RequestArgs> => {
+        getMapMarkers: async (isArchived?: boolean, isFavorite?: boolean, fileCreatedAfter?: string, fileCreatedBefore?: string, options: AxiosRequestConfig = {}): Promise<RequestArgs> => {
            const localVarPath = `/asset/map-marker`;
            // use dummy base URL string because the URL constructor only accepts absolute URLs.
            const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
@ -6306,6 +6307,10 @@ export const AssetApiAxiosParamCreator = function (configuration?: Configuration
            // http bearer authentication required
            await setBearerAuthToObject(localVarHeaderParameter, configuration)

+            if (isArchived !== undefined) {
+                localVarQueryParameter['isArchived'] = isArchived;
+            }
+
            if (isFavorite !== undefined) {
                localVarQueryParameter['isFavorite'] = isFavorite;
            }
@ -7134,14 +7139,15 @@ export const AssetApiFp = function(configuration?: Configuration) {
        },
        /**
         * 
+         * @param {boolean} [isArchived] 
         * @param {boolean} [isFavorite] 
         * @param {string} [fileCreatedAfter] 
         * @param {string} [fileCreatedBefore] 
         * @param {*} [options] Override http request option.
         * @throws {RequiredError}
         */
-        async getMapMarkers(isFavorite?: boolean, fileCreatedAfter?: string, fileCreatedBefore?: string, options?: AxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<Array<MapMarkerResponseDto>>> {
-            const localVarAxiosArgs = await localVarAxiosParamCreator.getMapMarkers(isFavorite, fileCreatedAfter, fileCreatedBefore, options);
+        async getMapMarkers(isArchived?: boolean, isFavorite?: boolean, fileCreatedAfter?: string, fileCreatedBefore?: string, options?: AxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<Array<MapMarkerResponseDto>>> {
+            const localVarAxiosArgs = await localVarAxiosParamCreator.getMapMarkers(isArchived, isFavorite, fileCreatedAfter, fileCreatedBefore, options);
            return createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration);
        },
        /**
@ -7428,7 +7434,7 @@ export const AssetApiFactory = function (configuration?: Configuration, basePath
         * @throws {RequiredError}
         */
        getMapMarkers(requestParameters: AssetApiGetMapMarkersRequest = {}, options?: AxiosRequestConfig): AxiosPromise<Array<MapMarkerResponseDto>> {
-            return localVarFp.getMapMarkers(requestParameters.isFavorite, requestParameters.fileCreatedAfter, requestParameters.fileCreatedBefore, options).then((request) => request(axios, basePath));
+            return localVarFp.getMapMarkers(requestParameters.isArchived, requestParameters.isFavorite, requestParameters.fileCreatedAfter, requestParameters.fileCreatedBefore, options).then((request) => request(axios, basePath));
        },
        /**
         * 
@ -7846,6 +7852,13 @@ export interface AssetApiGetDownloadInfoRequest {
 * @interface AssetApiGetMapMarkersRequest
 */
 export interface AssetApiGetMapMarkersRequest {
+    /**
+     * 
+     * @type {boolean}
+     * @memberof AssetApiGetMapMarkers
+     */
+    readonly isArchived?: boolean
+
    /**
     * 
     * @type {boolean}
@ -8374,7 +8387,7 @@ export class AssetApi extends BaseAPI {
     * @memberof AssetApi
     */
    public getMapMarkers(requestParameters: AssetApiGetMapMarkersRequest = {}, options?: AxiosRequestConfig) {
-        return AssetApiFp(this.configuration).getMapMarkers(requestParameters.isFavorite, requestParameters.fileCreatedAfter, requestParameters.fileCreatedBefore, options).then((request) => request(this.axios, this.basePath));
+        return AssetApiFp(this.configuration).getMapMarkers(requestParameters.isArchived, requestParameters.isFavorite, requestParameters.fileCreatedAfter, requestParameters.fileCreatedBefore, options).then((request) => request(this.axios, this.basePath));
    }

    /**
--- a/mobile/assets/i18n/en-US.json
+++ b/mobile/assets/i18n/en-US.json
@ -312,6 +312,7 @@
  "map_settings_dialog_title": "Map Settings",
  "map_settings_dark_mode": "Dark mode",
  "map_settings_only_show_favorites": "Show Favorite Only",
+  "map_settings_include_show_archived": "Include Archived",
  "map_settings_only_relative_range": "Date range",
  "map_settings_dialog_cancel": "Cancel",
  "map_settings_dialog_save": "Save",
--- a/mobile/lib/modules/map/models/map_state.model.dart
+++ b/mobile/lib/modules/map/models/map_state.model.dart
@ -1,29 +1,33 @@
 class MapState {
  final bool isDarkTheme;
  final bool showFavoriteOnly;
+  final bool includeArchived;
  final int relativeTime;

  MapState({
    this.isDarkTheme = false,
    this.showFavoriteOnly = false,
+    this.includeArchived = false,
    this.relativeTime = 0,
  });

  MapState copyWith({
    bool? isDarkTheme,
    bool? showFavoriteOnly,
+    bool? includeArchived,
    int? relativeTime,
  }) {
    return MapState(
      isDarkTheme: isDarkTheme ?? this.isDarkTheme,
      showFavoriteOnly: showFavoriteOnly ?? this.showFavoriteOnly,
+      includeArchived: includeArchived ?? this.includeArchived,
      relativeTime: relativeTime ?? this.relativeTime,
    );
  }

  @override
  String toString() {
-    return 'MapSettingsState(isDarkTheme: $isDarkTheme, showFavoriteOnly: $showFavoriteOnly, relativeTime: $relativeTime)';
+    return 'MapSettingsState(isDarkTheme: $isDarkTheme, showFavoriteOnly: $showFavoriteOnly, relativeTime: $relativeTime, includeArchived: $includeArchived)';
  }

  @override
@ -33,13 +37,15 @@ class MapState {
    return other is MapState &&
        other.isDarkTheme == isDarkTheme &&
        other.showFavoriteOnly == showFavoriteOnly &&
-        other.relativeTime == relativeTime;
+        other.relativeTime == relativeTime &&
+        other.includeArchived == includeArchived;
  }

  @override
  int get hashCode {
    return isDarkTheme.hashCode ^
        showFavoriteOnly.hashCode ^
-        relativeTime.hashCode;
+        relativeTime.hashCode ^
+        includeArchived.hashCode;
  }
 }
--- a/mobile/lib/modules/map/providers/map_marker.provider.dart
+++ b/mobile/lib/modules/map/providers/map_marker.provider.dart
@ -10,6 +10,7 @@ final mapMarkersProvider =
  final mapState = ref.read(mapStateNotifier);
  DateTime? fileCreatedAfter;
  bool? isFavorite;
+  bool? isIncludeArchived;

  if (mapState.relativeTime != 0) {
    fileCreatedAfter =
@ -20,8 +21,13 @@ final mapMarkersProvider =
    isFavorite = true;
  }

+  if (!mapState.includeArchived) {
+    isIncludeArchived = false;
+  }
+
  final markers = await service.getMapMarkers(
    isFavorite: isFavorite,
+    withArchived: isIncludeArchived,
    fileCreatedAfter: fileCreatedAfter,
  );

--- a/mobile/lib/modules/map/providers/map_state.provider.dart
+++ b/mobile/lib/modules/map/providers/map_state.provider.dart
@ -11,6 +11,8 @@ class MapStateNotifier extends StateNotifier<MapState> {
                .getSetting<bool>(AppSettingsEnum.mapThemeMode),
            showFavoriteOnly: appSettingsProvider
                .getSetting<bool>(AppSettingsEnum.mapShowFavoriteOnly),
+            includeArchived: appSettingsProvider
+                .getSetting<bool>(AppSettingsEnum.mapIncludeArchived),
            relativeTime: appSettingsProvider
                .getSetting<int>(AppSettingsEnum.mapRelativeDate),
          ),
@ -31,11 +33,19 @@ class MapStateNotifier extends StateNotifier<MapState> {
  void switchFavoriteOnly(bool isFavoriteOnly) {
    appSettingsProvider.setSetting(
      AppSettingsEnum.mapShowFavoriteOnly,
-      appSettingsProvider,
+      isFavoriteOnly,
    );
    state = state.copyWith(showFavoriteOnly: isFavoriteOnly);
  }

+  void switchIncludeArchived(bool isIncludeArchived) {
+    appSettingsProvider.setSetting(
+      AppSettingsEnum.mapIncludeArchived,
+      isIncludeArchived,
+    );
+    state = state.copyWith(includeArchived: isIncludeArchived);
+  }
+
  void setRelativeTime(int relativeTime) {
    appSettingsProvider.setSetting(
      AppSettingsEnum.mapRelativeDate,
--- a/mobile/lib/modules/map/services/map.service.dart
+++ b/mobile/lib/modules/map/services/map.service.dart
@ -23,12 +23,14 @@ class MapSerivce {

  Future<List<MapMarkerResponseDto>> getMapMarkers({
    bool? isFavorite,
+    bool? withArchived,
    DateTime? fileCreatedAfter,
    DateTime? fileCreatedBefore,
  }) async {
    try {
      final markers = await _apiService.assetApi.getMapMarkers(
        isFavorite: isFavorite,
+        isArchived: withArchived,
        fileCreatedAfter: fileCreatedAfter,
        fileCreatedBefore: fileCreatedBefore,
      );
--- a/mobile/lib/modules/map/ui/map_settings_dialog.dart
+++ b/mobile/lib/modules/map/ui/map_settings_dialog.dart
@ -13,6 +13,7 @@ class MapSettingsDialog extends HookConsumerWidget {
    final mapSettings = ref.read(mapStateNotifier);
    final isDarkMode = useState(mapSettings.isDarkTheme);
    final showFavoriteOnly = useState(mapSettings.showFavoriteOnly);
+    final showIncludeArchived = useState(mapSettings.includeArchived);
    final showRelativeDate = useState(mapSettings.relativeTime);
    final ThemeData theme = Theme.of(context);

@ -48,6 +49,22 @@ class MapSettingsDialog extends HookConsumerWidget {
      );
    }

+    Widget buildIncludeArchivedSetting() {
+      return SwitchListTile.adaptive(
+        value: showIncludeArchived.value,
+        onChanged: (value) {
+          showIncludeArchived.value = value;
+        },
+        activeColor: theme.primaryColor,
+        dense: true,
+        title: Text(
+          "map_settings_include_show_archived".tr(),
+          style:
+              theme.textTheme.labelLarge?.copyWith(fontWeight: FontWeight.bold),
+        ),
+      );
+    }
+
    Widget buildDateRangeSetting() {
      final now = DateTime.now();
      return DropdownMenu(
@ -127,6 +144,8 @@ class MapSettingsDialog extends HookConsumerWidget {
            mapSettingsNotifier.switchTheme(isDarkMode.value);
            mapSettingsNotifier.switchFavoriteOnly(showFavoriteOnly.value);
            mapSettingsNotifier.setRelativeTime(showRelativeDate.value);
+            mapSettingsNotifier
+                .switchIncludeArchived(showIncludeArchived.value);
            Navigator.of(context).pop();
          },
          style: TextButton.styleFrom(
@ -166,6 +185,7 @@ class MapSettingsDialog extends HookConsumerWidget {
            children: [
              buildMapThemeSetting(),
              buildFavoriteOnlySetting(),
+              buildIncludeArchivedSetting(),
              const SizedBox(
                height: 10,
              ),
--- a/mobile/lib/modules/map/views/map_page.dart
+++ b/mobile/lib/modules/map/views/map_page.dart
@ -155,7 +155,8 @@ class MapPageState extends ConsumerState<MapPage> {
    ref.listen(mapStateNotifier, (previous, next) {
      bool shouldRefetch =
          previous?.showFavoriteOnly != next.showFavoriteOnly ||
-              previous?.relativeTime != next.relativeTime;
+              previous?.relativeTime != next.relativeTime ||
+              previous?.includeArchived != next.includeArchived;
      if (shouldRefetch) {
        refetchMarkers.value = shouldRefetch;
        ref.invalidate(mapMarkersProvider);
--- a/mobile/lib/modules/settings/services/app_settings.service.dart
+++ b/mobile/lib/modules/settings/services/app_settings.service.dart
@ -48,6 +48,7 @@ enum AppSettingsEnum<T> {
  preferRemoteImage<bool>(StoreKey.preferRemoteImage, null, false),
  mapThemeMode<bool>(StoreKey.mapThemeMode, null, false),
  mapShowFavoriteOnly<bool>(StoreKey.mapShowFavoriteOnly, null, false),
+  mapIncludeArchived<bool>(StoreKey.mapIncludeArchived, null, false),
  mapRelativeDate<int>(StoreKey.mapRelativeDate, null, 0),
  allowSelfSignedSSLCert<bool>(StoreKey.selfSignedCert, null, false),
  ;
--- a/mobile/lib/shared/models/store.dart
+++ b/mobile/lib/shared/models/store.dart
@ -179,6 +179,7 @@ enum StoreKey<T> {
  mapShowFavoriteOnly<bool>(118, type: bool),
  mapRelativeDate<int>(119, type: int),
  selfSignedCert<bool>(120, type: bool),
+  mapIncludeArchived<bool>(121, type: bool),
  ;

  const StoreKey(
--- a/mobile/openapi/doc/AssetApi.md
+++ b/mobile/openapi/doc/AssetApi.md
@ -902,7 +902,7 @@ Name | Type | Description  | Notes
 [[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md)

 # **getMapMarkers**
-> List<MapMarkerResponseDto> getMapMarkers(isFavorite, fileCreatedAfter, fileCreatedBefore)
+> List<MapMarkerResponseDto> getMapMarkers(isArchived, isFavorite, fileCreatedAfter, fileCreatedBefore)



@ -925,12 +925,13 @@ import 'package:openapi/api.dart';
 //defaultApiClient.getAuthentication<HttpBearerAuth>('bearer').setAccessToken(yourTokenGeneratorFunction);

 final api_instance = AssetApi();
+final isArchived = true; // bool | 
 final isFavorite = true; // bool | 
 final fileCreatedAfter = 2013-10-20T19:20:30+01:00; // DateTime | 
 final fileCreatedBefore = 2013-10-20T19:20:30+01:00; // DateTime | 

 try {
-    final result = api_instance.getMapMarkers(isFavorite, fileCreatedAfter, fileCreatedBefore);
+    final result = api_instance.getMapMarkers(isArchived, isFavorite, fileCreatedAfter, fileCreatedBefore);
    print(result);
 } catch (e) {
    print('Exception when calling AssetApi->getMapMarkers: $e\n');
@ -941,6 +942,7 @@ try {

 Name | Type | Description  | Notes
 ------------- | ------------- | ------------- | -------------
+ **isArchived** | **bool**|  | [optional] 
 **isFavorite** | **bool**|  | [optional] 
 **fileCreatedAfter** | **DateTime**|  | [optional] 
 **fileCreatedBefore** | **DateTime**|  | [optional] 
--- a/mobile/openapi/lib/api/asset_api.dart
+++ b/mobile/openapi/lib/api/asset_api.dart
@ -909,12 +909,14 @@ class AssetApi {
  /// Performs an HTTP 'GET /asset/map-marker' operation and returns the [Response].
  /// Parameters:
  ///
+  /// * [bool] isArchived:
+  ///
  /// * [bool] isFavorite:
  ///
  /// * [DateTime] fileCreatedAfter:
  ///
  /// * [DateTime] fileCreatedBefore:
-  Future<Response> getMapMarkersWithHttpInfo({ bool? isFavorite, DateTime? fileCreatedAfter, DateTime? fileCreatedBefore, }) async {
+  Future<Response> getMapMarkersWithHttpInfo({ bool? isArchived, bool? isFavorite, DateTime? fileCreatedAfter, DateTime? fileCreatedBefore, }) async {
    // ignore: prefer_const_declarations
    final path = r'/asset/map-marker';

@ -925,6 +927,9 @@ class AssetApi {
    final headerParams = <String, String>{};
    final formParams = <String, String>{};

+    if (isArchived != null) {
+      queryParams.addAll(_queryParams('', 'isArchived', isArchived));
+    }
    if (isFavorite != null) {
      queryParams.addAll(_queryParams('', 'isFavorite', isFavorite));
    }
@ -951,13 +956,15 @@ class AssetApi {

  /// Parameters:
  ///
+  /// * [bool] isArchived:
+  ///
  /// * [bool] isFavorite:
  ///
  /// * [DateTime] fileCreatedAfter:
  ///
  /// * [DateTime] fileCreatedBefore:
-  Future<List<MapMarkerResponseDto>?> getMapMarkers({ bool? isFavorite, DateTime? fileCreatedAfter, DateTime? fileCreatedBefore, }) async {
-    final response = await getMapMarkersWithHttpInfo( isFavorite: isFavorite, fileCreatedAfter: fileCreatedAfter, fileCreatedBefore: fileCreatedBefore, );
+  Future<List<MapMarkerResponseDto>?> getMapMarkers({ bool? isArchived, bool? isFavorite, DateTime? fileCreatedAfter, DateTime? fileCreatedBefore, }) async {
+    final response = await getMapMarkersWithHttpInfo( isArchived: isArchived, isFavorite: isFavorite, fileCreatedAfter: fileCreatedAfter, fileCreatedBefore: fileCreatedBefore, );
    if (response.statusCode >= HttpStatus.badRequest) {
      throw ApiException(response.statusCode, await _decodeBodyBytes(response));
    }
--- a/mobile/openapi/test/asset_api_test.dart
+++ b/mobile/openapi/test/asset_api_test.dart
@ -102,7 +102,7 @@ void main() {
      // TODO
    });

-    //Future<List<MapMarkerResponseDto>> getMapMarkers({ bool isFavorite, DateTime fileCreatedAfter, DateTime fileCreatedBefore }) async
+    //Future<List<MapMarkerResponseDto>> getMapMarkers({ bool isArchived, bool isFavorite, DateTime fileCreatedAfter, DateTime fileCreatedBefore }) async
    test('test getMapMarkers', () async {
      // TODO
    });
--- a/server/immich-openapi-specs.json
+++ b/server/immich-openapi-specs.json
@ -1406,6 +1406,14 @@
      "get": {
        "operationId": "getMapMarkers",
        "parameters": [
+          {
+            "name": "isArchived",
+            "required": false,
+            "in": "query",
+            "schema": {
+              "type": "boolean"
+            }
+          },
          {
            "name": "isFavorite",
            "required": false,
--- a/server/src/domain/asset/asset.repository.ts
+++ b/server/src/domain/asset/asset.repository.ts
@ -22,6 +22,7 @@ export interface LivePhotoSearchOptions {
 }

 export interface MapMarkerSearchOptions {
+  isArchived?: boolean;
  isFavorite?: boolean;
  fileCreatedBefore?: Date;
  fileCreatedAfter?: Date;
--- a/server/src/domain/asset/dto/map-marker.dto.ts
+++ b/server/src/domain/asset/dto/map-marker.dto.ts
@ -4,6 +4,12 @@ import { IsBoolean, IsDate } from 'class-validator';
 import { Optional, toBoolean } from '../../domain.util';

 export class MapMarkerDto {
+  @ApiProperty()
+  @Optional()
+  @IsBoolean()
+  @Transform(toBoolean)
+  isArchived?: boolean;
+
  @ApiProperty()
  @Optional()
  @IsBoolean()
--- a/server/src/infra/repositories/asset.repository.ts
+++ b/server/src/infra/repositories/asset.repository.ts
@ -355,7 +355,7 @@ export class AssetRepository implements IAssetRepository {
  }

  async getMapMarkers(ownerId: string, options: MapMarkerSearchOptions = {}): Promise<MapMarker[]> {
-    const { isFavorite, fileCreatedAfter, fileCreatedBefore } = options;
+    const { isArchived, isFavorite, fileCreatedAfter, fileCreatedBefore } = options;

    const assets = await this.repository.find({
      select: {
@ -368,7 +368,7 @@ export class AssetRepository implements IAssetRepository {
      where: {
        ownerId,
        isVisible: true,
-        isArchived: false,
+        isArchived,
        exifInfo: {
          latitude: Not(IsNull()),
          longitude: Not(IsNull()),
--- a/server/test/e2e/asset.e2e-spec.ts
+++ b/server/test/e2e/asset.e2e-spec.ts
@ -56,6 +56,7 @@ const createAsset = (
    deviceAssetId: `test_${id}`,
    deviceId: 'e2e-test',
    libraryId,
+    isVisible: true,
    fileCreatedAt: createdAt,
    fileModifiedAt: new Date(),
    type: AssetType.IMAGE,
@ -89,19 +90,25 @@ describe(`${AssetController.name} (e2e)`, () => {
    await api.authApi.adminSignUp(server);
    const admin = await api.authApi.adminLogin(server);

-    const libraries = await api.libraryApi.getAll(server, admin.accessToken);
+    const [libraries] = await Promise.all([
+      api.libraryApi.getAll(server, admin.accessToken),
+      api.userApi.create(server, admin.accessToken, user1Dto),
+      api.userApi.create(server, admin.accessToken, user2Dto),
+    ]);
+
    const defaultLibrary = libraries[0];

-    await api.userApi.create(server, admin.accessToken, user1Dto);
-    user1 = await api.authApi.login(server, { email: user1Dto.email, password: user1Dto.password });
+    [user1, user2] = await Promise.all([
+      api.authApi.login(server, { email: user1Dto.email, password: user1Dto.password }),
+      api.authApi.login(server, { email: user2Dto.email, password: user2Dto.password }),
+    ]);

-    asset1 = await createAsset(assetRepository, user1, defaultLibrary.id, new Date('1970-01-01'));
-    asset2 = await createAsset(assetRepository, user1, defaultLibrary.id, new Date('1970-01-02'));
-    asset3 = await createAsset(assetRepository, user1, defaultLibrary.id, new Date('1970-02-01'));
-
-    await api.userApi.create(server, admin.accessToken, user2Dto);
-    user2 = await api.authApi.login(server, { email: user2Dto.email, password: user2Dto.password });
-    asset4 = await createAsset(assetRepository, user2, defaultLibrary.id, new Date('1970-01-01'));
+    [asset1, asset2, asset3, asset4] = await Promise.all([
+      createAsset(assetRepository, user1, defaultLibrary.id, new Date('1970-01-01')),
+      createAsset(assetRepository, user1, defaultLibrary.id, new Date('1970-01-02')),
+      createAsset(assetRepository, user1, defaultLibrary.id, new Date('1970-02-01')),
+      createAsset(assetRepository, user2, defaultLibrary.id, new Date('1970-01-01')),
+    ]);
  });

  afterAll(async () => {
@ -515,4 +522,45 @@ describe(`${AssetController.name} (e2e)`, () => {
      );
    });
  });
+
+  describe('GET /asset/map-marker', () => {
+    beforeEach(async () => {
+      await assetRepository.save({ id: asset1.id, isArchived: true });
+      await assetRepository.upsertExif({ assetId: asset1.id, latitude: 0, longitude: 0 });
+      await assetRepository.upsertExif({ assetId: asset2.id, latitude: 0, longitude: 0 });
+    });
+
+    it('should require authentication', async () => {
+      const { status, body } = await request(server).get('/asset/map-marker');
+
+      expect(status).toBe(401);
+      expect(body).toEqual(errorStub.unauthorized);
+    });
+
+    it('should get map markers for all non-archived assets', async () => {
+      const { status, body } = await request(server)
+        .get('/asset/map-marker')
+        .set('Authorization', `Bearer ${user1.accessToken}`);
+
+      expect(status).toBe(200);
+      expect(body).toHaveLength(2);
+      expect(body).toEqual(
+        expect.arrayContaining([
+          expect.objectContaining({ id: asset1.id }),
+          expect.objectContaining({ id: asset2.id }),
+        ]),
+      );
+    });
+
+    it('should get all map markers', async () => {
+      const { status, body } = await request(server)
+        .get('/asset/map-marker')
+        .set('Authorization', `Bearer ${user1.accessToken}`)
+        .query({ isArchived: false });
+
+      expect(status).toBe(200);
+      expect(body).toHaveLength(1);
+      expect(body).toEqual([expect.objectContaining({ id: asset2.id })]);
+    });
+  });
 });
--- a/web/src/api/open-api/api.ts
+++ b/web/src/api/open-api/api.ts
@ -6278,13 +6278,14 @@ export const AssetApiAxiosParamCreator = function (configuration?: Configuration
        },
        /**
         * 
+         * @param {boolean} [isArchived] 
         * @param {boolean} [isFavorite] 
         * @param {string} [fileCreatedAfter] 
         * @param {string} [fileCreatedBefore] 
         * @param {*} [options] Override http request option.
         * @throws {RequiredError}
         */
-        getMapMarkers: async (isFavorite?: boolean, fileCreatedAfter?: string, fileCreatedBefore?: string, options: AxiosRequestConfig = {}): Promise<RequestArgs> => {
+        getMapMarkers: async (isArchived?: boolean, isFavorite?: boolean, fileCreatedAfter?: string, fileCreatedBefore?: string, options: AxiosRequestConfig = {}): Promise<RequestArgs> => {
            const localVarPath = `/asset/map-marker`;
            // use dummy base URL string because the URL constructor only accepts absolute URLs.
            const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
@ -6306,6 +6307,10 @@ export const AssetApiAxiosParamCreator = function (configuration?: Configuration
            // http bearer authentication required
            await setBearerAuthToObject(localVarHeaderParameter, configuration)

+            if (isArchived !== undefined) {
+                localVarQueryParameter['isArchived'] = isArchived;
+            }
+
            if (isFavorite !== undefined) {
                localVarQueryParameter['isFavorite'] = isFavorite;
            }
@ -7134,14 +7139,15 @@ export const AssetApiFp = function(configuration?: Configuration) {
        },
        /**
         * 
+         * @param {boolean} [isArchived] 
         * @param {boolean} [isFavorite] 
         * @param {string} [fileCreatedAfter] 
         * @param {string} [fileCreatedBefore] 
         * @param {*} [options] Override http request option.
         * @throws {RequiredError}
         */
-        async getMapMarkers(isFavorite?: boolean, fileCreatedAfter?: string, fileCreatedBefore?: string, options?: AxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<Array<MapMarkerResponseDto>>> {
-            const localVarAxiosArgs = await localVarAxiosParamCreator.getMapMarkers(isFavorite, fileCreatedAfter, fileCreatedBefore, options);
+        async getMapMarkers(isArchived?: boolean, isFavorite?: boolean, fileCreatedAfter?: string, fileCreatedBefore?: string, options?: AxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<Array<MapMarkerResponseDto>>> {
+            const localVarAxiosArgs = await localVarAxiosParamCreator.getMapMarkers(isArchived, isFavorite, fileCreatedAfter, fileCreatedBefore, options);
            return createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration);
        },
        /**
@ -7428,7 +7434,7 @@ export const AssetApiFactory = function (configuration?: Configuration, basePath
         * @throws {RequiredError}
         */
        getMapMarkers(requestParameters: AssetApiGetMapMarkersRequest = {}, options?: AxiosRequestConfig): AxiosPromise<Array<MapMarkerResponseDto>> {
-            return localVarFp.getMapMarkers(requestParameters.isFavorite, requestParameters.fileCreatedAfter, requestParameters.fileCreatedBefore, options).then((request) => request(axios, basePath));
+            return localVarFp.getMapMarkers(requestParameters.isArchived, requestParameters.isFavorite, requestParameters.fileCreatedAfter, requestParameters.fileCreatedBefore, options).then((request) => request(axios, basePath));
        },
        /**
         * 
@ -7846,6 +7852,13 @@ export interface AssetApiGetDownloadInfoRequest {
 * @interface AssetApiGetMapMarkersRequest
 */
 export interface AssetApiGetMapMarkersRequest {
+    /**
+     * 
+     * @type {boolean}
+     * @memberof AssetApiGetMapMarkers
+     */
+    readonly isArchived?: boolean
+
    /**
     * 
     * @type {boolean}
@ -8374,7 +8387,7 @@ export class AssetApi extends BaseAPI {
     * @memberof AssetApi
     */
    public getMapMarkers(requestParameters: AssetApiGetMapMarkersRequest = {}, options?: AxiosRequestConfig) {
-        return AssetApiFp(this.configuration).getMapMarkers(requestParameters.isFavorite, requestParameters.fileCreatedAfter, requestParameters.fileCreatedBefore, options).then((request) => request(this.axios, this.basePath));
+        return AssetApiFp(this.configuration).getMapMarkers(requestParameters.isArchived, requestParameters.isFavorite, requestParameters.fileCreatedAfter, requestParameters.fileCreatedBefore, options).then((request) => request(this.axios, this.basePath));
    }

    /**
--- a/web/src/lib/components/map-page/map-settings-modal.svelte
+++ b/web/src/lib/components/map-page/map-settings-modal.svelte
@ -32,6 +32,7 @@
    >
      <SettingSwitch title="Allow dark mode" bind:checked={settings.allowDarkMode} />
      <SettingSwitch title="Only favorites" bind:checked={settings.onlyFavorites} />
+      <SettingSwitch title="Include archived" bind:checked={settings.includeArchived} />
      {#if customDateRange}
        <div in:fly={{ y: 10, duration: 200 }} class="flex flex-col gap-4">
          <div class="flex items-center justify-between gap-8">
--- a/web/src/lib/stores/preferences.store.ts
+++ b/web/src/lib/stores/preferences.store.ts
@ -21,6 +21,7 @@ export const locale = persisted<string | undefined>('locale', undefined, {

 export interface MapSettings {
  allowDarkMode: boolean;
+  includeArchived: boolean;
  onlyFavorites: boolean;
  relativeDate: string;
  dateAfter: string;
@ -29,6 +30,7 @@ export interface MapSettings {

 export const mapSettings = persisted<MapSettings>('map-settings', {
  allowDarkMode: true,
+  includeArchived: false,
  onlyFavorites: false,
  relativeDate: '',
  dateAfter: '',
--- a/web/src/routes/(user)/map/+page.svelte
+++ b/web/src/routes/(user)/map/+page.svelte
@ -44,11 +44,12 @@
    }
    abortController = new AbortController();

-    const { onlyFavorites } = $mapSettings;
+    const { includeArchived, onlyFavorites } = $mapSettings;
    const { fileCreatedAfter, fileCreatedBefore } = getFileCreatedDates();

    const { data } = await api.assetApi.getMapMarkers(
      {
+        isArchived: includeArchived && undefined,
        isFavorite: onlyFavorites || undefined,
        fileCreatedAfter: fileCreatedAfter || undefined,
        fileCreatedBefore,