[ENDPOINT] First version of the trusted apps list.

x-pack/plugins/security_solution/public/common/store/actions.ts

@@ -7,10 +7,16 @@
 import { EndpointAction } from '../../management/pages/endpoint_hosts/store/action';
 import { PolicyListAction } from '../../management/pages/policy/store/policy_list';
 import { PolicyDetailsAction } from '../../management/pages/policy/store/policy_details';
+import { TrustedAppsPageAction } from '../../management/pages/trusted_apps/store/action';
 
 export { appActions } from './app';
 export { dragAndDropActions } from './drag_and_drop';
 export { inputsActions } from './inputs';
 import { RoutingAction } from './routing';
 
-export type AppAction = EndpointAction | RoutingAction | PolicyListAction | PolicyDetailsAction;
+export type AppAction =
+  | EndpointAction
+  | RoutingAction
+  | PolicyListAction
+  | PolicyDetailsAction
+  | TrustedAppsPageAction;

x-pack/plugins/security_solution/public/common/store/routing/action.ts

@@ -6,7 +6,7 @@
 
 import { AppLocation, Immutable } from '../../../../common/endpoint/types';
 
-interface UserChangedUrl {
+export interface UserChangedUrl {
   readonly type: 'userChangedUrl';
   readonly payload: Immutable<AppLocation>;
 }

x-pack/plugins/security_solution/public/management/common/constants.ts

@@ -24,6 +24,11 @@ export const MANAGEMENT_STORE_POLICY_LIST_NAMESPACE = 'policyList';
 export const MANAGEMENT_STORE_POLICY_DETAILS_NAMESPACE = 'policyDetails';
 /** Namespace within the Management state where endpoint-host state is maintained */
 export const MANAGEMENT_STORE_ENDPOINTS_NAMESPACE = 'endpoints';
+/** Namespace within the Management state where trusted apps page state is maintained */
+export const MANAGEMENT_STORE_TRUSTED_APPS_NAMESPACE = 'trustedApps';
+
+export const MANAGEMENT_DEFAULT_PAGE = 1;
+export const MANAGEMENT_DEFAULT_PAGE_SIZE = 10;
 
 // --[ DEFAULTS ]---------------------------------------------------------------------------
 /** The default polling interval to start all polling pages */

x-pack/plugins/security_solution/public/management/common/routing.ts

@@ -10,6 +10,8 @@ import { generatePath } from 'react-router-dom';
 import querystring from 'querystring';
 
 import {
+  MANAGEMENT_DEFAULT_PAGE,
+  MANAGEMENT_DEFAULT_PAGE_SIZE,
   MANAGEMENT_ROUTING_ENDPOINTS_PATH,
   MANAGEMENT_ROUTING_POLICIES_PATH,
   MANAGEMENT_ROUTING_POLICY_DETAILS_PATH,
@@ -86,8 +88,26 @@ export const getPolicyDetailPath = (policyId: string, search?: string) => {
   })}${appendSearch(search)}`;
 };
 
-export const getTrustedAppsListPath = (search?: string) => {
-  return `${generatePath(MANAGEMENT_ROUTING_TRUSTED_APPS_PATH, {
+interface TrustedAppsListParams {
+  page_index?: number;
+  page_size?: number;
+}
+
+const normalizeTrustedAppsListParams = (params?: TrustedAppsListParams) => {
+  if (params) {
+    return {
+      ...(params.page_index === MANAGEMENT_DEFAULT_PAGE ? {} : { page_index: params.page_index }),
+      ...(params.page_size === MANAGEMENT_DEFAULT_PAGE_SIZE ? {} : { page_size: params.page_size }),
+    };
+  } else {
+    return {};
+  }
+};
+
+export const getTrustedAppsListPath = (params?: TrustedAppsListParams) => {
+  const path = generatePath(MANAGEMENT_ROUTING_TRUSTED_APPS_PATH, {
     tabName: AdministrationSubTab.trustedApps,
-  })}${appendSearch(search)}`;
+  });
+
+  return `${path}${appendSearch(querystring.stringify(normalizeTrustedAppsListParams(params)))}`;
 };

x-pack/plugins/security_solution/public/management/index.ts

@@ -47,9 +47,7 @@ export class Management {
          * Cast the ImmutableReducer to a regular reducer for compatibility with
          * the subplugin architecture (which expects plain redux reducers.)
          */
-        reducer: {
-          management: managementReducer,
-        } as ManagementPluginReducer,
+        reducer: { management: managementReducer } as ManagementPluginReducer,
         middleware: managementMiddlewareFactory(core, plugins),
       },
     };

x-pack/plugins/security_solution/public/management/pages/trusted_apps/service/index.ts

@@ -0,0 +1,22 @@
+/*
+ * Copyright Elasticsearch B.V. and/or licensed to Elasticsearch B.V. under one
+ * or more contributor license agreements. Licensed under the Elastic License;
+ * you may not use this file except in compliance with the Elastic License.
+ */
+
+import { HttpStart } from 'kibana/public';
+import { GetTrustedListAppsResponse } from '../../../../../common/endpoint/types/trusted_apps';
+
+export interface TrustedAppsService {
+  getTrustedAppsList(page: number, perPage: number): Promise<GetTrustedListAppsResponse>;
+}
+
+export class TrustedAppsHttpService implements TrustedAppsService {
+  constructor(private http: HttpStart) {}
+
+  async getTrustedAppsList(page: number, perPage: number): Promise<GetTrustedListAppsResponse> {
+    return this.http.get<GetTrustedListAppsResponse>('/api/endpoint/trusted_apps', {
+      query: { page, per_page: perPage },
+    });
+  }
+}

x-pack/plugins/security_solution/public/management/pages/trusted_apps/state/async_data_binding.ts

@@ -0,0 +1,85 @@
+/*
+ * Copyright Elasticsearch B.V. and/or licensed to Elasticsearch B.V. under one
+ * or more contributor license agreements. Licensed under the Elastic License;
+ * you may not use this file except in compliance with the Elastic License.
+ */
+
+import { Immutable } from '../../../../../common/endpoint/types';
+
+export interface UninitialisedAsyncBinding {
+  type: 'UninitialisedAsyncBinding';
+}
+
+export interface InProgressAsyncBinding<T, E> {
+  type: 'InProgressAsyncBinding';
+  previousBinding: StaleAsyncBinding<T, E>;
+}
+
+export interface PresentAsyncBinding<T> {
+  type: 'PresentAsyncBinding';
+  data: T;
+}
+
+export interface FailedAsyncBinding<T, E> {
+  type: 'FailedAsyncBinding';
+  error: E;
+  lastPresentBinding?: PresentAsyncBinding<T>;
+}
+
+export type StaleAsyncBinding<T, E> =
+  | UninitialisedAsyncBinding
+  | PresentAsyncBinding<T>
+  | FailedAsyncBinding<T, E>;
+
+export type AsyncDataBinding<T, E> =
+  | UninitialisedAsyncBinding
+  | InProgressAsyncBinding<T, E>
+  | PresentAsyncBinding<T>
+  | FailedAsyncBinding<T, E>;
+
+export const isUninitialisedAsyncBinding = <T, E>(
+  binding: Immutable<AsyncDataBinding<T, E>>
+): binding is Immutable<UninitialisedAsyncBinding> => binding.type === 'UninitialisedAsyncBinding';
+
+export const isInProgressBinding = <T, E>(
+  binding: Immutable<AsyncDataBinding<T, E>>
+): binding is Immutable<InProgressAsyncBinding<T, E>> => binding.type === 'InProgressAsyncBinding';
+
+export const isPresentAsyncBinding = <T, E>(
+  binding: Immutable<AsyncDataBinding<T, E>>
+): binding is Immutable<PresentAsyncBinding<T>> => binding.type === 'PresentAsyncBinding';
+
+export const isFailedAsyncBinding = <T, E>(
+  binding: Immutable<AsyncDataBinding<T, E>>
+): binding is Immutable<FailedAsyncBinding<T, E>> => binding.type === 'FailedAsyncBinding';
+
+export const getLastPresentDataBinding = <T, E>(
+  binding: Immutable<AsyncDataBinding<T, E>>
+): Immutable<PresentAsyncBinding<T>> | undefined => {
+  if (isPresentAsyncBinding(binding)) {
+    return binding;
+  } else if (isInProgressBinding(binding)) {
+    return getLastPresentDataBinding(binding.previousBinding);
+  } else if (isFailedAsyncBinding(binding)) {
+    return binding.lastPresentBinding;
+  } else {
+    return undefined;
+  }
+};
+
+export const getLastPresentData = <T, E>(binding: Immutable<AsyncDataBinding<T, E>>) => {
+  return getLastPresentDataBinding(binding)?.data;
+};
+
+export const getCurrentError = <T, E>(binding: Immutable<AsyncDataBinding<T, E>>) => {
+  return isFailedAsyncBinding(binding) ? binding.error : undefined;
+};
+
+export const isStaleBinding = <T, E>(
+  binding: AsyncDataBinding<T, E>,
+  isFresh: (data: T) => boolean
+): boolean =>
+  isUninitialisedAsyncBinding(binding) ||
+  (isPresentAsyncBinding(binding) && !isFresh(binding.data)) ||
+  (isFailedAsyncBinding(binding) &&
+    (!binding.lastPresentBinding || !isFresh(binding.lastPresentBinding.data)));

x-pack/plugins/security_solution/public/management/pages/trusted_apps/state/items_page.ts

@@ -0,0 +1,19 @@
+/*
+ * Copyright Elasticsearch B.V. and/or licensed to Elasticsearch B.V. under one
+ * or more contributor license agreements. Licensed under the Elastic License;
+ * you may not use this file except in compliance with the Elastic License.
+ */
+
+export interface PageInfo {
+  index: number;
+  size: number;
+}
+
+export interface ItemsPage<T> {
+  items: T[];
+  pageInfo: PageInfo;
+  totalItemsCount: number;
+}
+
+export const pageInfosEqual = (pageInfo1: PageInfo, pageInfo2: PageInfo) =>
+  pageInfo1.index === pageInfo2.index && pageInfo1.size === pageInfo2.size;

x-pack/plugins/security_solution/public/management/pages/trusted_apps/state/list_view_state.ts

@@ -0,0 +1,14 @@
+/*
+ * Copyright Elasticsearch B.V. and/or licensed to Elasticsearch B.V. under one
+ * or more contributor license agreements. Licensed under the Elastic License;
+ * you may not use this file except in compliance with the Elastic License.
+ */
+
+import { ServerApiError } from '../../../../common/types';
+import { ItemsPage, PageInfo } from './items_page';
+import { AsyncDataBinding } from './async_data_binding';
+
+export interface ListViewState<T> {
+  currentPage: AsyncDataBinding<ItemsPage<T>, ServerApiError>;
+  currentPageInfo: PageInfo;
+}

x-pack/plugins/security_solution/public/management/pages/trusted_apps/state/trusted_apps_page_state.ts

@@ -0,0 +1,13 @@
+/*
+ * Copyright Elasticsearch B.V. and/or licensed to Elasticsearch B.V. under one
+ * or more contributor license agreements. Licensed under the Elastic License;
+ * you may not use this file except in compliance with the Elastic License.
+ */
+
+import { TrustedApp } from '../../../../../common/endpoint/types/trusted_apps';
+import { ListViewState } from './list_view_state';
+
+export interface TrustedAppsPageState {
+  list: ListViewState<TrustedApp>;
+  active: boolean;
+}

x-pack/plugins/security_solution/public/management/pages/trusted_apps/store/action.ts

@@ -0,0 +1,20 @@
+/*
+ * Copyright Elasticsearch B.V. and/or licensed to Elasticsearch B.V. under one
+ * or more contributor license agreements. Licensed under the Elastic License;
+ * you may not use this file except in compliance with the Elastic License.
+ */
+
+import { ServerApiError } from '../../../../common/types';
+import { TrustedApp } from '../../../../../common/endpoint/types/trusted_apps';
+import { RoutingAction } from '../../../../common/store/routing/action';
+import { AsyncDataBinding } from '../state/async_data_binding';
+import { ItemsPage } from '../state/items_page';
+
+export interface ListDataBindingChanged {
+  type: 'listDataBindingChanged';
+  payload: {
+    newBinding: AsyncDataBinding<ItemsPage<TrustedApp>, ServerApiError>;
+  };
+}
+
+export type TrustedAppsPageAction = ListDataBindingChanged | RoutingAction;

x-pack/plugins/security_solution/public/management/pages/trusted_apps/store/middleware.ts

@@ -0,0 +1,83 @@
+/*
+ * Copyright Elasticsearch B.V. and/or licensed to Elasticsearch B.V. under one
+ * or more contributor license agreements. Licensed under the Elastic License;
+ * you may not use this file except in compliance with the Elastic License.
+ */
+
+import { ServerApiError } from '../../../../common/types';
+import { Immutable, TrustedApp } from '../../../../../common/endpoint/types';
+import { ImmutableMiddlewareAPI, ImmutableMiddlewareFactory } from '../../../../common/store';
+import { AppAction } from '../../../../common/store/actions';
+import { TrustedAppsPageState as PageState } from '../state/trusted_apps_page_state';
+import { TrustedAppsHttpService, TrustedAppsService } from '../service';
+import { needsRefreshOfListData } from './selectors';
+import { ListDataBindingChanged } from './action';
+import {
+  AsyncDataBinding,
+  StaleAsyncBinding,
+  getLastPresentDataBinding,
+} from '../state/async_data_binding';
+import { ItemsPage } from '../state/items_page';
+
+type ListBinding = Immutable<AsyncDataBinding<ItemsPage<TrustedApp>, ServerApiError>>;
+type StaleListBinding = Immutable<StaleAsyncBinding<ItemsPage<TrustedApp>, ServerApiError>>;
+
+const listDataBindingChanged = (newBinding: ListBinding): Immutable<ListDataBindingChanged> => ({
+  type: 'listDataBindingChanged',
+  payload: { newBinding },
+});
+
+const refreshList = async (
+  store: ImmutableMiddlewareAPI<PageState, AppAction>,
+  trustedAppsService: TrustedAppsService
+) => {
+  const list = store.getState().list;
+
+  store.dispatch(
+    listDataBindingChanged({
+      type: 'InProgressAsyncBinding',
+      // need to think on how to avoid the casting
+      previousBinding: list.currentPage as StaleListBinding,
+    })
+  );
+
+  try {
+    const response = await trustedAppsService.getTrustedAppsList(
+      list.currentPageInfo.index,
+      list.currentPageInfo.size
+    );
+
+    store.dispatch(
+      listDataBindingChanged({
+        type: 'PresentAsyncBinding',
+        data: {
+          items: response.data,
+          pageInfo: list.currentPageInfo,
+          totalItemsCount: response.total,
+        },
+      })
+    );
+  } catch (error) {
+    store.dispatch(
+      listDataBindingChanged({
+        type: 'FailedAsyncBinding',
+        error,
+        lastPresentBinding: getLastPresentDataBinding(list.currentPage),
+      })
+    );
+  }
+};
+
+const middlewareFactory: ImmutableMiddlewareFactory<PageState> = (coreStart) => {
+  const trustedAppsService: TrustedAppsService = new TrustedAppsHttpService(coreStart.http);
+
+  return (store) => (next) => async (action) => {
+    next(action);
+
+    if (needsRefreshOfListData(store.getState())) {
+      await refreshList(store, trustedAppsService);
+    }
+  };
+};
+
+export { middlewareFactory as trustedAppsPageMiddlewareFactory };