TypeScript application.state.provider.ApplicationStateProvider类代码示例

]).config((applicationStateProvider: ApplicationStateProvider) => {

  const taskDetails: INestedState = {
    name: 'taskDetails',
    url: '/:taskId',
    views: {},
    data: {
      pageTitleDetails: {
        title: 'Task Details',
        nameParam: 'taskId'
      }
    }
  };

  const tasks: INestedState = {
    name: 'tasks',
    url: '/tasks',
    views: {
      'insight': {
        templateUrl: require('../task/tasks.html'),
        controller: 'TasksCtrl',
        controllerAs: 'tasks'
      },
    },
    data: {
      pageTitleSection: {
        title: 'Tasks'
      }
    },
    children: [taskDetails],
  };

  applicationStateProvider.addChildState(tasks);
});

]).config((applicationStateProvider: ApplicationStateProvider) => {

  const detailTabsPanel: INestedState = {
    name: 'detailTab',
    url: '/:tab',
    views: {
      'detailTab': {
        templateUrl: require('./detail/detailTab/detailTabView.html'),
        controller: 'CiDetailTabCtrl',
        controllerAs: 'ctrl',
      }
    }
  };

  const detailPanel: INestedState = {
    name: 'detail',
    url: '/detail/:buildId',
    views: {
      'detail': {
        templateUrl: require('./detail/detailView.html'),
        controller: 'CiDetailCtrl',
        controllerAs: 'ctrl'
      }
    },
    children: [
      detailTabsPanel
    ]
  };

  const appCI: INestedState = {
    name: 'ci',
    url: '/ci',
    views: {
      'insight': {
        templateUrl: require('./ci.html'),
        controller: 'NetflixCiCtrl',
        controllerAs: 'ctrl'
      }
    },
    data: {
      pageTitleSection: {
        title: 'CI'
      }
    },
    children: [
      detailPanel
    ]
  };

  applicationStateProvider.addChildState(appCI);
});

]).config((applicationStateProvider: ApplicationStateProvider, stateConfigProvider: StateConfigProvider) => {

  const appState: INestedState = {
    name: 'analytics',
    url: '/analytics',
    reloadOnSearch: false,
    views: {
      'insight': {
        templateUrl: require('./application/appTableau.html'),
        controller: 'AppTableauCtrl as ctrl',
      }
    },
    data: {
      pageTitleSection: {
        title: 'Analytics'
      }
    },
  };

  const summaryState: INestedState = {
    name: 'analytics',
    url: '/analytics',
    reloadOnSearch: false,
    views: {
      'main@': {
        templateUrl: require('./summary/summaryTableau.html'),
        controller: 'SummaryTableauCtrl as ctrl',
      }
    },
    data: {
      pageTitleSection: {
        title: 'Analytics'
      }
    },
  };

  applicationStateProvider.addChildState(appState);
  stateConfigProvider.addToRootState(summaryState);
});

