portainer/app/docker/__module.js

angular.module('portainer.docker', ['portainer.app']).config([
  '$stateRegistryProvider',
  function ($stateRegistryProvider) {
    'use strict';

    var docker = {
      name: 'docker',
      parent: 'endpoint',
      abstract: true,
      /* ngInject */
      async onEnter(endpoint, $state, EndpointService, EndpointProvider, LegacyExtensionManager, Notifications, StateManager, SystemService) {
        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: 'portainer.templates.custom',
      url: '/custom',

      views: {
        'content@': {
          component: 'customTemplatesView',
        },
      },
    };

    const customTemplatesNew = {
      name: 'portainer.templates.custom.new',
      url: '/new?fileContent&type',

      views: {
        'content@': {
          component: 'createCustomTemplateView',
        },
      },
      params: {
        fileContent: '',
        type: '',
      },
    };

    const customTemplatesEdit = {
      name: 'portainer.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);
  },
]);