dataset.ts

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

import { Page } from 'model/common.model';
import { Dataset, IDatasetFilter, AccessionIdentifier } from 'model/dataset.model';
import { Creator } from 'model/creator.model';
import { Descriptor } from 'model/descriptor.model';
import { Location } from 'model/location.model';
import { RepositoryFile } from 'model/repositoryFile.model';
import { DatasetService } from 'service/DatasetService';
import { CreatorService } from 'service/CreatorService';
import { LocationService } from 'service/LocationService';
import { RepositoryFileService } from 'service/RepositoryFileService';
import {log} from 'utilities/debug';

import { CREATE_DATASET, RECEIVE_DATASET, RECEIVE_DATASET_PAGE, ADD_CREATOR_TO_DATASET, REMOVE_CREATOR_FROM_DATASET, UPDATE_DATASET_CREATOR, ADD_LOCATION, RECEIVE_LOCATION, REMOVE_LOCATION } from 'constants/datasets';
import {addFilterCode} from 'actions/filterCode';
import steps from 'ui/pages/dataset/dataset-stepper/steps';
import { navigateTo } from 'actions/navigation';
import * as _ from 'lodash';

const receiveDataset = (dataset: Dataset) => ({
    type: RECEIVE_DATASET, payload: dataset,
});

const receiveDatasetPage = (paged: Page<Dataset>, page, results, sortBy, filter: IDatasetFilter, order) => ({
    type: RECEIVE_DATASET_PAGE,
    payload: { paged, query: { page, results, sortBy, filter, order } },
});

function showDataset(uuid: string) {
  return (dispatch) => {
    dispatch(push(`/datasets/${uuid}`));
  };
}

function editDataset(uuid: string) {
  return (dispatch) => {
    dispatch(push(`/datasets/${uuid}/edit`));
  };
}

function listMyDatasets(page?, results?, sortBy?, filter?: string | IDatasetFilter, order?) {
  return (dispatch, getState) => {
    const token = getState().login.access_token;

    return DatasetService.listMyDatasets(token, page, results, sortBy, filter, order)
      .then((paged) => {
        dispatch(receiveDatasetPage(paged, page, results, sortBy, paged.filter, order));
        return dispatch(addFilterCode(paged.filterCode, paged.filter));
      })
      .catch((error) => {
        log('Error', error);
      });
  };
}

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

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

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

    return DatasetService.listDatasets(token, page, results, sortBy, filter, order)
      .then((paged) => {
        dispatch(receiveDatasetPage(paged, page, results, sortBy, filter, order));
        return dispatch(addFilterCode(paged.filterCode, paged.filter));
      })
      .catch((error) => {
        log('Error', error);
      });
  };
}

function listDatasetsByCodeRequest(page?, results?, sortBy?, filterCode?, order?) {
  return (dispatch, getState) => {
    const token = getState().login.access_token;

    return DatasetService.listDatasetsByCode(token, page, results, sortBy, filterCode, order)
      .then((paged) => {
        dispatch(receiveDatasetPage(paged, page, results, sortBy, paged.filter, order));
        return dispatch(addFilterCode(paged.filterCode, paged.filter));
      })
      .catch((error) => {
        log('Error', error);
      });
  };
}

function loadDataset(uuid: string) {
  return (dispatch, getState) => {
    const token = getState().login.access_token;

    return DatasetService.getDataset(token, uuid)
      .then((dataset) => {
        dispatch(receiveDataset(dataset));
      })
      .catch((error) => {
        log('Error', error);
      });
  };
}

// Create a new descriptor
const createDataset = () => (dispatch) => {
  dispatch({ type: CREATE_DATASET });
  return dispatch(push(`/datasets/edit`));
};

