17685697493

Committed 12 Sep 2025 08:48PM UTC coverage: 65.828% (+1.7%) from 64.102%

Build # 17685697493

Build Type

push

github

Committed by

web-flow

Commit Message

Merge pull request #1030 from bpatrik/db-projection

Implement projected (scoped/filtered) gallery. Fixes #1015

Run Details

1305 of 2243 branches covered (58.18%)

Branch coverage included in aggregate %.

706 of 873 new or added lines in 54 files covered. (80.87%)

16 existing lines in 10 files now uncovered.

4794 of 7022 relevant lines covered (68.27%)

4355.01 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

88.02

/src/backend/model/ObjectManagers.ts

/* eslint-disable @typescript-eslint/no-var-requires */
import {SQLConnection} from './database/SQLConnection';
import {Logger} from '../Logger';
import {LocationManager} from './database/LocationManager';
import {JobManager} from './jobs/JobManager';
import {ParentDirectoryDTO} from '../../common/entities/DirectoryDTO';
import {GalleryManager} from './database/GalleryManager';
import {UserManager} from './database/UserManager';
import {IndexingManager} from './database/IndexingManager';
import {SearchManager} from './database/SearchManager';
import {VersionManager} from './database/VersionManager';
import {CoverManager} from './database/CoverManager';
import {AlbumManager} from './database/AlbumManager';
import {PersonManager} from './database/PersonManager';
import {SharingManager} from './database/SharingManager';
import {IObjectManager} from './database/IObjectManager';
import {ExtensionManager} from './extension/ExtensionManager';
import {ProjectedCacheManager} from './database/ProjectedCacheManager';
import {SessionManager} from './database/SessionManager';

const LOG_TAG = '[ObjectManagers]';

export class ObjectManagers {

  private static instance: ObjectManagers = null;

  private readonly managers: IObjectManager[];
  private galleryManager: GalleryManager;
  private userManager: UserManager;
  private searchManager: SearchManager;
  private sharingManager: SharingManager;
  private indexingManager: IndexingManager;
  private personManager: PersonManager;
  private coverManager: CoverManager;
  private versionManager: VersionManager;
  private jobManager: JobManager;
  private locationManager: LocationManager;
  private albumManager: AlbumManager;
  private extensionManager: ExtensionManager;
  private projectedCacheManager: ProjectedCacheManager;
  private sessionManager: SessionManager;
  private initDone = false;

  constructor() {
    this.managers = [];
  }

  public static getInstance(): ObjectManagers {
    if (!this.instance) {
      this.instance = new ObjectManagers();
    }
    return this.instance;
  }

  public static async reset(): Promise<void> {
    Logger.silly(LOG_TAG, 'Object manager reset begin');
    if (ObjectManagers.isReady()) {
      if (
        ObjectManagers.getInstance().IndexingManager &&
        ObjectManagers.getInstance().IndexingManager.IsSavingInProgress
      ) {
        await ObjectManagers.getInstance().IndexingManager.SavingReady;
      }
      for (const manager of ObjectManagers.getInstance().managers) {
        if (manager === ObjectManagers.getInstance().versionManager) {
          continue;
        }
        if (manager.cleanUp) {
          await manager.cleanUp();
        }
      }
    }

    await SQLConnection.close();
    this.instance = null;
    Logger.debug(LOG_TAG, 'Object manager reset done');
  }

  public static isReady(): boolean {
    return this.instance && this.instance.initDone;
  }


  public async init(): Promise<void> {
    if (this.initDone) {
      return;
    }
    await SQLConnection.init();
    await this.initManagers();
    Logger.debug(LOG_TAG, 'SQL DB inited');
    this.initDone = true;
  }

  private async initManagers(): Promise<void> {
    this.AlbumManager = new AlbumManager();
    this.GalleryManager = new GalleryManager();
    this.IndexingManager = new IndexingManager();
    this.PersonManager = new PersonManager();
    this.CoverManager = new CoverManager();
    this.SearchManager = new SearchManager();
    this.SharingManager = new SharingManager();
    this.UserManager = new UserManager();
    this.VersionManager = new VersionManager();
    this.JobManager = new JobManager();
    this.LocationManager = new LocationManager();
    this.ExtensionManager = new ExtensionManager();
    this.ProjectedCacheManager = new ProjectedCacheManager();
    this.SessionManager = new SessionManager();

    for (const manager of ObjectManagers.getInstance().managers) {
      if (manager === ObjectManagers.getInstance().versionManager) {
        continue;
      }
      if (manager.init) {
        await manager.init();
      }
    }
  }

