descriptorList.ts

import { push } from 'react-router-redux';

import { DescriptorListService } from 'service/DescriptorListService';
import { DescriptorList, Descriptor, IDescriptorListFilter } from 'model/descriptor.model';
import { Page } from 'model/common.model';
import {log} from 'utilities/debug';
import { addFilterCode } from 'actions/filterCode';
import {cleanFilters} from 'utilities';

import {
  GET_DESCRIPTORLIST, RECEIVE_DESCRIPTORLIST,
  CREATE_DESCRIPTORLIST,
  LIST_DESCRIPTORLISTS, RECEIVE_DESCRIPTORLISTS,
} from 'constants/descriptors';

const receiveDescriptorList = (descriptorList: DescriptorList) => ({
  type: RECEIVE_DESCRIPTORLIST,
  payload: descriptorList,
});

const receiveDescriptorLists = (paged: Page<DescriptorList>, page, results, sortBy, filter: IDescriptorListFilter, order) => ({
  type: RECEIVE_DESCRIPTORLISTS,
  payload: { paged, query: { page, results, sortBy, filter, order } },
});

const loadingDescriptorLists = (page, results, sortBy, filter, order) => ({
  type: LIST_DESCRIPTORLISTS,
  payload: { page, results, sortBy, filter, order },
});

// Just load a descriptor list
export const loadDescriptorList = (uuid: string, success?: (d) => any, fail?: (error) => any) => (dispatch, getState) => {
  log('Loading descriptor list', uuid);
  const token = getState().login.access_token;

  dispatch({ type: GET_DESCRIPTORLIST, payload: uuid });

  return DescriptorListService.loadDescriptorList(token, uuid)
    // receive the current descriptor list
    // // Demo long load
    // .then((descriptorList) => {
    //   await setTimeout(() => dispatch(receiveDescriptorList(descriptorList)), 10000);
    .then((descriptorList) => {
      if (success) {
        return success(descriptorList);
      }
      dispatch(receiveDescriptorList(descriptorList));
    }).catch((error) => {
      log(`No descriptor list with uuid ${uuid}`, error);
      if (fail) {
        return fail(error);
      }
    });
};

// List current user's descriptor lists
export const listMyDescriptorLists = (page?, results?, sortBy?, filter?: string | IDescriptorListFilter, order?) => (dispatch, getState) => {
  log('Loading my descriptor lists');
  const token = getState().login.access_token;

  dispatch(loadingDescriptorLists(page, results, sortBy, filter, order));

  return DescriptorListService.listMyDescriptorLists(token, page, results, sortBy, filter, order)
    // receive the current descriptor list
    .then((descriptorLists) => {
      dispatch(receiveDescriptorLists(descriptorLists, page, results, sortBy, descriptorLists.filter, order));
      return dispatch(addFilterCode(descriptorLists.filterCode, descriptorLists.filter));
    }).catch((error) => {
      log(`Error loading my descriptor lists`, error);
    });
};

export const promiseListDescriptorLists = (page?, results?, sortBy?, filter?, order?) => (dispatch, getState) => {
    const token = getState().login.access_token;

    return DescriptorListService.listDescriptorLists(token, page, results, sortBy, filter, order)
        .catch((error) => {
            log('Error', error);
            return error;
        });
};

export const promiseDescriptorList = (uuid) => (dispatch, getState) => {
    const token = getState().login.access_token;

    return DescriptorListService.loadDescriptorList(token, uuid)
        .catch((error) => {
            log('Error', error);
            return error;
        });
};

export const autocomplete = (term: string = '') => (dispatch, getState) => {
    const token = getState().login.access_token;

    return DescriptorListService.autocomplete(token, term)
        .catch((error) => {
            log('Error', error);
        });
};

// List published descriptor lists
export const listDescriptorLists = (page?, results?, sortBy?, filter?, order?) => (dispatch, getState) => {
  log('Loading published descriptor lists');
  const token = getState().login.access_token;

  dispatch(loadingDescriptorLists(page, results, sortBy, filter, order));

  return DescriptorListService.listDescriptorLists(token, page, results, sortBy, filter, order)
    // receive the current descriptor list
    .then((paged) => {
      dispatch(receiveDescriptorLists(paged, page, results, sortBy, filter, order));
      return dispatch(addFilterCode(paged.filterCode, paged.filter));
    }).catch((error) => {
      log(`Error loading published descriptor lists`, error);
    });
};