const saveDataset = (dataset: Dataset) => (dispatch, getState) => {

    const needToRedirect: boolean = !(dataset.version && dataset.uuid);

    if (_.isEqual({...getState().datasets.currentDataset}, {...dataset})) {
        return;
    }

    // remove normalized data here
    const data = new Dataset({
      ...dataset,
      repositoryFiles: [],
      creators: [],
      locations: [],
      descriptors: [],
    });

    const token = getState().login.access_token;

    return DatasetService.saveDataset(token, data)
      .then((saved) => {
        dispatch(receiveDataset(saved));
        if (needToRedirect) {
            dispatch(gotoNextStep(saved));
        }
      }).catch((error) => {
        log('Save error', error);
      });
};

function gotoNextStep(dataset: Dataset) {
    return (dispatch, getState) => {
        const link = window.location.pathname.split('/').pop();
        const stepId = steps.find((e) => e.link.endsWith(link)).id;
        const path = steps.find((e) => e.id === (stepId + 1)).link;
        dispatch(navigateTo(`/datasets/${dataset.uuid}/${path}`));
    };
}

function publishDataset(dataset: Dataset, published: boolean = true) {
  return (dispatch, getState) => {
    const token = getState().login.access_token;

    return DatasetService.publishDataset(token, dataset, published)
      .then((saved) => {
        dispatch(receiveDataset(saved));
        dispatch(showDataset(saved.uuid));
      }).catch((error) => {
        log('Publish error', error);
      });
  };
}

function deleteDataset(dataset: Dataset) {
  return (dispatch, getState) => {
    const token = getState().login.access_token;

    return DatasetService.deleteDataset(token, dataset)
      .then((saved) => {
        dispatch(receiveDataset(saved));
        // dispatch(showDataset(saved.uuid));
      }).catch((error) => {
        log('Delete error', error);
      });
  };
}

function updateDatasetAccessionIdentifiers(dataset: Dataset, accessionIdentifiers: AccessionIdentifier[]) {
  return (dispatch, getState) => {
    const token = getState().login.access_token;

    return DatasetService.updateAccessionIdentifiers(token, dataset, accessionIdentifiers)
      .then((saved) => {
        dispatch(receiveDataset(saved));
      }).catch((error) => {
        log('Publish error', error);
      });
  };
}

function addDescriptorsToDatasetRequest(dataset: Dataset, descriptor: Descriptor) {

  return (dispatch, getState) => {
    const token = getState().login.access_token;

    return DatasetService.addDescriptorsToDataset(token, dataset, [descriptor.uuid])
      .then((saved) => {
        dispatch(receiveDataset(saved));
      }).catch((error) => {
        log('Add error', error);
      });
  };
}

export const setDescriptorsToDatasetRequest = (dataset: Dataset, descriptorUuids: string[]) => (dispatch, getState) => {
  return DatasetService.setDescriptorsToDataset(getState().login.access_token, dataset, descriptorUuids)
    .then((saved) => {
      dispatch(receiveDataset(saved));
    }).catch((error) => {
      log('Add error', error);
    });
};

function removeDescriptorsFromDatasetRequest(dataset: Dataset, descriptor: Descriptor) {
  return (dispatch, getState) => {
    const token = getState().login.access_token;

    return DatasetService.removeDescriptorsFromDataset(token, dataset, [descriptor.uuid])
      .then((saved) => {
        dispatch(receiveDataset(saved));
      }).catch((error) => {
        log('Delete error', error);
      });
  };
}

export {
  listMyDatasets, listDatasetsRequest, loadDataset, createDataset, saveDataset, deleteDataset,
  publishDataset, receiveDataset, editDataset, showDataset, updateDatasetAccessionIdentifiers,
  addDescriptorsToDatasetRequest, removeDescriptorsFromDatasetRequest,
};

export const uploadRepositoryFileRequest = (datasetUUID: string, file: File) => (dispatch, getState) => {
    const token = getState().login.access_token;

    return RepositoryFileService.uploadRepositoryFile(token, datasetUUID, file)
        .then((dataset) => {
            dispatch(receiveDataset(dataset));
        }).catch((error) => {
            log('Save error', error);
        });
};

export const updateRepositoryFileRequest = (datasetUUID: string, repositoryfile: RepositoryFile) => (dispatch, getState) => {
    const token = getState().login.access_token;

    return RepositoryFileService.updateRepositoryFile(token, datasetUUID, repositoryfile)
        .then((dataset) => {
            dispatch(receiveDataset(dataset));
        }).catch((error) => {
            log('Save error', error);
        });
};