  public async onDataChange(
    changedDir: ParentDirectoryDTO = null
  ): Promise<void> {
    await this.VersionManager.onNewDataVersion();

    for (const manager of this.managers) {
      if (manager === this.versionManager) {
        continue;
      }
      if (manager.onNewDataVersion) {
        await manager.onNewDataVersion(changedDir);
      }
    }
  }


  get VersionManager(): VersionManager {
    return this.versionManager;
  }

  set VersionManager(value: VersionManager) {
    if (this.versionManager) {
      this.managers.splice(this.managers.indexOf(this.versionManager), 1);
    }
    this.versionManager = value;
    this.managers.push(this.versionManager);
  }

  get LocationManager(): LocationManager {
    return this.locationManager;
  }

  set LocationManager(value: LocationManager) {
    if (this.locationManager) {
      this.managers.splice(this.managers.indexOf(this.locationManager), 1);
    }
    this.locationManager = value;
    this.managers.push(this.locationManager);
  }

  get AlbumManager(): AlbumManager {
    return this.albumManager;
  }

  set AlbumManager(value: AlbumManager) {
    if (this.albumManager) {
      this.managers.splice(this.managers.indexOf(this.albumManager), 1);
    }
    this.albumManager = value;
    this.managers.push(this.albumManager);
  }

  get PersonManager(): PersonManager {
    return this.personManager;
  }

  set PersonManager(value: PersonManager) {
    if (this.personManager) {
      this.managers.splice(this.managers.indexOf(this.personManager), 1);
    }
    this.personManager = value;
    this.managers.push(this.personManager);
  }

  get CoverManager(): CoverManager {
    return this.coverManager;
  }

  set CoverManager(value: CoverManager) {
    if (this.coverManager) {
      this.managers.splice(this.managers.indexOf(this.coverManager as IObjectManager), 1);
    }
    this.coverManager = value;
    this.managers.push(this.coverManager as IObjectManager);
  }

  get IndexingManager(): IndexingManager {
    return this.indexingManager;
  }

  set IndexingManager(value: IndexingManager) {
    if (this.indexingManager) {
      this.managers.splice(this.managers.indexOf(this.indexingManager as IObjectManager), 1);
    }
    this.indexingManager = value;
    this.managers.push(this.indexingManager as IObjectManager);
  }

  get GalleryManager(): GalleryManager {
    return this.galleryManager;
  }

  set GalleryManager(value: GalleryManager) {
    if (this.galleryManager) {
      this.managers.splice(this.managers.indexOf(this.galleryManager as IObjectManager), 1);
    }
    this.galleryManager = value;
    this.managers.push(this.galleryManager as IObjectManager);
  }

  get UserManager(): UserManager {
    return this.userManager;
  }

  set UserManager(value: UserManager) {
    if (this.userManager) {
      this.managers.splice(this.managers.indexOf(this.userManager as IObjectManager), 1);
    }
    this.userManager = value;
    this.managers.push(this.userManager as IObjectManager);
  }

  get SearchManager(): SearchManager {
    return this.searchManager;
  }

  set SearchManager(value: SearchManager) {
    if (this.searchManager) {
      this.managers.splice(this.managers.indexOf(this.searchManager as IObjectManager), 1);
    }
    this.searchManager = value;
    this.managers.push(this.searchManager as IObjectManager);
  }

  get SharingManager(): SharingManager {
    return this.sharingManager;
  }

  set SharingManager(value: SharingManager) {
    if (this.sharingManager) {
      this.managers.splice(this.managers.indexOf(this.sharingManager as IObjectManager), 1);
    }
    this.sharingManager = value;
    this.managers.push(this.sharingManager as IObjectManager);
  }

  get JobManager(): JobManager {
    return this.jobManager;
  }

  set JobManager(value: JobManager) {
    if (this.jobManager) {
      this.managers.splice(this.managers.indexOf(this.jobManager as IObjectManager), 1);
    }
    this.jobManager = value;
    this.managers.push(this.jobManager as IObjectManager);
  }