// List published descriptor lists by code
export const listDescriptorListsByCode = (page?, results?, sortBy?, filterCode?, order?) => (dispatch, getState) => {
  log('Loading published descriptor lists by code');
  const token = getState().login.access_token;

  return DescriptorListService.listDescriptorListsByCode(token, page, results, sortBy, filterCode, order)
  // receive the current descriptor list
    .then((paged) => {
      const filter = cleanFilters(paged.filter, ['published']);
      dispatch(receiveDescriptorLists(paged, page, results, sortBy, filter as IDescriptorListFilter, order));
      return dispatch(addFilterCode(paged.filterCode, paged.filter));
    }).catch((error) => {
      log(`Error loading published descriptor lists`, error);
    });
};

// Create a new descriptor list
export const createDescriptorList = () => (dispatch) => {
  dispatch({ type: CREATE_DESCRIPTORLIST });
  return dispatch(push(`/descriptorlists/edit`));
};

// Edit an existing descriptor list
export const editDescriptorList = (uuid: string) => (dispatch, getState) => {
  return dispatch(loadDescriptorList(uuid))
    .then((descriptorList) => dispatch(push(`/descriptorlists/${descriptorList.uuid}/edit`)));
};

// Save the descriptor list
export const saveDescriptorList = (descriptorList: DescriptorList) => (dispatch, getState) => {

  log('Saving descriptor list', descriptorList);
  const createOrSave = descriptorList.version ? DescriptorListService.updateDescriptorList : DescriptorListService.createDescriptorList;

  return createOrSave(getState().login.access_token, descriptorList)
    // when response is back
    .then((descriptorList) => {
      // receive the updated descriptor list
      dispatch(receiveDescriptorList(descriptorList));
    }).catch((error) => {
      log(`Error saving descriptor list`, error, descriptorList);
    });
};

// Publish the descriptor list
export const deleteDescriptorList = (descriptorList: DescriptorList) => (dispatch, getState) => {
  return DescriptorListService.deleteDescriptorList(getState().login.access_token, descriptorList)
    .then((descriptorList) => {
      // receive updates
      dispatch(receiveDescriptorList(descriptorList));
    });
};

// Publish the descriptor list
export const publishDescriptorList = (descriptorList: DescriptorList, published?: boolean) => (dispatch, getState) => {
  return DescriptorListService.publishDescriptorList(getState().login.access_token, descriptorList, published)
    .then((descriptorList) => {
      // receive updates
      dispatch(receiveDescriptorList(descriptorList));
      // go to the published descriptor list page
      dispatch(push(`/descriptorlists/${descriptorList.uuid}`));
    });
};

// Add a descriptor to the descriptor list
export const addDescriptorToDescriptorList = (descriptorList: DescriptorList, descriptor: Descriptor) => (dispatch, getState) => {
  return DescriptorListService.addDescriptor(getState().login.access_token, descriptorList, [ descriptor.uuid ])
    .then((descriptorList) => {
      // receive updates
      dispatch(receiveDescriptorList(descriptorList));
    });
};

// Add a descriptor to the descriptor list
export const addDescriptorsToDescriptorList = (descriptorList: DescriptorList, descriptorUuids: string[]) => (dispatch, getState) => {
  return DescriptorListService.addDescriptor(getState().login.access_token, descriptorList, descriptorUuids)
    .then((descriptorList) => {
      // receive updates
      dispatch(receiveDescriptorList(descriptorList));
    });
};

// Add a descriptor to the descriptor list
export const setDescriptorsToDescriptorList = (descriptorList: DescriptorList, descriptorUuids: string[]) => (dispatch, getState) => {
    return DescriptorListService.setDescriptors(getState().login.access_token, descriptorList, descriptorUuids)
        .then((descriptorList) => {
            // receive updates
            dispatch(receiveDescriptorList(descriptorList));
        });
};

// Remove a descriptor to the descriptor list
export const removeDescriptorFromDescriptorList = (descriptorList: DescriptorList, descriptor: Descriptor) => (dispatch, getState) => {
  return DescriptorListService.removeDescriptor(getState().login.access_token, descriptorList, [ descriptor.uuid ])
    .then((descriptorList) => {
      // receive updates
      dispatch(receiveDescriptorList(descriptorList));
    });
};