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/descriptors.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 { 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';

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?, 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, filter, order));
      })
      .catch((error) => {
        console.log('Error', 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) => {
        return dispatch(receiveDatasetPage(paged, page, results, sortBy, filter, order));
      })
      .catch((error) => {
        console.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) => {
        console.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) => {

    // 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));
      }).catch((error) => {
        console.log('Save error', error);
      });
};

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) => {
        console.log('Publish 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) => {
        console.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) => {
        console.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) => {
        console.log('Delete error', error);
      });
  };
}

export {
  listMyDatasets, listDatasetsRequest, loadDataset, createDataset, saveDataset,
  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) => {
            console.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) => {
            console.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) => {
      console.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) => {
    console.log('createCreator');
    return CreatorService.createCreator(getState().login.access_token, uuid)
      .then((obj) => {
        dispatch(addCreatorToDataset(obj, uuid));
      }).catch((error) => {
        console.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) => {
                console.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) => {
                console.log('Delete creator error', error);
            });
    };
}

export { createDatasetCreator, deleteCreatorRequest, updateCreatorRequest };

//
// 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) => {
        console.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) => {
        console.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) => {
        console.log('Delete error', error);
      });
  };
}

export { createLocationRequest, updateLocationRequest, deleteLocationRequest, receiveLocation };