This section describes importing application configuration parts using the web client.

Note that the selected application elements of the current application will be replaced by those coming from the file. Therefore, it is recommended to back up the current application configuration before importing an application configuration file. That way the current configuration is easier to restore if any issues should arise from importing an external application configuration file. For more details, refer to Section Exporting an Application Configuration File

The app-config.json file can be used in a deployment to load application configuration automatically. For more details, refer to Section Deploying the Application.

After the import elements were selected, if the application has no workspaces or permission rules, the Application Initialization Bean is called. For more details, refer to Section Setting Advanced Initialization.

The current application configuration can be exported in a .json file that can be analyzed, edited, and reimported. For more details, refer to Section Importing an Application Configuration File. The file structure defines all application elements and their internal structure, such as the settings, views, dashboards, workspaces, and folders.

The Permission Rules, Rulesets, and Groups are also stored in the exported structure. For more details, refer to Section Defining Permission Rules and Rulesets.

DOC allows discarding changes made on the application to come back to the application default configuration.

Scenario data is never affected when you reset the application configuration, i.e. existing scenarios are always preserved in the application.

	Note that "Existing" scenarios refer to scenarios that have not been deleted, for instance, using the options Move to Trash and Empty Trash. For more details, refer to Section Using the Scenario List Widget.

However, in some cases, users can no longer see existing scenarios in the web client after resetting the application configuration, as described in Sections Importing an Application Configuration File or Resetting the Application Configuration to Default. This happens when workspaces are deleted by the reset and the scenarios in them become "orphans".

Orphan scenarios are moved to a workspace called Lost and found. It is automatically created, if necessary, with the scenario-service user as the owner and default permission rules.

For example, importing a configuration file can lead to this situation as follows:

The result is that:

When this happens, the user performing the reset needs to use the Permissions view to change the permissions on workspace Lost and found.

For more details, refer to Section Understanding the "Application Elements Override" Tab.

	Note that , to prevent moving all scenarios to workspace Lost & Found, users can untick the option Workspaces and Folders when Importing an Application Configuration File.

To implement a custom web application controller, you first need to create a class that implements the interface GeneApplicationController.

/**
 * Implementing a GeneApplicationController allows to override some common patterns of the default DOC Web Application
 * such as the header, menus, sidebar, toolbars and titles.
 *
 * Note that GeneApplicationController does not provide extension APIs to override widget behavior. To do so
 * you have to use GeneWidgetController API.
 */
export interface GeneApplicationController {

    /**
    * When provided, the component will replace the default Gene component for the header bar
    */
    header?: {
        component?: Type<any>;
     },

    /**
    * When provided, the component will replace the default Gene component for the sidebar
    */
    sidenav?: {
        component?: Type<any>;
    }

    /**
     * This method allows to override and add additional Menus in the top bar.
     * This method is being called by GeneFramework each time current ViewDashboard or GeneContext
     * change.
     *
     * @param view current displayed view
     * @param context current context
     */
    customizeMenus?: (context: GeneContext, view: ViewDashboard) => Observable<GeneApplicationMenu[]>;

    /**
     * This method allows to override and add additional GeneToolbarElement in the current ViewDashboard
     * toolbar.
     * This method is being called by GeneFramework each time current ViewDashboard or GeneContext
     * change.
     *
     * @param view current displayed view
     * @param context current context
     */
    customizeViewDashboardToolbar?: (context: GeneContext, view: ViewDashboard) => Observable<GeneToolbarElement[]>;

    /**
     * This method allows to override the View and Dashboard titles.
     * This method is being called by GeneFramework each time current ViewDashboard or GeneContext
     * change.
     *
     * @param view current displayed view
     * @param context current context
     */
    customizeViewDashboardTitle?: (context: GeneContext, view: ViewDashboard) => Observable<string>;

    /**
     * This method allows to override DOC default configuration.
     * This method is being called by GeneFramework each time current ViewDashboard or GeneContext
     * change.
     *
     * Note that it is safe to modify the configuration received as a parameter and return it.
     *
     * @param view current displayed view
     * @param context current context
     * @param configuration default application configuration
     * @return Observable of the partial configuration to override
     */
    customizeDefaultConfiguration?: (context: GeneContext, view: ViewDashboard) => Observable<GeneApplicationConfiguration>;

}

Here is an example of a custom controller that adds a new Menu in the Header Bar and hides the default Task Menu. Note that this controller is available as a sample:

export class SampleApplicationController implements GeneApplicationController {

    // Customize Header menu by adding a 'Factory Menu'
    // With two Menu Items
    customizeMenus(context: GeneContext, view: ViewDashboard): Observable<GeneApplicationMenu[]> {
        return of([
            {
                icon: 'factory',
                id: 'factory-menu',
                title: 'Factory Menu',
                menuGroups: [
                    {
                        title: 'Menu Group 1',
                        menuItems: [
                            {
                                label: 'Menu Element 1',
                                icon: 'employee',
                                clickHandler: () => alert('Menu Element 1 Clicked !')
                            },
                            {
                                label: 'Menu Element 2',
                                icon: 'employee',
                                clickHandler: () => alert('Menu Element 2 Clicked !')
                            }
                        ]
                    }
                ]
            }
        ]);
    }

    // Customize default Application Configuration
    // - Hide the Task menu (always)
    customizeDefaultConfiguration(context: GeneContext, view: ViewDashboard,  configuration: GeneApplicationConfiguration): Observable<Partial<GeneApplicationConfiguration>> {
        return of({
            header: {
                taskMenu: {
                    hide: true
                }
            }
        });
    }
}

In the first component that is started, which is the app.component.ts, DOC can register multiple application controllers through GeneApplicationService.

export class AppComponent {

    constructor(translate: TranslateService, settingsService: GeneSettingsService, applicationService: GeneApplicationService) {

        // ...
        // Register a custom app controller sample
        applicationService.registerApplicationController('Sample Custom Menu', () => new SampleCustomMenusApplicationController());
        // ...
    }
}