module(TASK_STATES, [APPLICATION_STATE_PROVIDER]).config((applicationStateProvider: ApplicationStateProvider) => {
  const taskDetails: INestedState = {
    name: 'taskDetails',
    url: '/:taskId',
    views: {},
    data: {
      pageTitleDetails: {
        title: 'Task Details',
        nameParam: 'taskId',
      },
    },
  };

  const tasks: INestedState = {
    name: 'tasks',
    url: '/tasks?q',
    views: {
      insight: {
        templateUrl: require('../task/tasks.html'),
        controller: 'TasksCtrl',
        controllerAs: 'tasks',
      },
    },
    params: {
      q: { dynamic: true, value: null },
    },
    data: {
      pageTitleSection: {
        title: 'Tasks',
      },
    },
    children: [taskDetails],
  };

  applicationStateProvider.addChildState(tasks);
});

]).config((applicationStateProvider: ApplicationStateProvider, stateConfigProvider: StateConfigProvider) => {

  const securityGroupDetails: INestedState = {
    name: 'securityGroupDetails',
    url: '/securityGroupDetails/:provider/:accountId/:region/:vpcId/:name',
    params: {
      vpcId: {
        value: null,
        squash: true,
      },
    },
    views: {
      'detail@../insight': {
        templateProvider: ['$templateCache', '$stateParams', 'cloudProviderRegistry',
          ($templateCache: ng.ITemplateCacheService,
           $stateParams: StateParams,
           cloudProviderRegistry: CloudProviderRegistry) => {
            return $templateCache.get(cloudProviderRegistry.getValue($stateParams.provider, 'securityGroup.detailsTemplateUrl'));
        }],
        controllerProvider: ['$stateParams', 'cloudProviderRegistry',
          ($stateParams: StateParams,
           cloudProviderRegistry: CloudProviderRegistry) => {
            return cloudProviderRegistry.getValue($stateParams.provider, 'securityGroup.detailsController');
        }],
        controllerAs: 'ctrl'
      }
    },
    resolve: {
      resolvedSecurityGroup: ['$stateParams', ($stateParams: StateParams) => {
        return {
          name: $stateParams.name,
          accountId: $stateParams.accountId,
          provider: $stateParams.provider,
          region: $stateParams.region,
          vpcId: $stateParams.vpcId,
        };
      }]
    },
    data: {
      pageTitleDetails: {
        title: 'Security Group Details',
        nameParam: 'name',
        accountParam: 'accountId',
        regionParam: 'region'
      },
      history: {
        type: 'securityGroups',
      },
    }
  };

  const securityGroupSummary: INestedState = {
    url: `/securityGroups?${stateConfigProvider.paramsToQuery(filterModelConfig)}`,
    name: 'securityGroups',
    views: {
      'nav': {
        template: '<security-group-filter app="$resolve.app"></security-group-filter>',
      },
      'master': {
        templateUrl: require('../securityGroup/all.html'),
        controller: 'AllSecurityGroupsCtrl',
        controllerAs: 'ctrl'
      }
    },
    params: stateConfigProvider.buildDynamicParams(filterModelConfig),
    data: {
      pageTitleSection: {
        title: 'Security Groups'
      }
    }
  };

  const standaloneSecurityGroup: INestedState = {
    name: 'securityGroupDetails',
    url: '/securityGroupDetails/:provider/:accountId/:region/:vpcId/:name',
    params: {
      vpcId: {
        value: null,
        squash: true,
      },
    },
    views: {
      'main@': {
        templateUrl: require('../presentation/standalone.view.html'),
        controllerProvider: ['$stateParams', 'cloudProviderRegistry',
          ($stateParams: StateParams,
           cloudProviderRegistry: CloudProviderRegistry) => {
            return cloudProviderRegistry.getValue($stateParams.provider, 'securityGroup.detailsController');
        }],
        controllerAs: 'ctrl'
      }
    },
    resolve: {
      resolvedSecurityGroup: ['$stateParams', ($stateParams: StateParams) => {
        return {
          name: $stateParams.name,
          accountId: $stateParams.accountId,
          provider: $stateParams.provider,
          region: $stateParams.region,
          vpcId: $stateParams.vpcId,
//.........这里部分代码省略.........

]).config((applicationStateProvider: ApplicationStateProvider, stateConfigProvider: StateConfigProvider) => {

  const globalFastPropertyRolloutExecutionDetails: INestedState = {
    name: 'execution',
    url: '/:executionId?refId&stage&step&details',
    params: {
      stage: {
        value: '0',
      },
      step: {
        value: '0',
      }
    },
    data: {
      pageTitleDetails: {
        title: 'Execution Details',
        nameParam: 'executionId'
      }
    }
  };

  const globalFastPropertyRollouts: INestedState = {
    name: 'executions',
    url: '/rollouts',
    views: {
      'master': {
        templateUrl: require('./dataNav/fastPropertyRollouts.html'),
        controller: 'FastPropertyRolloutController',
        controllerAs: 'rollout'
      }
    },
    data: {
      pageTitleSection: {
        title: 'Fast Property Rollout'
      }
    },
    children: [globalFastPropertyRolloutExecutionDetails]

  };

  const applicationFastPropertyDetails: INestedState = {
    name: 'propertyDetails',
    url: '/:propertyId',
    reloadOnSearch: true,
    views: {
      'detail@../propInsights': {
        templateUrl: require('./view/fastPropertyDetails.html'),
        controller: 'FastPropertiesDetailsController',
        controllerAs: 'details'
      }
    },
    resolve: {
      fastProperty: ['$stateParams', ($stateParams: angular.ui.IStateParamsService) => {
        return {
          propertyId: $stateParams['propertyId'],
        };
      }]
    },
    data: {
      pageTitleDetails: {
        title: 'Fast Property Details',
        propertyId: 'propertyId',
        accountParam: 'accountId',
        regionParam: 'region'
      },
      history: {
        type: 'properties',
      },
    }
  };


  const applicationFastProperty: INestedState = {
    name: 'properties',
    url: '/properties',
    reloadOnSearch: false,
    views: {
      'master': {
        templateUrl: require('./view/properties.html'),
        controller: 'FastPropertiesController',
        controllerAs: 'fp'
      },
    },
    children: [
      applicationFastPropertyDetails
    ]
  };

  const propInsights: INestedState = {
    name: 'propInsights',
    abstract: true,
    views: {
      'insight': {
        templateUrl: require('./mainApplicationProperties.html'),
      }
    },
    data: {
      pageTitleSection: {
        title: 'Fast Properties'
      }
//.........这里部分代码省略.........

]).config((applicationStateProvider: ApplicationStateProvider) => {

  const loadBalancerDetails: INestedState = {
    name: 'loadBalancerDetails',
    url: '/loadBalancerDetails/:provider/:accountId/:region/:vpcId/:name',
    params: {
      vpcId: {
        value: null,
        squash: true,
      },
    },
    views: {
      'detail@../insight': {
        templateProvider: ['$templateCache', '$stateParams', 'cloudProviderRegistry',
          ($templateCache: ng.ITemplateCacheService,
           $stateParams: ILoadBalancerDetailsStateParams,
           cloudProviderRegistry: CloudProviderRegistry) => {
            return $templateCache.get(cloudProviderRegistry.getValue($stateParams.provider, 'loadBalancer.detailsTemplateUrl'));
        }],
        controllerProvider: ['$stateParams', 'cloudProviderRegistry',
          ($stateParams: ILoadBalancerDetailsStateParams,
           cloudProviderRegistry: CloudProviderRegistry) => {
            return cloudProviderRegistry.getValue($stateParams.provider, 'loadBalancer.detailsController');
        }],
        controllerAs: 'ctrl'
      }
    },
    resolve: {
      loadBalancer: ['$stateParams', ($stateParams: ILoadBalancerDetailsStateParams) => {
        return {
          name: $stateParams.name,
          accountId: $stateParams.accountId,
          region: $stateParams.region,
          vpcId: $stateParams.vpcId
        };
      }]
    },
    data: {
      pageTitleDetails: {
        title: 'Load Balancer Details',
        nameParam: 'name',
        accountParam: 'accountId',
        regionParam: 'region'
      },
      history: {
        type: 'loadBalancers',
      },
    }
  };

  const loadBalancers: INestedState = {
      url: '/loadBalancers',
      name: 'loadBalancers',
      views: {
        'nav': {
          template: '<load-balancer-filter app="$resolve.app"></load-balancer-filter>',
        },
        'master': {
          templateUrl: require('../loadBalancer/all.html'),
          controller: 'AllLoadBalancersCtrl',
          controllerAs: 'ctrl'
        }
      },
      data: {
        pageTitleSection: {
          title: 'Load Balancers'
        }
      },
      children: [],
    };

  applicationStateProvider.addInsightState(loadBalancers);
  applicationStateProvider.addInsightDetailState(loadBalancerDetails);
});

]).config((stateConfigProvider: StateConfigProvider, applicationStateProvider: ApplicationStateProvider) => {
  const dashboard: INestedState = {
    name: 'dashboard',
    url: '/dashboard',
    views: {
      detail: {
        templateUrl: require('../projects/dashboard/dashboard.html'),
        controller: 'ProjectDashboardCtrl',
        controllerAs: 'vm',
      },
    },
    data: {
      pageTitleSection: {
        title: 'Dashboard',
      },
    },
  };

  const project: INestedState = {
    name: 'project',
    url: '/projects/{project}',
    resolve: {
      projectConfiguration: [
        '$stateParams',
        ($stateParams: IProjectStateParms) => {
          return ProjectReader.getProjectConfig($stateParams.project).then(
            (projectConfig: IProject) => projectConfig,
            (): IProject => {
              return {
                id: null,
                name: $stateParams.project,
                email: null,
                config: null,
                notFound: true,
              };
            },
          );
        },
      ],
    },
    views: {
      'main@': {
        templateUrl: require('../projects/project.html'),
        controller: 'ProjectCtrl',
        controllerAs: 'vm',
      },
    },
    data: {
      pageTitleMain: {
        field: 'project',
      },
      history: {
        type: 'projects',
      },
    },
    children: [dashboard],
  };

  const allProjects: INestedState = {
    name: 'projects',
    url: '/projects',
    views: {
      'main@': {
        templateUrl: require('../projects/projects.html'),
        controller: 'ProjectsCtrl',
        controllerAs: 'ctrl',
      },
    },
    data: {
      pageTitleMain: {
        label: 'Projects',
      },
    },
    children: [project],
  };

  stateConfigProvider.addToRootState(allProjects);
  stateConfigProvider.addToRootState(project);
  applicationStateProvider.addParentState(project, 'detail', '/applications');

  stateConfigProvider.addRewriteRule('/projects/{project}', '/projects/{project}/dashboard');
  stateConfigProvider.addRewriteRule(
    '/projects/{project}/applications/{application}',
    '/projects/{project}/applications/{application}/clusters',
  );
});

  (applicationStateProvider: ApplicationStateProvider, stateConfigProvider: StateConfigProvider) => {
    const pipelineConfig: INestedState = {
      name: 'pipelineConfig',
      url: '/configure/:pipelineId?executionId&new',
      views: {
        pipelines: {
          templateUrl: require('../pipeline/config/pipelineConfig.html'),
          controller: 'PipelineConfigCtrl',
          controllerAs: 'vm',
        },
      },
      data: {
        pageTitleSection: {
          title: 'pipeline config',
        },
      },
    };

    // a specific stage can be deep linked by providing either refId or stageId,
    // which will be resolved to stage or step by the executionDetails controller to stage/step parameters,
    // replacing the URL
    const executionDetails: INestedState = {
      name: 'execution',
      url: '/:executionId?refId&stage&subStage&step&details&stageId',
      params: {
        stage: {
          value: '0',
        },
        step: {
          value: '0',
        },
      },
      data: {
        pageTitleDetails: {
          title: 'Execution Details',
          nameParam: 'executionId',
        },
      },
    };

    const singleExecutionDetails: INestedState = {
      name: 'executionDetails',
      url: '/details',
      views: {
        pipelines: { component: SingleExecutionDetails, $type: 'react' },
      },
      params: {
        executionParams: null,
      },
      abstract: true,
      children: [executionDetails],
    };

    const executions: INestedState = {
      name: 'executions',
      url: `?startManualExecution&${stateConfigProvider.paramsToQuery(filterModelConfig)}`,
      views: {
        pipelines: { component: Executions, $type: 'react' },
      },
      params: stateConfigProvider.buildDynamicParams(filterModelConfig),
      children: [executionDetails],
      data: {
        pageTitleSection: {
          title: 'Pipeline Executions',
        },
      },
    };

    const pipelines: INestedState = {
      name: 'pipelines',
      url: '/executions',
      abstract: true,
      views: {
        insight: {
          template: '<div ui-view="pipelines" sticky-headers class="flex-fill"></div>',
        },
      },
      children: [executions, pipelineConfig, singleExecutionDetails],
    };

    applicationStateProvider.addChildState(pipelines);
  },

]).config((applicationStateProvider: ApplicationStateProvider, stateConfigProvider: StateConfigProvider) => {
  const clusters: INestedState = {
      name: 'clusters',
      url: '/clusters',
      views: {
        'nav': {
          templateUrl: require('../cluster/filter/filterNav.html'),
          controller: 'ClusterFilterCtrl',
          controllerAs: 'clustersFilters'
        },
        'master': {
          templateUrl: require('../cluster/all.html'),
          controller: 'AllClustersCtrl',
          controllerAs: 'allClusters'
        }
      },
      data: {
        pageTitleSection: {
          title: 'Clusters'
        }
      },
      children: [],
    };

  const serverGroupDetails: INestedState = {
    name: 'serverGroup',
    url: '/serverGroupDetails/:provider/:accountId/:region/:serverGroup',
    views: {
      'detail@../insight': {
        templateProvider: ['$templateCache', '$stateParams', 'cloudProviderRegistry',
          ($templateCache: ng.ITemplateCacheService,
           $stateParams: IServerGroupStateParams,
           cloudProviderRegistry: CloudProviderRegistry) => {
            return $templateCache.get(cloudProviderRegistry.getValue($stateParams.provider, 'serverGroup.detailsTemplateUrl'));
        }],
        controllerProvider: ['$stateParams', 'cloudProviderRegistry',
          ($stateParams: IServerGroupStateParams,
           cloudProviderRegistry: CloudProviderRegistry) => {
            return cloudProviderRegistry.getValue($stateParams.provider, 'serverGroup.detailsController');
        }],
        controllerAs: 'ctrl'
      }
    },
    resolve: {
      serverGroup: ['$stateParams', ($stateParams: IServerGroupStateParams) => {
        return {
          name: $stateParams.serverGroup,
          accountId: $stateParams.accountId,
          region: $stateParams.region,
        };
      }]
    },
    data: {
      pageTitleDetails: {
        title: 'Server Group Details',
        nameParam: 'serverGroup',
        accountParam: 'accountId',
        regionParam: 'region'
      },
      history: {
        type: 'serverGroups',
      },
    }
  };

  const multipleServerGroups: INestedState = {
    name: 'multipleServerGroups',
    url: '/multipleServerGroups',
    views: {
      'detail@../insight': {
        templateUrl: require('../serverGroup/details/multipleServerGroups.view.html'),
        controller: 'MultipleServerGroupsCtrl',
        controllerAs: 'vm'
      }
    },
    data: {
      pageTitleDetails: {
        title: 'Multiple Server Groups',
      },
    }
  };

  applicationStateProvider.addInsightState(clusters);
  applicationStateProvider.addInsightDetailState(serverGroupDetails);
  applicationStateProvider.addInsightDetailState(multipleServerGroups);

  stateConfigProvider.addRewriteRule('/applications/{application}', '/applications/{application}/clusters');
});