src/store/modules/topology/index.ts - skywalking-rocketbot-ui - Git at Google

 /**
  * Licensed to the Apache Software Foundation (ASF) under one or more
  * contributor license agreements.  See the NOTICE file distributed with
  * this work for additional information regarding copyright ownership.
  * The ASF licenses this file to You under the Apache License, Version 2.0
  * (the "License"); you may not use this file except in compliance with
  * the License.  You may obtain a copy of the License at
  *
  *      http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */

 import { Commit, ActionTree, Dispatch } from 'vuex';
 import graph from '@/graph';
 import * as types from '../../mutation-types';
 import axios, { AxiosPromise, AxiosResponse } from 'axios';
 import { cancelToken } from '@/utils/cancelToken';

 interface Option {
   key: string;
   label: string;
 }
 export interface Duration {
   start: string;
   end: string;
   step: string;
 }
 export interface Call {
   avgResponseTime: number;
   cpm: number;
   isAlert: boolean;
   source: string | any;
   target: string | any;
   id: string;
   detectPoints: string[];
 }
 interface Node {
   apdex: number;
   avgResponseTime: number;
   cpm: number;
   id: string;
   isAlarm: boolean;
   name: string;
   numOfServer: number;
   numOfServerAlarm: number;
   numOfServiceAlarm: number;
   sla: number;
   type: string;
 }

 export interface EndpointDependencyConidition {
   serviceName: string;
   endpointName: string;
   destServiceName: string;
   destEndpointName: string;
   duration: Duration;
 }

 export interface State {
   callback: any;
   calls: Call[];
   nodes: Node[];
   detectPoints: string[];
   selectedServiceCall: Call | null;
   currentNode: any;
   currentLink: any;
   current: Option;
   mode: boolean;
   getResponseTimeTrend: number[];
   getSLATrend: number[];
   getThroughputTrend: number[];
   responsePercentile: { [key: string]: number[] };
   instanceDependency: {
     calls: Call[];
     nodes: Node[];
   };
   endpointDependency: {
     calls: Call[];
     nodes: Node[];
   };
   selectedInstanceCall: Call | null;
   instanceDependencyMetrics: { [key: string]: any };
   endpointDependencyMetrics: { [key: string]: any };
   currentEndpointDepth: { key: number; label: string };
   queryInstanceMetricsType: string;
   serviceThroughput: { Throughput: number[] };
   serviceSLA: { SLA: number[] };
   serviceResponseTime: { ResponseTime: number[] };
   servicePercentile: { [key: string]: number[] };
   serviceApdexScore: { ApdexScore: number[] };
   topoEndpoints: any[];
   topoInstances: any[];
 }

 const PercentileItem: string[] = ['p50', 'p75', 'p90', 'p95', 'p99'];

 const initState: State = {
   callback: '',
   mode: true,
   detectPoints: [],
   selectedServiceCall: null,
   calls: [],
   nodes: [],
   currentNode: {},
   currentLink: {},
   current: {
     key: 'default',
     label: 'default',
   },
   getResponseTimeTrend: [],
   getSLATrend: [],
   getThroughputTrend: [],
   responsePercentile: {},
   instanceDependency: {
     calls: [],
     nodes: [],
   },
   endpointDependency: {
     calls: [],
     nodes: [],
   },
   selectedInstanceCall: null,
   instanceDependencyMetrics: {},
   endpointDependencyMetrics: {},
   currentEndpointDepth: { key: 2, label: '2' },
   queryInstanceMetricsType: '',
   serviceThroughput: { Throughput: [] },
   serviceSLA: { SLA: [] },
   serviceResponseTime: { ResponseTime: [] },
   servicePercentile: {
     p50: [],
     p75: [],
     p90: [],
     p95: [],
     p99: [],
   },
   serviceApdexScore: { ApdexScore: [] },
   topoEndpoints: [],
   topoInstances: [],
 };

 // getters
 const getters = {};

 // mutations
 const mutations = {
   [types.SET_CALLBACK](state: State, data: any) {
     state.callback = data;
   },
   [types.SET_MODE](state: State, data: string[]) {
     state.detectPoints = data;
     const temp = state.mode ? 'SERVER' : 'CLIENT';
     if (data.indexOf(temp) === -1) {
       state.mode = !state.mode;
     }
   },
   [types.SET_MODE_STATUS](state: State, data: boolean) {
     state.mode = data;
   },
   [types.SET_NODE](state: State, data: any) {
     state.currentNode = data;
   },
   [types.SET_LINK](state: State, data: any) {
     state.currentLink = data;
   },
   [types.SET_TOPO](state: State, data: any) {
     state.calls = data.calls;
     state.nodes = data.nodes;
   },
   [types.SET_SELECTED_CALL](state: State, data: any) {
     state.selectedServiceCall = data;
   },
   [types.SET_TOPO_RELATION](state: State, data: any) {
     state.getResponseTimeTrend = data.getResponseTimeTrend
       ? data.getResponseTimeTrend.values.map((i: any) => i.value)
       : [];
     state.getSLATrend = data.getSLATrend ? data.getSLATrend.values.map((i: any) => i.value) : [];
     state.getThroughputTrend = data.getThroughputTrend ? data.getThroughputTrend.values.map((i: any) => i.value) : [];

     if (!data.getPercentile) {
       state.responsePercentile = {};
       return;
     }
     data.getPercentile.forEach((item: any, index: number) => {
       state.responsePercentile[PercentileItem[index]] = item.values.map((i: any) => i.value);
     });
   },
   [types.SET_INSTANCE_DEPENDENCY](state: State, data: any) {
     state.instanceDependency = data;
   },
   [types.SET_SELECTED_INSTANCE_CALL](state: State, data: Call) {
     state.selectedInstanceCall = data;
   },
   [types.SET_INSTANCE_DEPEDENCE_METRICS](state: State, data: any) {
     state.instanceDependencyMetrics.getResponseTimeTrend = data.getResponseTimeTrend
       ? data.getResponseTimeTrend.values.map((i: any) => i.value)
       : [];
     state.instanceDependencyMetrics.getSLATrend = data.getSLATrend
       ? data.getSLATrend.values.map((i: any) => i.value)
       : [];
     state.instanceDependencyMetrics.getThroughputTrend = data.getThroughputTrend
       ? data.getThroughputTrend.values.map((i: any) => i.value)
       : [];
     state.instanceDependencyMetrics.percentResponse = {};
     if (!data.getPercentile) {
       return;
     }
     data.getPercentile.forEach((item: any, index: number) => {
       state.instanceDependencyMetrics.percentResponse[PercentileItem[index]] = item.values.map((i: any) => i.value);
     });
   },
   [types.SET_ENDPOINT_DEPENDENCY_METRICS](state: State, data: { [key: string]: any }) {
     state.endpointDependencyMetrics.cpm = data.endpointRelationCpm
       ? data.endpointRelationCpm.values.values.map((i: any) => i.value)
       : [];
     state.endpointDependencyMetrics.respTime = data.endpointRelationRespTime
       ? data.endpointRelationRespTime.values.values.map((i: any) => i.value)
       : [];
     state.endpointDependencyMetrics.sla = data.endpointRelationSla
       ? data.endpointRelationSla.values.values.map((i: any) => i.value)
       : [];
     state.endpointDependencyMetrics.percentile = {};
     if (!data.endpointRelationPercentile) {
       return;
     }
     for (const item of data.endpointRelationPercentile) {
       state.endpointDependencyMetrics.percentile[PercentileItem[Number(item.label)]] = item.values.values.map(
         (i: any) => i.value,
       );
     }
   },
   [types.SET_INSTANCE_DEPEDENCE_TYPE](state: State, data: string) {
     state.queryInstanceMetricsType = data;
   },
   [types.SET_SERVICE_DETAIL](state: State, data: any) {
     state.serviceApdexScore = data.serviceApdexScore
       ? data.serviceApdexScore.values.map((i: any) => Number((i.value / 10000).toFixed(2)))
       : [];
     state.serviceResponseTime = data.serviceResponseTime
       ? data.serviceResponseTime.values.map((i: any) => i.value)
       : [];
     state.serviceThroughput = data.serviceThroughput ? data.serviceThroughput.values.map((i: any) => i.value) : [];
     state.serviceSLA = data.serviceSLA ? data.serviceSLA.values.map((i: any) => i.value / 100) : [];
     if (!data.servicePercentile) {
       return;
     }
     data.servicePercentile.forEach((item: any, index: number) => {
       state.servicePercentile[PercentileItem[index]] = item.values.map((i: any) => i.value);
     });
   },
   [types.SET_TOPO_ENDPOINT](state: State, data: any[]) {
     state.topoEndpoints = data;
     window.localStorage.setItem('topologyEndpoints', JSON.stringify(data));
   },
   [types.SET_TOPO_INSTANCE](state: State, data: any[]) {
     state.topoInstances = data;
     window.localStorage.setItem('topologyInstances', JSON.stringify(data));
   },
   [types.EDIT_TOPO_INSTANCE_CONFIG](state: State, params: { values: any; index: number }) {
     state.topoInstances[params.index] = { ...state.topoInstances[params.index], ...params.values };
     window.localStorage.setItem('topologyInstances', JSON.stringify(state.topoInstances));
   },
   [types.EDIT_TOPO_ENDPOINT_CONFIG](state: State, params: { values: any; index: number }) {
     state.topoEndpoints[params.index] = { ...state.topoEndpoints[params.index], ...params.values };
     window.localStorage.setItem('topologyEndpoints', JSON.stringify(state.topoEndpoints));
   },
   [types.DELETE_TOPO_ENDPOINT](state: State, index: number) {
     state.topoEndpoints.splice(index, 1);
     window.localStorage.setItem('topologyEndpoints', JSON.stringify(state.topoEndpoints));
   },
   [types.DELETE_TOPO_INSTANCE](state: State, index: number) {
     state.topoInstances.splice(index, 1);
     window.localStorage.setItem('topologyInstances', JSON.stringify(state.topoInstances));
   },
   [types.ADD_TOPO_INSTANCE_COMP](state: State) {
     const comp = {
       width: 3,
       title: 'Title',
       height: 350,
       entityType: 'ServiceInstance',
       independentSelector: false,
       metricType: 'UNKNOWN',
     };
     state.topoInstances.push(comp);
     window.localStorage.setItem('topologyInstances', JSON.stringify(state.topoInstances));
   },
   [types.ADD_TOPO_ENDPOINT_COMP](state: State) {
     const comp = {
       width: 3,
       title: 'Title',
       height: 350,
       entityType: 'Endpoint',
       independentSelector: false,
       metricType: 'UNKNOWN',
     };
     state.topoEndpoints.push(comp);
     window.localStorage.setItem('topologyEndpoints', JSON.stringify(state.topoEndpoints));
   },
   [types.SET_ENDPOINT_DEPENDENCY](state: State, data: { calls: Call[]; nodes: Node[] }) {
     state.endpointDependency = data;
   },
   [types.SET_ENDPOINT_DEPTH](state: State, data: { key: number; label: string }) {
     state.currentEndpointDepth = data;
   },
 };

 // actions
 const actions: ActionTree<State, any> = {
   GET_SERVICES(context: { commit: Commit }, params: { duration: Duration; keyword: string }) {
     if (!params.keyword) {
       params.keyword = '';
     }
     return graph
       .query('queryServices')
       .params(params)
       .then((res: AxiosResponse) => {
         return res.data.data.services || [];
       });
   },
   GET_SERVICE_ENDPOINTS(context: { commit: Commit }, params: { serviceId: string; keyword: string }) {
     if (!params.serviceId) {
       return new Promise((resolve) => resolve());
     }
     if (!params.keyword) {
       params.keyword = '';
     }
     return graph
       .query('queryEndpoints')
       .params(params)
       .then((res: AxiosResponse) => {
         return res.data.data.getEndpoints || [];
       });
   },
   CLEAR_TOPO(context: { commit: Commit; state: State }) {
     context.commit(types.SET_TOPO, { calls: [], nodes: [] });
   },
   CLEAR_TOPO_INFO(context: { commit: Commit; state: State }) {
     context.commit(types.SET_TOPO_RELATION, {});
     context.commit(types.SET_SELECTED_CALL, null);
   },
   GET_INSTANCE_DEPENDENCY_METRICS(
     context: { commit: Commit; state: State; dispatch: Dispatch; getters: any },
     params: any,
   ) {
     if (params.mode === 'SERVER') {
       params.queryType = 'queryTopoInstanceServerInfo';
       context.dispatch('INSTANCE_RELATION_INFO', params);
     }
     if (params.mode === 'CLIENT') {
       params.queryType = 'queryTopoInstanceClientInfo';
       context.dispatch('INSTANCE_RELATION_INFO', params);
     }
   },
   GET_TOPO_SERVICE_INFO(context: { commit: Commit; state: State }, params: { id: string; duration: Duration }) {
     if (!params.id) {
       return;
     }
     return graph
       .query('queryTopoServiceInfo')
       .params({
         id: params.id,
         duration: params.duration,
       })
       .then((res: AxiosResponse) => {
         if (!res.data.data) {
           return;
         }
         context.commit('SET_TOPO_RELATION', res.data.data);
         context.commit(types.SET_SELECTED_CALL, params);
       });
   },
   GET_TOPO_CLIENT_INFO(context: { commit: Commit; state: State }, params: any) {
     return graph
       .query('queryTopoClientInfo')
       .params(params)
       .then((res: AxiosResponse) => {
         if (!res.data.data) {
           return;
         }
         context.commit('SET_TOPO_RELATION', res.data.data);
         context.commit(types.SET_SELECTED_CALL, params);
       });
   },
   GET_TOPO_SERVICE_DETAIL(
     context: { commit: Commit; state: State },
     params: { serviceId: string; duration: Duration },
   ) {
     return graph
       .query('queryTopoServiceDetail')
       .params({
         serviceId: params.serviceId,
         duration: params.duration,
       })
       .then((res: AxiosResponse) => {
         if (!res.data.data) {
           return;
         }
         context.commit('SET_SERVICE_DETAIL', res.data.data);
       });
   },
   GET_TOPO(context: { commit: Commit; state: State }, params: any) {
     let query = 'queryTopo';
     if (params.serviceId) {
       query = 'queryServiceTopo';
     }
     if (params.serviceIds) {
       query = 'queryServicesTopo';
     }
     return graph
       .query(query)
       .params(params)
       .then((res: AxiosResponse) => {
         if (res.data.errors) {
           context.commit(types.SET_TOPO, { calls: [], nodes: [] });
           return;
         }
         const calls = res.data.data.topo.calls;
         const nodes = res.data.data.topo.nodes;
         const ids = nodes.map((i: any) => i.id);
         const idsC = calls.filter((i: any) => i.detectPoints.indexOf('CLIENT') !== -1).map((b: any) => b.id);
         const idsS = calls.filter((i: any) => i.detectPoints.indexOf('CLIENT') === -1).map((b: any) => b.id);
         return graph
           .query('queryTopoInfo')
           .params({ ...params, ids, idsC, idsS })
           .then((info: AxiosResponse) => {
             const resInfo = info.data.data;
             if (!resInfo.sla) {
               return context.commit(types.SET_TOPO, { calls, nodes });
             }
             for (let i = 0; i < resInfo.sla.values.length; i += 1) {
               for (let j = 0; j < nodes.length; j += 1) {
                 if (nodes[j].id === resInfo.sla.values[i].id) {
                   nodes[j] = {
                     ...nodes[j],
                     isGroupActive: true,
                     sla: resInfo.sla.values[i].value ? resInfo.sla.values[i].value / 100 : -1,
                     cpm: resInfo.nodeCpm.values[i] ? resInfo.nodeCpm.values[i].value : -1,
                     latency: resInfo.nodeLatency.values[i] ? resInfo.nodeLatency.values[i].value : -1,
                   };
                 }
               }
             }
             if (!resInfo.cpmC) {
               return context.commit(types.SET_TOPO, { calls, nodes });
             }
             for (let i = 0; i < resInfo.cpmC.values.length; i += 1) {
               for (let j = 0; j < calls.length; j += 1) {
                 if (calls[j].id === resInfo.cpmC.values[i].id) {
                   calls[j] = {
                     ...calls[j],
                     isGroupActive: true,
                     cpm: resInfo.cpmC.values[i] ? resInfo.cpmC.values[i].value : '',
                     latency: resInfo.latencyC.values[i] ? resInfo.latencyC.values[i].value : '',
                   };
                 }
               }
             }
             if (!resInfo.cpmS) {
               return context.commit(types.SET_TOPO, { calls, nodes });
             }
             for (let i = 0; i < resInfo.cpmS.values.length; i += 1) {
               for (let j = 0; j < calls.length; j += 1) {
                 if (calls[j].id === resInfo.cpmS.values[i].id) {
                   calls[j] = {
                     ...calls[j],
                     cpm: resInfo.cpmS.values[i] ? resInfo.cpmS.values[i].value : '',
                     latency: resInfo.latencyS.values[i] ? resInfo.latencyS.values[i].value : '',
                   };
                 }
               }
             }
             context.commit(types.SET_TOPO, { calls, nodes });
           });
       });
   },
   // todo sync
   GET_ALL_ENDPOINT_DEPENDENCY(
     context: { commit: Commit; state: State; dispatch: Dispatch },
     params: { endpointIds: string[]; duration: Duration },
   ) {
     context.dispatch('GET_ENDPOINT_TOPO', params).then((res) => {
       if (context.state.currentEndpointDepth.key > 1) {
         const endpointIds = res.nodes.map((item: Node) => item.id);

         context.dispatch('GET_ENDPOINT_TOPO', { endpointIds, duration: params.duration }).then((json) => {
           if (context.state.currentEndpointDepth.key > 2) {
             const ids = json.nodes.map((item: Node) => item.id);

             context.dispatch('GET_ENDPOINT_TOPO', { endpointIds: ids, duration: params.duration }).then((topo) => {
               if (context.state.currentEndpointDepth.key > 3) {
                 const endpoints = topo.nodes.map((item: Node) => item.id);
                 context
                   .dispatch('GET_ENDPOINT_TOPO', { endpointIds: endpoints, duration: params.duration })
                   .then((data) => {
                     if (context.state.currentEndpointDepth.key > 4) {
                       context
                         .dispatch('GET_ENDPOINT_TOPO', { endpointIds: endpoints, duration: params.duration })
                         .then((topos) => {
                           context.commit(types.SET_ENDPOINT_DEPENDENCY, topos);
                         });
                     } else {
                       context.commit(types.SET_ENDPOINT_DEPENDENCY, data);
                     }
                   });
               } else {
                 context.commit(types.SET_ENDPOINT_DEPENDENCY, topo);
               }
             });
           } else {
             context.commit(types.SET_ENDPOINT_DEPENDENCY, json);
           }
         });
       } else {
         context.commit(types.SET_ENDPOINT_DEPENDENCY, res);
       }
     });
   },
   GET_ENDPOINT_TOPO(context: { commit: Commit; state: State }, params: { endpointIds: string[]; duration: Duration }) {
     const variables = ['$duration: Duration!'];
     const fragment = params.endpointIds.map((id: string, index: number) => {
       return `endpointTopology${index}: getEndpointDependencies(endpointId: "${id}", duration: $duration) {
         nodes {
           id
           name
           serviceId
           serviceName
           type
           isReal
         }
         calls {
           id
           source
           target
           detectPoints
         }
       }`;
     });
     const querys = `query queryData(${variables}) {${fragment}}`;
     return axios
       .post('/graphql', { query: querys, variables: { duration: params.duration } }, { cancelToken: cancelToken() })
       .then((res: AxiosResponse) => {
         if (res.data.errors) {
           context.commit(types.SET_ENDPOINT_DEPENDENCY, { calls: [], nodes: [] });
           return;
         }
         const topo = res.data.data;
         const calls = [] as any;
         let nodes = [] as any;
         for (const key of Object.keys(topo)) {
           calls.push(...topo[key].calls);
           nodes.push(...topo[key].nodes);
         }
         const obj = {} as any;
         nodes = nodes.reduce((prev: Node[], next: Node) => {
           if (!obj[next.id]) {
             obj[next.id] = true;
             prev.push(next);
           }
           return prev;
         }, []);
         const queryVariables = ['$duration: Duration!'];
         const fragments = calls
           .map((call: Call & EndpointDependencyConidition, index: number) => {
             let source = {} as any;
             let target = {} as any;
             for (const node of nodes) {
               if (node.id === call.source) {
                 source = node;
                 call.serviceName = node.serviceName;
                 call.endpointName = node.name;
               }
               if (node.id === call.target) {
                 target = node;
                 call.destServiceName = node.serviceName;
                 call.destEndpointName = node.name;
               }
             }
             return `cpm_${index}: readMetricsValue(condition: {
             name: "endpoint_relation_cpm"
             entity: {
               scope: EndpointRelation
               serviceName: "${source.serviceName}"
               normal: true
               endpointName: "${source.name}"
               destNormal: true
               destServiceName: "${target.serviceName}"
               destEndpointName: "${target.name}"
             }
           }, duration: $duration)`;
           })
           .join(' ');
         const query = `query queryData(${queryVariables}) {${fragments}}`;
         return axios
           .post('/graphql', { query, variables: { duration: params.duration } }, { cancelToken: cancelToken() })
           .then((json: AxiosResponse<any>) => {
             if (json.data.errors) {
               context.commit(types.SET_ENDPOINT_DEPENDENCY, { calls: [], nodes: [] });
               return;
             }
             const cpms = json.data.data;
             const keys = Object.keys(cpms);
             for (const key of keys) {
               const index = Number(key.split('_')[1]);
               calls[index].value = cpms[key] || 0.01;
             }
             return { calls, nodes };
           })
           .catch(() => {
             context.commit(types.SET_ENDPOINT_DEPENDENCY, { calls: [], nodes: [] });
           });
       });
   },
   async GET_TOPO_INSTANCE_DEPENDENCY(
     context: { commit: Commit; state: State },
     params: {
       clientServiceId: string;
       serverServiceId: string;
       duration: Duration;
     },
   ) {
     graph
       .query('queryTopoInstanceDependency')
       .params(params)
       .then((res: AxiosResponse) => {
         if (!(res.data && res.data.data)) {
           return;
         }
         const serverIdsC = [] as string[];
         const clientIdsC = [] as string[];
         const topoCalls = res.data.data.topo.calls;
         for (const call of topoCalls) {
           if (call.detectPoints.includes('CLIENT')) {
             clientIdsC.push(call.id);
           } else {
             serverIdsC.push(call.id);
           }
         }
         graph
           .query('queryDependencyInstanceClientMetric')
           .params({
             idsC: clientIdsC,
             duration: params.duration,
           })
           .then((json: AxiosResponse) => {
             const clientCalls = [] as string[];
             for (const call of topoCalls) {
               for (const cpm of json.data.data.cpmC.values) {
                 if (cpm.id === call.id) {
                   clientCalls.push({
                     ...call,
                     ...cpm,
                   });
                 }
               }
             }
             graph
               .query('queryDependencyInstanceServerMetric')
               .params({
                 idsC: serverIdsC,
                 duration: params.duration,
               })
               .then((jsonResp: AxiosResponse) => {
                 const serverCalls = [] as string[];
                 for (const call of topoCalls) {
                   for (const cpm of jsonResp.data.data.cpmC.values) {
                     if (cpm.id === call.id) {
                       serverCalls.push({
                         ...call,
                         ...cpm,
                       });
                     }
                   }
                 }
                 const data = {
                   nodes: res.data.data.topo.nodes,
                   calls: [...serverCalls, ...clientCalls],
                 };
                 context.commit(types.SET_INSTANCE_DEPENDENCY, data);
               });
           });
       });
   },
   INSTANCE_RELATION_INFO(
     context: { commit: Commit; state: State },
     params: Call & { mode: string; queryType: string; durationTime: Duration },
   ) {
     graph
       .query(params.queryType)
       .params({
         id: params.id,
         duration: params.durationTime,
       })
       .then((res: AxiosResponse) => {
         if (!(res.data && res.data.data)) {
           return;
         }
         context.commit(types.SET_SELECTED_INSTANCE_CALL, params);
         context.commit(types.SET_INSTANCE_DEPEDENCE_TYPE, params.mode);
         context.commit(types.SET_INSTANCE_DEPEDENCE_METRICS, res.data.data);
       });
   },
   GET_ENDPOINT_DEPENDENCY_METRICS(context: { commit: Commit; state: State }, params: EndpointDependencyConidition) {
     return graph
       .query('queryTopoEndpointDependencyMetrics')
       .params(params)
       .then((res: AxiosResponse) => {
         if (!(res.data && res.data.data)) {
           return;
         }
         context.commit(types.SET_ENDPOINT_DEPENDENCY_METRICS, res.data.data);
       });
   },
 };

 export default {
   namespaced: true,
   state: initState,
   getters,
   actions,
   mutations,
 };
	/**
	* Licensed to the Apache Software Foundation (ASF) under one or more
	* contributor license agreements. See the NOTICE file distributed with
	* this work for additional information regarding copyright ownership.
	* The ASF licenses this file to You under the Apache License, Version 2.0
	* (the "License"); you may not use this file except in compliance with
	* the License. You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*/

	import { Commit, ActionTree, Dispatch } from 'vuex';
	import graph from '@/graph';
	import * as types from '../../mutation-types';
	import axios, { AxiosPromise, AxiosResponse } from 'axios';
	import { cancelToken } from '@/utils/cancelToken';

	interface Option {
	key: string;
	label: string;
	}
	export interface Duration {
	start: string;
	end: string;
	step: string;
	}
	export interface Call {
	avgResponseTime: number;
	cpm: number;
	isAlert: boolean;
	source: string \| any;
	target: string \| any;
	id: string;
	detectPoints: string[];
	}
	interface Node {
	apdex: number;
	avgResponseTime: number;
	cpm: number;
	id: string;
	isAlarm: boolean;
	name: string;
	numOfServer: number;
	numOfServerAlarm: number;
	numOfServiceAlarm: number;
	sla: number;
	type: string;
	}

	export interface EndpointDependencyConidition {
	serviceName: string;
	endpointName: string;
	destServiceName: string;
	destEndpointName: string;
	duration: Duration;
	}

	export interface State {
	callback: any;
	calls: Call[];
	nodes: Node[];
	detectPoints: string[];
	selectedServiceCall: Call \| null;
	currentNode: any;
	currentLink: any;
	current: Option;
	mode: boolean;
	getResponseTimeTrend: number[];
	getSLATrend: number[];
	getThroughputTrend: number[];
	responsePercentile: { [key: string]: number[] };
	instanceDependency: {
	calls: Call[];
	nodes: Node[];
	};
	endpointDependency: {
	calls: Call[];
	nodes: Node[];
	};
	selectedInstanceCall: Call \| null;
	instanceDependencyMetrics: { [key: string]: any };
	endpointDependencyMetrics: { [key: string]: any };
	currentEndpointDepth: { key: number; label: string };
	queryInstanceMetricsType: string;
	serviceThroughput: { Throughput: number[] };
	serviceSLA: { SLA: number[] };
	serviceResponseTime: { ResponseTime: number[] };
	servicePercentile: { [key: string]: number[] };
	serviceApdexScore: { ApdexScore: number[] };
	topoEndpoints: any[];
	topoInstances: any[];
	}

	const PercentileItem: string[] = ['p50', 'p75', 'p90', 'p95', 'p99'];

	const initState: State = {
	callback: '',
	mode: true,
	detectPoints: [],
	selectedServiceCall: null,
	calls: [],
	nodes: [],
	currentNode: {},
	currentLink: {},
	current: {
	key: 'default',
	label: 'default',
	},
	getResponseTimeTrend: [],
	getSLATrend: [],
	getThroughputTrend: [],
	responsePercentile: {},
	instanceDependency: {
	calls: [],
	nodes: [],
	},
	endpointDependency: {
	calls: [],
	nodes: [],
	},
	selectedInstanceCall: null,
	instanceDependencyMetrics: {},
	endpointDependencyMetrics: {},
	currentEndpointDepth: { key: 2, label: '2' },
	queryInstanceMetricsType: '',
	serviceThroughput: { Throughput: [] },
	serviceSLA: { SLA: [] },
	serviceResponseTime: { ResponseTime: [] },
	servicePercentile: {
	p50: [],
	p75: [],
	p90: [],
	p95: [],
	p99: [],
	},
	serviceApdexScore: { ApdexScore: [] },
	topoEndpoints: [],
	topoInstances: [],
	};

	// getters
	const getters = {};

	// mutations
	const mutations = {
	[types.SET_CALLBACK](state: State, data: any) {
	state.callback = data;
	},
	[types.SET_MODE](state: State, data: string[]) {
	state.detectPoints = data;
	const temp = state.mode ? 'SERVER' : 'CLIENT';
	if (data.indexOf(temp) === -1) {
	state.mode = !state.mode;
	}
	},
	[types.SET_MODE_STATUS](state: State, data: boolean) {
	state.mode = data;
	},
	[types.SET_NODE](state: State, data: any) {
	state.currentNode = data;
	},
	[types.SET_LINK](state: State, data: any) {
	state.currentLink = data;
	},
	[types.SET_TOPO](state: State, data: any) {
	state.calls = data.calls;
	state.nodes = data.nodes;
	},
	[types.SET_SELECTED_CALL](state: State, data: any) {
	state.selectedServiceCall = data;
	},
	[types.SET_TOPO_RELATION](state: State, data: any) {
	state.getResponseTimeTrend = data.getResponseTimeTrend
	? data.getResponseTimeTrend.values.map((i: any) => i.value)
	: [];
	state.getSLATrend = data.getSLATrend ? data.getSLATrend.values.map((i: any) => i.value) : [];
	state.getThroughputTrend = data.getThroughputTrend ? data.getThroughputTrend.values.map((i: any) => i.value) : [];

	if (!data.getPercentile) {
	state.responsePercentile = {};
	return;
	}
	data.getPercentile.forEach((item: any, index: number) => {
	state.responsePercentile[PercentileItem[index]] = item.values.map((i: any) => i.value);
	});
	},
	[types.SET_INSTANCE_DEPENDENCY](state: State, data: any) {
	state.instanceDependency = data;
	},
	[types.SET_SELECTED_INSTANCE_CALL](state: State, data: Call) {
	state.selectedInstanceCall = data;
	},
	[types.SET_INSTANCE_DEPEDENCE_METRICS](state: State, data: any) {
	state.instanceDependencyMetrics.getResponseTimeTrend = data.getResponseTimeTrend
	? data.getResponseTimeTrend.values.map((i: any) => i.value)
	: [];
	state.instanceDependencyMetrics.getSLATrend = data.getSLATrend
	? data.getSLATrend.values.map((i: any) => i.value)
	: [];
	state.instanceDependencyMetrics.getThroughputTrend = data.getThroughputTrend
	? data.getThroughputTrend.values.map((i: any) => i.value)
	: [];
	state.instanceDependencyMetrics.percentResponse = {};
	if (!data.getPercentile) {
	return;
	}
	data.getPercentile.forEach((item: any, index: number) => {
	state.instanceDependencyMetrics.percentResponse[PercentileItem[index]] = item.values.map((i: any) => i.value);
	});
	},
	[types.SET_ENDPOINT_DEPENDENCY_METRICS](state: State, data: { [key: string]: any }) {
	state.endpointDependencyMetrics.cpm = data.endpointRelationCpm
	? data.endpointRelationCpm.values.values.map((i: any) => i.value)
	: [];
	state.endpointDependencyMetrics.respTime = data.endpointRelationRespTime
	? data.endpointRelationRespTime.values.values.map((i: any) => i.value)
	: [];
	state.endpointDependencyMetrics.sla = data.endpointRelationSla
	? data.endpointRelationSla.values.values.map((i: any) => i.value)
	: [];
	state.endpointDependencyMetrics.percentile = {};
	if (!data.endpointRelationPercentile) {
	return;
	}
	for (const item of data.endpointRelationPercentile) {
	state.endpointDependencyMetrics.percentile[PercentileItem[Number(item.label)]] = item.values.values.map(
	(i: any) => i.value,
	);
	}
	},
	[types.SET_INSTANCE_DEPEDENCE_TYPE](state: State, data: string) {
	state.queryInstanceMetricsType = data;
	},
	[types.SET_SERVICE_DETAIL](state: State, data: any) {
	state.serviceApdexScore = data.serviceApdexScore
	? data.serviceApdexScore.values.map((i: any) => Number((i.value / 10000).toFixed(2)))
	: [];
	state.serviceResponseTime = data.serviceResponseTime
	? data.serviceResponseTime.values.map((i: any) => i.value)
	: [];
	state.serviceThroughput = data.serviceThroughput ? data.serviceThroughput.values.map((i: any) => i.value) : [];
	state.serviceSLA = data.serviceSLA ? data.serviceSLA.values.map((i: any) => i.value / 100) : [];
	if (!data.servicePercentile) {
	return;
	}
	data.servicePercentile.forEach((item: any, index: number) => {
	state.servicePercentile[PercentileItem[index]] = item.values.map((i: any) => i.value);
	});
	},
	[types.SET_TOPO_ENDPOINT](state: State, data: any[]) {
	state.topoEndpoints = data;
	window.localStorage.setItem('topologyEndpoints', JSON.stringify(data));
	},
	[types.SET_TOPO_INSTANCE](state: State, data: any[]) {
	state.topoInstances = data;
	window.localStorage.setItem('topologyInstances', JSON.stringify(data));
	},
	[types.EDIT_TOPO_INSTANCE_CONFIG](state: State, params: { values: any; index: number }) {
	state.topoInstances[params.index] = { ...state.topoInstances[params.index], ...params.values };
	window.localStorage.setItem('topologyInstances', JSON.stringify(state.topoInstances));
	},
	[types.EDIT_TOPO_ENDPOINT_CONFIG](state: State, params: { values: any; index: number }) {
	state.topoEndpoints[params.index] = { ...state.topoEndpoints[params.index], ...params.values };
	window.localStorage.setItem('topologyEndpoints', JSON.stringify(state.topoEndpoints));
	},
	[types.DELETE_TOPO_ENDPOINT](state: State, index: number) {
	state.topoEndpoints.splice(index, 1);
	window.localStorage.setItem('topologyEndpoints', JSON.stringify(state.topoEndpoints));
	},
	[types.DELETE_TOPO_INSTANCE](state: State, index: number) {
	state.topoInstances.splice(index, 1);
	window.localStorage.setItem('topologyInstances', JSON.stringify(state.topoInstances));
	},
	[types.ADD_TOPO_INSTANCE_COMP](state: State) {
	const comp = {
	width: 3,
	title: 'Title',
	height: 350,
	entityType: 'ServiceInstance',
	independentSelector: false,
	metricType: 'UNKNOWN',
	};
	state.topoInstances.push(comp);
	window.localStorage.setItem('topologyInstances', JSON.stringify(state.topoInstances));
	},
	[types.ADD_TOPO_ENDPOINT_COMP](state: State) {
	const comp = {
	width: 3,
	title: 'Title',
	height: 350,
	entityType: 'Endpoint',
	independentSelector: false,
	metricType: 'UNKNOWN',
	};
	state.topoEndpoints.push(comp);
	window.localStorage.setItem('topologyEndpoints', JSON.stringify(state.topoEndpoints));
	},
	[types.SET_ENDPOINT_DEPENDENCY](state: State, data: { calls: Call[]; nodes: Node[] }) {
	state.endpointDependency = data;
	},
	[types.SET_ENDPOINT_DEPTH](state: State, data: { key: number; label: string }) {
	state.currentEndpointDepth = data;
	},
	};

	// actions
	const actions: ActionTree<State, any> = {
	GET_SERVICES(context: { commit: Commit }, params: { duration: Duration; keyword: string }) {
	if (!params.keyword) {
	params.keyword = '';
	}
	return graph
	.query('queryServices')
	.params(params)
	.then((res: AxiosResponse) => {
	return res.data.data.services \|\| [];
	});
	},
	GET_SERVICE_ENDPOINTS(context: { commit: Commit }, params: { serviceId: string; keyword: string }) {
	if (!params.serviceId) {
	return new Promise((resolve) => resolve());
	}
	if (!params.keyword) {
	params.keyword = '';
	}
	return graph
	.query('queryEndpoints')
	.params(params)
	.then((res: AxiosResponse) => {
	return res.data.data.getEndpoints \|\| [];
	});
	},
	CLEAR_TOPO(context: { commit: Commit; state: State }) {
	context.commit(types.SET_TOPO, { calls: [], nodes: [] });
	},
	CLEAR_TOPO_INFO(context: { commit: Commit; state: State }) {
	context.commit(types.SET_TOPO_RELATION, {});
	context.commit(types.SET_SELECTED_CALL, null);
	},
	GET_INSTANCE_DEPENDENCY_METRICS(
	context: { commit: Commit; state: State; dispatch: Dispatch; getters: any },
	params: any,
	) {
	if (params.mode === 'SERVER') {
	params.queryType = 'queryTopoInstanceServerInfo';
	context.dispatch('INSTANCE_RELATION_INFO', params);
	}
	if (params.mode === 'CLIENT') {
	params.queryType = 'queryTopoInstanceClientInfo';
	context.dispatch('INSTANCE_RELATION_INFO', params);
	}
	},
	GET_TOPO_SERVICE_INFO(context: { commit: Commit; state: State }, params: { id: string; duration: Duration }) {
	if (!params.id) {
	return;
	}
	return graph
	.query('queryTopoServiceInfo')
	.params({
	id: params.id,
	duration: params.duration,
	})
	.then((res: AxiosResponse) => {
	if (!res.data.data) {
	return;
	}
	context.commit('SET_TOPO_RELATION', res.data.data);
	context.commit(types.SET_SELECTED_CALL, params);
	});
	},
	GET_TOPO_CLIENT_INFO(context: { commit: Commit; state: State }, params: any) {
	return graph
	.query('queryTopoClientInfo')
	.params(params)
	.then((res: AxiosResponse) => {
	if (!res.data.data) {
	return;
	}
	context.commit('SET_TOPO_RELATION', res.data.data);
	context.commit(types.SET_SELECTED_CALL, params);
	});
	},
	GET_TOPO_SERVICE_DETAIL(
	context: { commit: Commit; state: State },
	params: { serviceId: string; duration: Duration },
	) {
	return graph
	.query('queryTopoServiceDetail')
	.params({
	serviceId: params.serviceId,
	duration: params.duration,
	})
	.then((res: AxiosResponse) => {
	if (!res.data.data) {
	return;
	}
	context.commit('SET_SERVICE_DETAIL', res.data.data);
	});
	},
	GET_TOPO(context: { commit: Commit; state: State }, params: any) {
	let query = 'queryTopo';
	if (params.serviceId) {
	query = 'queryServiceTopo';
	}
	if (params.serviceIds) {
	query = 'queryServicesTopo';
	}
	return graph
	.query(query)
	.params(params)
	.then((res: AxiosResponse) => {
	if (res.data.errors) {
	context.commit(types.SET_TOPO, { calls: [], nodes: [] });
	return;
	}
	const calls = res.data.data.topo.calls;
	const nodes = res.data.data.topo.nodes;
	const ids = nodes.map((i: any) => i.id);
	const idsC = calls.filter((i: any) => i.detectPoints.indexOf('CLIENT') !== -1).map((b: any) => b.id);
	const idsS = calls.filter((i: any) => i.detectPoints.indexOf('CLIENT') === -1).map((b: any) => b.id);
	return graph
	.query('queryTopoInfo')
	.params({ ...params, ids, idsC, idsS })
	.then((info: AxiosResponse) => {
	const resInfo = info.data.data;
	if (!resInfo.sla) {
	return context.commit(types.SET_TOPO, { calls, nodes });
	}
	for (let i = 0; i < resInfo.sla.values.length; i += 1) {
	for (let j = 0; j < nodes.length; j += 1) {
	if (nodes[j].id === resInfo.sla.values[i].id) {
	nodes[j] = {
	...nodes[j],
	isGroupActive: true,
	sla: resInfo.sla.values[i].value ? resInfo.sla.values[i].value / 100 : -1,
	cpm: resInfo.nodeCpm.values[i] ? resInfo.nodeCpm.values[i].value : -1,
	latency: resInfo.nodeLatency.values[i] ? resInfo.nodeLatency.values[i].value : -1,
	};
	}
	}
	}
	if (!resInfo.cpmC) {
	return context.commit(types.SET_TOPO, { calls, nodes });
	}
	for (let i = 0; i < resInfo.cpmC.values.length; i += 1) {
	for (let j = 0; j < calls.length; j += 1) {
	if (calls[j].id === resInfo.cpmC.values[i].id) {
	calls[j] = {
	...calls[j],
	isGroupActive: true,
	cpm: resInfo.cpmC.values[i] ? resInfo.cpmC.values[i].value : '',
	latency: resInfo.latencyC.values[i] ? resInfo.latencyC.values[i].value : '',
	};
	}
	}
	}
	if (!resInfo.cpmS) {
	return context.commit(types.SET_TOPO, { calls, nodes });
	}
	for (let i = 0; i < resInfo.cpmS.values.length; i += 1) {
	for (let j = 0; j < calls.length; j += 1) {
	if (calls[j].id === resInfo.cpmS.values[i].id) {
	calls[j] = {
	...calls[j],
	cpm: resInfo.cpmS.values[i] ? resInfo.cpmS.values[i].value : '',
	latency: resInfo.latencyS.values[i] ? resInfo.latencyS.values[i].value : '',
	};
	}
	}
	}
	context.commit(types.SET_TOPO, { calls, nodes });
	});
	});
	},
	// todo sync
	GET_ALL_ENDPOINT_DEPENDENCY(
	context: { commit: Commit; state: State; dispatch: Dispatch },
	params: { endpointIds: string[]; duration: Duration },
	) {
	context.dispatch('GET_ENDPOINT_TOPO', params).then((res) => {
	if (context.state.currentEndpointDepth.key > 1) {
	const endpointIds = res.nodes.map((item: Node) => item.id);

	context.dispatch('GET_ENDPOINT_TOPO', { endpointIds, duration: params.duration }).then((json) => {
	if (context.state.currentEndpointDepth.key > 2) {
	const ids = json.nodes.map((item: Node) => item.id);

	context.dispatch('GET_ENDPOINT_TOPO', { endpointIds: ids, duration: params.duration }).then((topo) => {
	if (context.state.currentEndpointDepth.key > 3) {
	const endpoints = topo.nodes.map((item: Node) => item.id);
	context
	.dispatch('GET_ENDPOINT_TOPO', { endpointIds: endpoints, duration: params.duration })
	.then((data) => {
	if (context.state.currentEndpointDepth.key > 4) {
	context
	.dispatch('GET_ENDPOINT_TOPO', { endpointIds: endpoints, duration: params.duration })
	.then((topos) => {
	context.commit(types.SET_ENDPOINT_DEPENDENCY, topos);
	});
	} else {
	context.commit(types.SET_ENDPOINT_DEPENDENCY, data);
	}
	});
	} else {
	context.commit(types.SET_ENDPOINT_DEPENDENCY, topo);
	}
	});
	} else {
	context.commit(types.SET_ENDPOINT_DEPENDENCY, json);
	}
	});
	} else {
	context.commit(types.SET_ENDPOINT_DEPENDENCY, res);
	}
	});
	},
	GET_ENDPOINT_TOPO(context: { commit: Commit; state: State }, params: { endpointIds: string[]; duration: Duration }) {
	const variables = ['$duration: Duration!'];
	const fragment = params.endpointIds.map((id: string, index: number) => {
	return `endpointTopology${index}: getEndpointDependencies(endpointId: "${id}", duration: $duration) {
	nodes {
	id
	name
	serviceId
	serviceName
	type
	isReal
	}
	calls {
	id
	source
	target
	detectPoints
	}
	}`;
	});
	const querys = `query queryData(${variables}) {${fragment}}`;
	return axios
	.post('/graphql', { query: querys, variables: { duration: params.duration } }, { cancelToken: cancelToken() })
	.then((res: AxiosResponse) => {
	if (res.data.errors) {
	context.commit(types.SET_ENDPOINT_DEPENDENCY, { calls: [], nodes: [] });
	return;
	}
	const topo = res.data.data;
	const calls = [] as any;
	let nodes = [] as any;
	for (const key of Object.keys(topo)) {
	calls.push(...topo[key].calls);
	nodes.push(...topo[key].nodes);
	}
	const obj = {} as any;
	nodes = nodes.reduce((prev: Node[], next: Node) => {
	if (!obj[next.id]) {
	obj[next.id] = true;
	prev.push(next);
	}
	return prev;
	}, []);
	const queryVariables = ['$duration: Duration!'];
	const fragments = calls
	.map((call: Call & EndpointDependencyConidition, index: number) => {
	let source = {} as any;
	let target = {} as any;
	for (const node of nodes) {
	if (node.id === call.source) {
	source = node;
	call.serviceName = node.serviceName;
	call.endpointName = node.name;
	}
	if (node.id === call.target) {
	target = node;
	call.destServiceName = node.serviceName;
	call.destEndpointName = node.name;
	}
	}
	return `cpm_${index}: readMetricsValue(condition: {
	name: "endpoint_relation_cpm"
	entity: {
	scope: EndpointRelation
	serviceName: "${source.serviceName}"
	normal: true
	endpointName: "${source.name}"
	destNormal: true
	destServiceName: "${target.serviceName}"
	destEndpointName: "${target.name}"
	}
	}, duration: $duration)`;
	})
	.join(' ');
	const query = `query queryData(${queryVariables}) {${fragments}}`;
	return axios
	.post('/graphql', { query, variables: { duration: params.duration } }, { cancelToken: cancelToken() })
	.then((json: AxiosResponse<any>) => {
	if (json.data.errors) {
	context.commit(types.SET_ENDPOINT_DEPENDENCY, { calls: [], nodes: [] });
	return;
	}
	const cpms = json.data.data;
	const keys = Object.keys(cpms);
	for (const key of keys) {
	const index = Number(key.split('_')[1]);
	calls[index].value = cpms[key] \|\| 0.01;
	}
	return { calls, nodes };
	})
	.catch(() => {
	context.commit(types.SET_ENDPOINT_DEPENDENCY, { calls: [], nodes: [] });
	});
	});
	},
	async GET_TOPO_INSTANCE_DEPENDENCY(
	context: { commit: Commit; state: State },
	params: {
	clientServiceId: string;
	serverServiceId: string;
	duration: Duration;
	},
	) {
	graph
	.query('queryTopoInstanceDependency')
	.params(params)
	.then((res: AxiosResponse) => {
	if (!(res.data && res.data.data)) {
	return;
	}
	const serverIdsC = [] as string[];
	const clientIdsC = [] as string[];
	const topoCalls = res.data.data.topo.calls;
	for (const call of topoCalls) {
	if (call.detectPoints.includes('CLIENT')) {
	clientIdsC.push(call.id);
	} else {
	serverIdsC.push(call.id);
	}
	}
	graph
	.query('queryDependencyInstanceClientMetric')
	.params({
	idsC: clientIdsC,
	duration: params.duration,
	})
	.then((json: AxiosResponse) => {
	const clientCalls = [] as string[];
	for (const call of topoCalls) {
	for (const cpm of json.data.data.cpmC.values) {
	if (cpm.id === call.id) {
	clientCalls.push({
	...call,
	...cpm,
	});
	}
	}
	}
	graph
	.query('queryDependencyInstanceServerMetric')
	.params({
	idsC: serverIdsC,
	duration: params.duration,
	})
	.then((jsonResp: AxiosResponse) => {
	const serverCalls = [] as string[];
	for (const call of topoCalls) {
	for (const cpm of jsonResp.data.data.cpmC.values) {
	if (cpm.id === call.id) {
	serverCalls.push({
	...call,
	...cpm,
	});
	}
	}
	}
	const data = {
	nodes: res.data.data.topo.nodes,
	calls: [...serverCalls, ...clientCalls],
	};
	context.commit(types.SET_INSTANCE_DEPENDENCY, data);
	});
	});
	});
	},
	INSTANCE_RELATION_INFO(
	context: { commit: Commit; state: State },
	params: Call & { mode: string; queryType: string; durationTime: Duration },
	) {
	graph
	.query(params.queryType)
	.params({
	id: params.id,
	duration: params.durationTime,
	})
	.then((res: AxiosResponse) => {
	if (!(res.data && res.data.data)) {
	return;
	}
	context.commit(types.SET_SELECTED_INSTANCE_CALL, params);
	context.commit(types.SET_INSTANCE_DEPEDENCE_TYPE, params.mode);
	context.commit(types.SET_INSTANCE_DEPEDENCE_METRICS, res.data.data);
	});
	},
	GET_ENDPOINT_DEPENDENCY_METRICS(context: { commit: Commit; state: State }, params: EndpointDependencyConidition) {
	return graph
	.query('queryTopoEndpointDependencyMetrics')
	.params(params)
	.then((res: AxiosResponse) => {
	if (!(res.data && res.data.data)) {
	return;
	}
	context.commit(types.SET_ENDPOINT_DEPENDENCY_METRICS, res.data.data);
	});
	},
	};

	export default {
	namespaced: true,
	state: initState,
	getters,
	actions,
	mutations,
	};