superset-frontend/packages/superset-frontend/src/dashboard/actions/sliceEntities.js

/**
 * 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.
 */
/* eslint camelcase: 0 */
import { t, SupersetClient } from '@superset-ui/core';
import rison from 'rison';

import { addDangerToast } from 'src/messageToasts/actions';
import { getDatasourceParameter } from 'src/modules/utils';
import { getClientErrorObject } from 'src/utils/getClientErrorObject';

export const SET_ALL_SLICES = 'SET_ALL_SLICES';
export function setAllSlices(slices) {
  return { type: SET_ALL_SLICES, payload: { slices } };
}

export const FETCH_ALL_SLICES_STARTED = 'FETCH_ALL_SLICES_STARTED';
export function fetchAllSlicesStarted() {
  return { type: FETCH_ALL_SLICES_STARTED };
}

export const FETCH_ALL_SLICES_FAILED = 'FETCH_ALL_SLICES_FAILED';
export function fetchAllSlicesFailed(error) {
  return { type: FETCH_ALL_SLICES_FAILED, payload: { error } };
}

const FETCH_SLICES_PAGE_SIZE = 200;
export function fetchAllSlices(userId) {
  return (dispatch, getState) => {
    const { sliceEntities } = getState();
    if (sliceEntities.lastUpdated === 0) {
      dispatch(fetchAllSlicesStarted());

      return SupersetClient.get({
        endpoint: `/api/v1/chart/?q=${rison.encode({
          columns: [
            'changed_on_delta_humanized',
            'changed_on_utc',
            'datasource_id',
            'datasource_type',
            'datasource_url',
            'datasource_name_text',
            'description_markeddown',
            'description',
            'edit_url',
            'id',
            'params',
            'slice_name',
            'url',
            'viz_type',
          ],
          filters: [{ col: 'owners', opr: 'rel_m_m', value: userId }],
          page_size: FETCH_SLICES_PAGE_SIZE,
          order_column: 'changed_on_delta_humanized',
          order_direction: 'desc',
        })}`,
      })
        .then(({ json }) => {
          const slices = {};
          json.result.forEach(slice => {
            let form_data = JSON.parse(slice.params);
            form_data = {
              ...form_data,
              // force using datasource stored in relational table prop
              datasource:
                getDatasourceParameter(
                  slice.datasource_id,
                  slice.datasource_type,
                ) || form_data.datasource,
            };
            slices[slice.id] = {
              slice_id: slice.id,
              slice_url: slice.url,
              slice_name: slice.slice_name,
              edit_url: slice.edit_url,
              form_data,
              datasource_name: slice.datasource_name_text,
              datasource_url: slice.datasource_url,
              datasource_id: slice.datasource_id,
              datasource_type: slice.datasource_type,
              changed_on: new Date(slice.changed_on_utc).getTime(),
              description: slice.description,
              description_markdown: slice.description_markeddown,
              viz_type: slice.viz_type,
              modified: slice.changed_on_delta_humanized,
              changed_on_humanized: slice.changed_on_delta_humanized,
            };
          });

          return dispatch(setAllSlices(slices));
        })
        .catch(
          errorResponse =>
            console.log(errorResponse) ||
            getClientErrorObject(errorResponse).then(({ error }) => {
              dispatch(
                fetchAllSlicesFailed(
                  error || t('Could not fetch all saved charts'),
                ),
              );
              dispatch(
                addDangerToast(
                  t('Sorry there was an error fetching saved charts: ') + error,
                ),
              );
            }),
        );
    }

    return dispatch(setAllSlices(sliceEntities.slices));
  };
}