text: angular.module('portainer.docker', ['portainer.app']).config([
    '$stateRegistryProvider',
    function ($stateRegistryProvider) {
      'use strict';
  
      var docker = {
        name: 'docker',
        parent: 'endpoint',
        url: '/docker',
        abstract: true,
        onEnter: /* @ngInject */ function onEnter(endpoint, $async, $state, EndpointService, EndpointProvider, LegacyExtensionManager, Notifications, StateManager, SystemService) {
          return $async(async () => {
            if (![1, 2, 4].includes(endpoint.Type)) {
              $state.go('portainer.home');
              return;
            }
            try {
              const status = await checkEndpointStatus(endpoint);
  
              if (endpoint.Type !== 4) {
                await updateEndpointStatus(endpoint, status);
              }
              endpoint.Status = status;
  
              if (status === 2) {
                if (!endpoint.Snapshots[0]) {
                  throw new Error('Endpoint is unreachable and there is no snapshot available for offline browsing.');
                }
                if (endpoint.Snapshots[0].Swarm) {
                  throw new Error('Endpoint is unreachable. Connect to another swarm manager.');
                }
              }
  
              EndpointProvider.setEndpointID(endpoint.Id);
              EndpointProvider.setEndpointPublicURL(endpoint.PublicURL);
              EndpointProvider.setOfflineModeFromStatus(endpoint.Status);
  
              const extensions = await LegacyExtensionManager.initEndpointExtensions(endpoint);
              await StateManager.updateEndpointState(endpoint, extensions);
            } catch (e) {
              Notifications.error('Failed loading endpoint', e);
              $state.go('portainer.home', {}, { reload: true });
            }
  
            async function checkEndpointStatus(endpoint) {
              try {
                await SystemService.ping(endpoint.Id);
                return 1;
              } catch (e) {
                return 2;
              }
            }
  
            async function updateEndpointStatus(endpoint, status) {
              if (endpoint.Status === status) {
                return;
              }
              await EndpointService.updateEndpoint(endpoint.Id, { Status: status });
            }
          });
        },
      };
  
      var configs = {
        name: 'docker.configs',
        url: '/configs',
        views: {
          'content@': {
            templateUrl: './views/configs/configs.html',
            controller: 'ConfigsController',
            controllerAs: 'ctrl',
          },
        },
      };
  
      var config = {
        name: 'docker.configs.config',
        url: '/:id',
        views: {
          'content@': {
            templateUrl: './views/configs/edit/config.html',
            controller: 'ConfigController',
          },
        },
      };
  
      var configCreation = {
        name: 'docker.configs.new',
        url: '/new?id',
        views: {
          'content@': {
            templateUrl: './views/configs/create/createconfig.html',
            controller: 'CreateConfigController',
            controllerAs: 'ctrl',
          },
        },
      };
  
      var containers = {
        name: 'docker.containers',
        url: '/containers',
        views: {
          'content@': {
            templateUrl: './views/containers/containers.html',
            controller: 'ContainersController',
          },
        },
      };
  
      var container = {
        name: 'docker.containers.container',
        url: '/:id?nodeName',
        views: {
          'content@': {
            templateUrl: './views/containers/edit/container.html',
            controller: 'ContainerController',
          },
        },
      };
  
      var containerAttachConsole = {
        name: 'docker.containers.container.attach',
        url: '/attach',
        views: {
          'content@': {
            templateUrl: './views/containers/console/attach.html',
            controller: 'ContainerConsoleController',
          },
        },
      };
  
      var containerExecConsole = {
        name: 'docker.containers.container.exec',
        url: '/exec',
        views: {
          'content@': {
            templateUrl: './views/containers/console/exec.html',
            controller: 'ContainerConsoleController',
          },
        },
      };
  
      var containerCreation = {
        name: 'docker.containers.new',
        url: '/new?nodeName&from',
        views: {
          'content@': {
            templateUrl: './views/containers/create/createcontainer.html',
            controller: 'CreateContainerController',
          },
        },
      };
  
      var containerInspect = {
        name: 'docker.containers.container.inspect',
        url: '/inspect',
        views: {
          'content@': {
            templateUrl: './views/containers/inspect/containerinspect.html',
            controller: 'ContainerInspectController',
          },
        },
      };
  
      var containerLogs = {
        name: 'docker.containers.container.logs',
        url: '/logs',
        views: {
          'content@': {
            templateUrl: './views/containers/logs/containerlogs.html',
            controller: 'ContainerLogsController',
          },
        },
      };
  
      var containerStats = {
        name: 'docker.containers.container.stats',
        url: '/stats',
        views: {
          'content@': {
            templateUrl: './views/containers/stats/containerstats.html',
            controller: 'ContainerStatsController',
          },
        },
      };
  
      const customTemplates = {
        name: 'docker.templates.custom',
        url: '/custom',
  
        views: {
          'content@': {
            component: 'customTemplatesView',
          },
        },
      };
  
      const customTemplatesNew = {
        name: 'docker.templates.custom.new',
        url: '/new?fileContent&type',
  
        views: {
          'content@': {
            component: 'createCustomTemplateView',
          },
        },
        params: {
          fileContent: '',
          type: '',
        },
      };
  
      const customTemplatesEdit = {
        name: 'docker.templates.custom.edit',
        url: '/:id',
  
        views: {
          'content@': {
            component: 'editCustomTemplateView',
          },
        },
      };
  
      var dashboard = {
        name: 'docker.dashboard',
        url: '/dashboard',
        views: {
          'content@': {
            templateUrl: './views/dashboard/dashboard.html',
            controller: 'DashboardController',
          },
        },
      };
  
      var host = {
        name: 'docker.host',
        url: '/host',
        views: {
          'content@': {
            component: 'hostView',
          },
        },
      };
  
      var hostBrowser = {
        name: 'docker.host.browser',
        url: '/browser',
        views: {
          'content@': {
            component: 'hostBrowserView',
          },
        },
      };
  
      var events = {
        name: 'docker.events',
        url: '/events',
        views: {
          'content@': {
            templateUrl: './views/events/events.html',
            controller: 'EventsController',
          },
        },
      };
  
      var images = {
        name: 'docker.images',
        url: '/images',
        views: {
          'content@': {
            templateUrl: './views/images/images.html',
            controller: 'ImagesController',
          },
        },
      };
  
      var image = {
        name: 'docker.images.image',
        url: '/:id?nodeName',
        views: {
          'content@': {
            templateUrl: './views/images/edit/image.html',
            controller: 'ImageController',
          },
        },
      };
  
      var imageBuild = {
        name: 'docker.images.build',
        url: '/build',
        views: {
          'content@': {
            templateUrl: './views/images/build/buildimage.html',
            controller: 'BuildImageController',
          },
        },
      };
  
      var imageImport = {
        name: 'docker.images.import',
        url: '/import',
        views: {
          'content@': {
            templateUrl: './views/images/import/importimage.html',
            controller: 'ImportImageController',
          },
        },
      };
  
      var networks = {
        name: 'docker.networks',
        url: '/networks',
        views: {
          'content@': {
            templateUrl: './views/networks/networks.html',
            controller: 'NetworksController',
          },
        },
      };
  
      var network = {
        name: 'docker.networks.network',
        url: '/:id?nodeName',
        views: {
          'content@': {
            templateUrl: './views/networks/edit/network.html',
            controller: 'NetworkController',
          },
        },
      };
  
      var networkCreation = {
        name: 'docker.networks.new',
        url: '/new',
        views: {
          'content@': {
            templateUrl: './views/networks/create/createnetwork.html',
            controller: 'CreateNetworkController',
          },
        },
      };
  
      var nodes = {
        name: 'docker.nodes',
        url: '/nodes',
        abstract: true,
      };
  
      var node = {
        name: 'docker.nodes.node',
        url: '/:id',
        views: {
          'content@': {
            component: 'nodeDetailsView',
          },
        },
      };
  
      var nodeBrowser = {
        name: 'docker.nodes.node.browse',
        url: '/browse',
        views: {
          'content@': {
            component: 'nodeBrowserView',
          },
        },
      };
  
      var secrets = {
        name: 'docker.secrets',
        url: '/secrets',
        views: {
          'content@': {
            templateUrl: './views/secrets/secrets.html',
            controller: 'SecretsController',
          },
        },
      };
  
      var secret = {
        name: 'docker.secrets.secret',
        url: '/:id',
        views: {
          'content@': {
            templateUrl: './views/secrets/edit/secret.html',
            controller: 'SecretController',
          },
        },
      };
  
      var secretCreation = {
        name: 'docker.secrets.new',
        url: '/new',
        views: {
          'content@': {
            templateUrl: './views/secrets/create/createsecret.html',
            controller: 'CreateSecretController',
          },
        },
      };
  
      var services = {
        name: 'docker.services',
        url: '/services',
        views: {
          'content@': {
            templateUrl: './views/services/services.html',
            controller: 'ServicesController',
          },
        },
      };
  
      var service = {
        name: 'docker.services.service',
        url: '/:id',
        views: {
          'content@': {
            templateUrl: './views/services/edit/service.html',
            controller: 'ServiceController',
          },
        },
      };
  
      var serviceCreation = {
        name: 'docker.services.new',
        url: '/new',
        views: {
          'content@': {
            templateUrl: './views/services/create/createservice.html',
            controller: 'CreateServiceController',
          },
        },
      };
  
      var serviceLogs = {
        name: 'docker.services.service.logs',
        url: '/logs',
        views: {
          'content@': {
            templateUrl: './views/services/logs/servicelogs.html',
            controller: 'ServiceLogsController',
          },
        },
      };
  
      var stacks = {
        name: 'docker.stacks',
        url: '/stacks',
        views: {
          'content@': {
            templateUrl: '~Portainer/views/stacks/stacks.html',
            controller: 'StacksController',
          },
        },
      };
  
      var stack = {
        name: 'docker.stacks.stack',
        url: '/:name?id&type&external',
        views: {
          'content@': {
            templateUrl: '~Portainer/views/stacks/edit/stack.html',
            controller: 'StackController',
          },
        },
      };
  
      var stackCreation = {
        name: 'docker.stacks.newstack',
        url: '/newstack',
        views: {
          'content@': {
            templateUrl: '~Portainer/views/stacks/create/createstack.html',
            controller: 'CreateStackController',
          },
        },
      };
  
      var swarm = {
        name: 'docker.swarm',
        url: '/swarm',
        views: {
          'content@': {
            templateUrl: './views/swarm/swarm.html',
            controller: 'SwarmController',
          },
        },
      };
  
      var swarmVisualizer = {
        name: 'docker.swarm.visualizer',
        url: '/visualizer',
        views: {
          'content@': {
            templateUrl: './views/swarm/visualizer/swarmvisualizer.html',
            controller: 'SwarmVisualizerController',
          },
        },
      };
  
      var tasks = {
        name: 'docker.tasks',
        url: '/tasks',
        abstract: true,
      };
  
      var task = {
        name: 'docker.tasks.task',
        url: '/:id',
        views: {
          'content@': {
            templateUrl: './views/tasks/edit/task.html',
            controller: 'TaskController',
          },
        },
      };
  
      var taskLogs = {
        name: 'docker.tasks.task.logs',
        url: '/logs',
        views: {
          'content@': {
            templateUrl: './views/tasks/logs/tasklogs.html',
            controller: 'TaskLogsController',
          },
        },
      };
  
      var templates = {
        name: 'docker.templates',
        url: '/templates',
        views: {
          'content@': {
            templateUrl: '~Portainer/views/templates/templates.html',
            controller: 'TemplatesController',
          },
        },
      };
  
      var volumes = {
        name: 'docker.volumes',
        url: '/volumes',
        views: {
          'content@': {
            templateUrl: './views/volumes/volumes.html',
            controller: 'VolumesController',
          },
        },
      };
  
      var volume = {
        name: 'docker.volumes.volume',
        url: '/:id?nodeName',
        views: {
          'content@': {
            templateUrl: './views/volumes/edit/volume.html',
            controller: 'VolumeController',
          },
        },
      };
  
      var volumeBrowse = {
        name: 'docker.volumes.volume.browse',
        url: '/browse',
        views: {
          'content@': {
            templateUrl: './views/volumes/browse/browsevolume.html',
            controller: 'BrowseVolumeController',
          },
        },
      };
  
      var volumeCreation = {
        name: 'docker.volumes.new',
        url: '/new',
        views: {
          'content@': {
            templateUrl: './views/volumes/create/createvolume.html',
            controller: 'CreateVolumeController',
          },
        },
      };
  
      $stateRegistryProvider.register(configs);
      $stateRegistryProvider.register(config);
      $stateRegistryProvider.register(configCreation);
      $stateRegistryProvider.register(containers);
      $stateRegistryProvider.register(container);
      $stateRegistryProvider.register(containerExecConsole);
      $stateRegistryProvider.register(containerAttachConsole);
      $stateRegistryProvider.register(containerCreation);
      $stateRegistryProvider.register(containerInspect);
      $stateRegistryProvider.register(containerLogs);
      $stateRegistryProvider.register(containerStats);
      $stateRegistryProvider.register(customTemplates);
      $stateRegistryProvider.register(customTemplatesNew);
      $stateRegistryProvider.register(customTemplatesEdit);
      $stateRegistryProvider.register(docker);
      $stateRegistryProvider.register(dashboard);
      $stateRegistryProvider.register(host);
      $stateRegistryProvider.register(hostBrowser);
      $stateRegistryProvider.register(events);
      $stateRegistryProvider.register(images);
      $stateRegistryProvider.register(image);
      $stateRegistryProvider.register(imageBuild);
      $stateRegistryProvider.register(imageImport);
      $stateRegistryProvider.register(networks);
      $stateRegistryProvider.register(network);
      $stateRegistryProvider.register(networkCreation);
      $stateRegistryProvider.register(nodes);
      $stateRegistryProvider.register(node);
      $stateRegistryProvider.register(nodeBrowser);
      $stateRegistryProvider.register(secrets);
      $stateRegistryProvider.register(secret);
      $stateRegistryProvider.register(secretCreation);
      $stateRegistryProvider.register(services);
      $stateRegistryProvider.register(service);
      $stateRegistryProvider.register(serviceCreation);
      $stateRegistryProvider.register(serviceLogs);
      $stateRegistryProvider.register(stacks);
      $stateRegistryProvider.register(stack);
      $stateRegistryProvider.register(stackCreation);
      $stateRegistryProvider.register(swarm);
      $stateRegistryProvider.register(swarmVisualizer);
      $stateRegistryProvider.register(tasks);
      $stateRegistryProvider.register(task);
      $stateRegistryProvider.register(taskLogs);
      $stateRegistryProvider.register(templates);
      $stateRegistryProvider.register(volumes);
      $stateRegistryProvider.register(volume);
      $stateRegistryProvider.register(volumeBrowse);
      $stateRegistryProvider.register(volumeCreation);
    },
  ]);
  