export const deleteRepositoryFileRequest = (datasetUUID: string, uuid: string) => (dispatch, getState) => {
  const token = getState().login.access_token;

  return RepositoryFileService.deleteRepositoryFile(token, datasetUUID, uuid)
    .then((dataset) => {
      dispatch(receiveDataset(dataset));
    }).catch((error) => {
      log('Delete error', error);
    });
};

function addCreatorToDataset(creator: Creator, uuid: string) {
  return {
    type: ADD_CREATOR_TO_DATASET,
    payload: {
      creator,
      datasetUUID: uuid,
    },
  };
}

// FIXME No uuid param required, currentDataset is available in state
function createDatasetCreator(uuid: string) {
  return (dispatch, getState) => {
    log('createCreator');
    return CreatorService.createCreator(getState().login.access_token, uuid)
      .then((obj) => {
        dispatch(addCreatorToDataset(obj, uuid));
      }).catch((error) => {
        log('Create creator error', error);
      });
  };
}

function updateCreator(creator: Creator) {
    return {
        type: UPDATE_DATASET_CREATOR,
        payload : {
            creator,
        },
    };
}

function updateCreatorRequest(uuid: string, creator: Creator) {
    return (dispatch, getState) => {
        const token = getState().login.access_token;
        return CreatorService.updateCreator(token, uuid, creator)
            .then((obj) => {
                dispatch(updateCreator(obj));
            }).catch((error) => {
                log('Update creator error', error);
            });
    };
}

function removeCreator(creator: Creator, uuid: string) {
    return {
        type: REMOVE_CREATOR_FROM_DATASET,
        payload : {
            creator,
            datasetUUID: uuid,
        },
    };
}

function deleteCreatorRequest(uuid: string, creator: Creator) {
    return (dispatch, getState) => {
        const token = getState().login.access_token;
        return CreatorService.deleteCreator(token, uuid, creator)
            .then((obj) => {
                dispatch(removeCreator(obj, uuid));
            }).catch((error) => {
                log('Delete creator error', error);
            });
    };
}

export { createDatasetCreator, deleteCreatorRequest, updateCreatorRequest, listDatasetsByCodeRequest };

//
// Dataset: Timing and Location

function addLocation(datasetUUID: string, location: Location) {
  return {
    type: ADD_LOCATION,
    payload: {
      datasetUUID,
      location,
    },
  };
}

function createLocationRequest(datasetUUID: string) {
  const location = new Location({});

  return (dispatch, getState) => {
    const token = getState().login.access_token;

    return LocationService.saveLocation(token, datasetUUID, location)
      .then((saved) => {
        dispatch(addLocation(datasetUUID, saved));
      }).catch((error) => {
        log('Save error', error);
      });
  };
}

function receiveLocation(location: Location) {
  return {
    type: RECEIVE_LOCATION,
    payload: {
      location,
    },
  };
}

function updateLocationRequest(datasetUUID: string, location: Location) {

  return (dispatch, getState) => {
    const token = getState().login.access_token;

    return LocationService.saveLocation(token, datasetUUID, location)
      .then((saved) => {
        dispatch(receiveLocation(saved));
      }).catch((error) => {
        log('Save error', error);
      });
  };
}

function deleteLocation(datasetUUID: string, location: Location) {
  return {
    type: REMOVE_LOCATION,
    payload: {
      datasetUUID,
      location,
    },
  };
}

function deleteLocationRequest(datasetUUID: string, location: Location) {
  return (dispatch, getState) => {
    const token = getState().login.access_token;

    return LocationService.deleteLocation(token, datasetUUID, location)
      .then((saved) => {
        dispatch(deleteLocation(datasetUUID, saved));
      }).catch((error) => {
        log('Delete error', error);
      });
  };
}

export { createLocationRequest, updateLocationRequest, deleteLocationRequest, receiveLocation };