Vmeda.Online/src/core/classes/page-loads-manager.ts

// (C) Copyright 2015 Moodle Pty Ltd.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//     http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

import { CoreRefreshButtonModalComponent } from '@components/refresh-button-modal/refresh-button-modal';
import { CoreNavigator } from '@services/navigator';
import { CoreDomUtils } from '@services/utils/dom';
import { Subject } from 'rxjs';
import { AsyncComponent } from './async-component';
import { PageLoadWatcher } from './page-load-watcher';

/**
 * Class to manage requests in a page and its components.
 */
export class PageLoadsManager {

    onRefreshPage = new Subject<void>();

    protected initialPath?: string;
    protected currentLoadWatcher?: PageLoadWatcher;
    protected ongoingLoadWatchers = new Set<PageLoadWatcher>();

    /**
     * Start a page load, creating a new load watcher and watching the page.
     *
     * @param page Page instance.
     * @param staleWhileRevalidate Whether to use stale while revalidate strategy.
     * @return Load watcher to use.
     */
    startPageLoad(page: AsyncComponent, staleWhileRevalidate: boolean): PageLoadWatcher {
        this.initialPath = this.initialPath ?? CoreNavigator.getCurrentPath();
        this.currentLoadWatcher = new PageLoadWatcher(this, staleWhileRevalidate);
        this.ongoingLoadWatchers.add(this.currentLoadWatcher);

        this.currentLoadWatcher.watchComponent(page);

        return this.currentLoadWatcher;
    }

    /**
     * Start a component load, adding it to currrent load watcher (if it exists) and watching the component.
     *
     * @param component Component instance.
     * @return Load watcher to use.
     */
    startComponentLoad(component: AsyncComponent): PageLoadWatcher {
        // If a component is loading data without the page loading data, probably the component is reloading/refreshing.
        // In that case, create a load watcher instance but don't store it in currentLoadWatcher because it's not a page load.
        const loadWatcher = this.currentLoadWatcher ?? new PageLoadWatcher(this, false);

        loadWatcher.watchComponent(component);

        return loadWatcher;
    }

    /**
     * A load has finished, remove its watcher from ongoing watchers and notify if needed.
     *
     * @param loadWatcher Load watcher related to the load that finished.
     */
    onPageLoaded(loadWatcher: PageLoadWatcher): void {
        if (!this.ongoingLoadWatchers.has(loadWatcher)) {
            // Watcher not in list, it probably finished already.
            return;
        }

        this.removeLoadWatcher(loadWatcher);

        if (!loadWatcher.hasMeaningfulChanges()) {
            // No need to notify.
            return;
        }

        // Check if there is another ongoing load watcher using update in background.
        // If so, wait for the other one to finish before notifying to prevent being notified twice.
        const ongoingLoadWatcher = this.getAnotherOngoingUpdateInBackgroundWatcher(loadWatcher);
        if (ongoingLoadWatcher) {
            ongoingLoadWatcher.markMeaningfulChanges();

            return;
        }

        if (this.initialPath === CoreNavigator.getCurrentPath()) {
            // User hasn't changed page, notify them.
            this.notifyUser();
        } else {
            // User left the page, just update the data.
            this.onRefreshPage.next();
        }
    }

    /**
     * Get an ongoing load watcher that supports updating in background and is not the one passed as a parameter.
     *
     * @param loadWatcher Load watcher to ignore.
     * @return Ongoing load watcher, undefined if none found.
     */
    protected getAnotherOngoingUpdateInBackgroundWatcher(loadWatcher: PageLoadWatcher): PageLoadWatcher | undefined {
        for (const ongoingLoadWatcher of this.ongoingLoadWatchers) {
            if (ongoingLoadWatcher.canUpdateInBackground() && loadWatcher !== ongoingLoadWatcher) {
                return ongoingLoadWatcher;
            }
        }
    }

    /**
     * Remove a load watcher from the list.
     *
     * @param loadWatcher Load watcher to remove.
     */
    protected removeLoadWatcher(loadWatcher: PageLoadWatcher): void {
        this.ongoingLoadWatchers.delete(loadWatcher);
        if (loadWatcher === this.currentLoadWatcher) {
            delete this.currentLoadWatcher;
        }
    }

    /**
     * Notify the user, asking him if he wants to update the data.
     */
    protected async notifyUser(): Promise<void> {
        await CoreDomUtils.openModal<boolean>({
            component: CoreRefreshButtonModalComponent,
            cssClass: 'core-modal-no-background core-modal-fullscreen',
            closeOnNavigate: true,
        });

        this.onRefreshPage.next();
    }

}