  get ExtensionManager(): ExtensionManager {
    return this.extensionManager;
  }

  set ExtensionManager(value: ExtensionManager) {
    if (this.extensionManager) {
      this.managers.splice(this.managers.indexOf(this.extensionManager as IObjectManager), 1);
    }
    this.extensionManager = value;
    this.managers.push(this.extensionManager as IObjectManager);
  }

  get ProjectedCacheManager(): ProjectedCacheManager {
    return this.projectedCacheManager;
  }

  set ProjectedCacheManager(value: ProjectedCacheManager) {
    if (this.projectedCacheManager) {
      this.managers.splice(this.managers.indexOf(this.projectedCacheManager as IObjectManager), 1);
    }
    this.projectedCacheManager = value;
    this.managers.push(this.projectedCacheManager as IObjectManager);
  }
  get SessionManager(): SessionManager {
    return this.sessionManager;
  }

  set SessionManager(value: SessionManager) {
    if (this.sessionManager) {
      this.managers.splice(this.managers.indexOf(this.sessionManager as IObjectManager), 1);
    }
    this.sessionManager = value;
    this.managers.push(this.sessionManager as IObjectManager);
  }

}

1	/* eslint-disable @typescript-eslint/no-var-requires */
2	import {SQLConnection} from './database/SQLConnection';	1✔
3	import {Logger} from '../Logger';	1✔
4	import {LocationManager} from './database/LocationManager';	1✔
5	import {JobManager} from './jobs/JobManager';	1✔
6	import {ParentDirectoryDTO} from '../../common/entities/DirectoryDTO';
7	import {GalleryManager} from './database/GalleryManager';	1✔
8	import {UserManager} from './database/UserManager';	1✔
9	import {IndexingManager} from './database/IndexingManager';	1✔
10	import {SearchManager} from './database/SearchManager';	1✔
11	import {VersionManager} from './database/VersionManager';	1✔
12	import {CoverManager} from './database/CoverManager';	1✔
13	import {AlbumManager} from './database/AlbumManager';	1✔
14	import {PersonManager} from './database/PersonManager';	1✔
15	import {SharingManager} from './database/SharingManager';	1✔
16	import {IObjectManager} from './database/IObjectManager';
17	import {ExtensionManager} from './extension/ExtensionManager';	1✔
18	import {ProjectedCacheManager} from './database/ProjectedCacheManager';	1✔
19	import {SessionManager} from './database/SessionManager';	1✔
20
21	const LOG_TAG = '[ObjectManagers]';	1✔
22
23	export class ObjectManagers {	1✔
24
25	private static instance: ObjectManagers = null;	1✔
26
27	private readonly managers: IObjectManager[];
28	private galleryManager: GalleryManager;
29	private userManager: UserManager;
30	private searchManager: SearchManager;
31	private sharingManager: SharingManager;
32	private indexingManager: IndexingManager;
33	private personManager: PersonManager;
34	private coverManager: CoverManager;
35	private versionManager: VersionManager;
36	private jobManager: JobManager;
37	private locationManager: LocationManager;
38	private albumManager: AlbumManager;
39	private extensionManager: ExtensionManager;
40	private projectedCacheManager: ProjectedCacheManager;
41	private sessionManager: SessionManager;
42	private initDone = false;	219✔
43
44	constructor() {
45	this.managers = [];	219✔
46	}
47
48	public static getInstance(): ObjectManagers {
49	if (!this.instance) {	9,459✔
50	this.instance = new ObjectManagers();	219✔
51	}
52	return this.instance;	9,459✔
53	}
54
55	public static async reset(): Promise<void> {
56	Logger.silly(LOG_TAG, 'Object manager reset begin');	294✔
57	if (ObjectManagers.isReady()) {	294✔
58	if (	219✔
59	ObjectManagers.getInstance().IndexingManager &&	438✔
60	ObjectManagers.getInstance().IndexingManager.IsSavingInProgress
61	) {
62	await ObjectManagers.getInstance().IndexingManager.SavingReady;	3✔
63	}
64	for (const manager of ObjectManagers.getInstance().managers) {	219✔
65	if (manager === ObjectManagers.getInstance().versionManager) {	3,066✔
66	continue;	219✔
67	}
68	if (manager.cleanUp) {	2,847✔
69	await manager.cleanUp();	438✔
70	}
71	}
72	}
73
74	await SQLConnection.close();	294✔
75	this.instance = null;	294✔
76	Logger.debug(LOG_TAG, 'Object manager reset done');	294✔
77	}
78
79	public static isReady(): boolean {
80	return this.instance && this.instance.initDone;	294✔
81	}
82
83
84	public async init(): Promise<void> {
85	if (this.initDone) {	304✔
86	return;	85✔
87	}
88	await SQLConnection.init();	219✔
89	await this.initManagers();	219✔
90	Logger.debug(LOG_TAG, 'SQL DB inited');	219✔
91	this.initDone = true;	219✔
92	}
93
94	private async initManagers(): Promise<void> {
95	this.AlbumManager = new AlbumManager();	219✔
96	this.GalleryManager = new GalleryManager();	219✔
97	this.IndexingManager = new IndexingManager();	219✔
98	this.PersonManager = new PersonManager();	219✔
99	this.CoverManager = new CoverManager();	219✔
100	this.SearchManager = new SearchManager();	219✔
101	this.SharingManager = new SharingManager();	219✔
102	this.UserManager = new UserManager();	219✔
103	this.VersionManager = new VersionManager();	219✔
104	this.JobManager = new JobManager();	219✔
105	this.LocationManager = new LocationManager();	219✔
106	this.ExtensionManager = new ExtensionManager();	219✔
107	this.ProjectedCacheManager = new ProjectedCacheManager();	219✔
108	this.SessionManager = new SessionManager();	219✔
109
110	for (const manager of ObjectManagers.getInstance().managers) {	219✔
111	if (manager === ObjectManagers.getInstance().versionManager) {	3,066✔
112	continue;	219✔
113	}
114	if (manager.init) {	2,847✔
115	await manager.init();	657✔
116	}
117	}
118	}
119
120	public async onDataChange(
121	changedDir: ParentDirectoryDTO = null	×
122	): Promise<void> {
123	await this.VersionManager.onNewDataVersion();	98✔
124
125	for (const manager of this.managers) {	98✔
126	if (manager === this.versionManager) {	1,372✔
127	continue;	98✔
128	}
129	if (manager.onNewDataVersion) {	1,274✔
130	await manager.onNewDataVersion(changedDir);	294✔
131	}
132	}
133	}
134
135
136	get VersionManager(): VersionManager {
137	return this.versionManager;	104✔
138	}
139
140	set VersionManager(value: VersionManager) {
141	if (this.versionManager) {	219!
142	this.managers.splice(this.managers.indexOf(this.versionManager), 1);	×
143	}
144	this.versionManager = value;	219✔
145	this.managers.push(this.versionManager);	219✔
146	}
147
148	get LocationManager(): LocationManager {
149	return this.locationManager;	4✔
150	}
151
152	set LocationManager(value: LocationManager) {
153	if (this.locationManager) {	221✔
154	this.managers.splice(this.managers.indexOf(this.locationManager), 1);	2✔
155	}
156	this.locationManager = value;	221✔
157	this.managers.push(this.locationManager);	221✔
158	}
159
160	get AlbumManager(): AlbumManager {
161	return this.albumManager;	8✔
162	}
163
164	set AlbumManager(value: AlbumManager) {
165	if (this.albumManager) {	219!
166	this.managers.splice(this.managers.indexOf(this.albumManager), 1);	×
167	}
168	this.albumManager = value;	219✔
169	this.managers.push(this.albumManager);	219✔
170	}
171
172	get PersonManager(): PersonManager {
173	return this.personManager;	270✔
174	}
175
176	set PersonManager(value: PersonManager) {
177	if (this.personManager) {	219!
178	this.managers.splice(this.managers.indexOf(this.personManager), 1);	×
179	}
180	this.personManager = value;	219✔
181	this.managers.push(this.personManager);	219✔
182	}
183
184	get CoverManager(): CoverManager {
185	return this.coverManager;	374✔
186	}
187
188	set CoverManager(value: CoverManager) {
189	if (this.coverManager) {	219!
NEW 190	this.managers.splice(this.managers.indexOf(this.coverManager as IObjectManager), 1);	×
191	}
192	this.coverManager = value;	219✔
193	this.managers.push(this.coverManager as IObjectManager);	219✔
194	}
195
196	get IndexingManager(): IndexingManager {
197	return this.indexingManager;	645✔
198	}
199
200	set IndexingManager(value: IndexingManager) {
201	if (this.indexingManager) {	247✔
202	this.managers.splice(this.managers.indexOf(this.indexingManager as IObjectManager), 1);	28✔
203	}
204	this.indexingManager = value;	247✔
205	this.managers.push(this.indexingManager as IObjectManager);	247✔
206	}
207
208	get GalleryManager(): GalleryManager {
209	return this.galleryManager;	30✔
210	}
211
212	set GalleryManager(value: GalleryManager) {
213	if (this.galleryManager) {	231✔
214	this.managers.splice(this.managers.indexOf(this.galleryManager as IObjectManager), 1);	12✔
215	}
216	this.galleryManager = value;	231✔
217	this.managers.push(this.galleryManager as IObjectManager);	231✔
218	}
219
220	get UserManager(): UserManager {
221	return this.userManager;	29✔
222	}
223
224	set UserManager(value: UserManager) {
225	if (this.userManager) {	229✔
226	this.managers.splice(this.managers.indexOf(this.userManager as IObjectManager), 1);	10✔
227	}
228	this.userManager = value;	229✔
229	this.managers.push(this.userManager as IObjectManager);	229✔
230	}
231
232	get SearchManager(): SearchManager {
233	return this.searchManager;	287✔
234	}
235
236	set SearchManager(value: SearchManager) {
237	if (this.searchManager) {	231✔
238	this.managers.splice(this.managers.indexOf(this.searchManager as IObjectManager), 1);	12✔
239	}
240	this.searchManager = value;	231✔
241	this.managers.push(this.searchManager as IObjectManager);	231✔
242	}
243
244	get SharingManager(): SharingManager {
245	return this.sharingManager;	21✔
246	}
247
248	set SharingManager(value: SharingManager) {
249	if (this.sharingManager) {	219!
250	this.managers.splice(this.managers.indexOf(this.sharingManager as IObjectManager), 1);	×
251	}
252	this.sharingManager = value;	219✔
253	this.managers.push(this.sharingManager as IObjectManager);	219✔
254	}
255
256	get JobManager(): JobManager {
257	return this.jobManager;	4✔
258	}
259
260	set JobManager(value: JobManager) {
261	if (this.jobManager) {	219!
262	this.managers.splice(this.managers.indexOf(this.jobManager as IObjectManager), 1);	×
263	}
264	this.jobManager = value;	219✔
265	this.managers.push(this.jobManager as IObjectManager);	219✔
266	}
267
268	get ExtensionManager(): ExtensionManager {
269	return this.extensionManager;	×
270	}
271
272	set ExtensionManager(value: ExtensionManager) {
273	if (this.extensionManager) {	219!
274	this.managers.splice(this.managers.indexOf(this.extensionManager as IObjectManager), 1);	×
275	}
276	this.extensionManager = value;	219✔
277	this.managers.push(this.extensionManager as IObjectManager);	219✔
278	}
279
280	get ProjectedCacheManager(): ProjectedCacheManager {
281	return this.projectedCacheManager;	358✔
282	}
283
284	set ProjectedCacheManager(value: ProjectedCacheManager) {
285	if (this.projectedCacheManager) {	219!
NEW 286	this.managers.splice(this.managers.indexOf(this.projectedCacheManager as IObjectManager), 1);	×
287	}
288	this.projectedCacheManager = value;	219✔
289	this.managers.push(this.projectedCacheManager as IObjectManager);	219✔
290	}
291	get SessionManager(): SessionManager {
292	return this.sessionManager;	387✔
293	}
294
295	set SessionManager(value: SessionManager) {
296	if (this.sessionManager) {	219!
NEW 297	this.managers.splice(this.managers.indexOf(this.sessionManager as IObjectManager), 1);	×
298	}
299	this.sessionManager = value;	219✔
300	this.managers.push(this.sessionManager as IObjectManager);	219✔
301	}
302
303	}

bpatrik / pigallery2 / 17685697493

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous