public.ts

/**
 * This is a top-level group for actions in /accessions/* routes.
 */
import * as _ from 'lodash';
import navigateTo from 'actions/navigation';
import {filterCodeToUrl} from 'actions/filterCode';
import FilteredPage, { IPageRequest } from 'model/FilteredPage';
import Accession from 'model/accession/Accession';
import AccessionFilter from 'model/accession/AccessionFilter';
import AccessionMapInfo from 'model/accession/AccessionMapInfo';
import MapLayer from 'model/genesys/MapTileLayer';

import {
  RECEIVE_ACCESSION,
  RECEIVE_ACCESSION_OVERVIEW,
  RECEIVE_ACCESSION_MAPINFO,
  RECEIVE_ACCESSION_AUDIT_LOG,
  RECEIVE_TILE_LAYER,
  APPEND_ACCESSIONS,
  APPEND_ACCESSIONS_WITH_SUGGESTIONS,
} from 'accessions/constants';
import AccessionService from 'service/genesys/AccessionService';
import ClimateService from 'service/genesys/ClimateService';
import { showSnackbar } from 'actions/snackbar';
import Page from 'model/Page';
import TileClimate from 'model/genesys/TileClimate';
import {createApiCaller, createPureApiCaller} from 'actions/ApiCall';
import ApiCall from 'model/ApiCall';

const receiveAccessionMapInfo = (apiCall: ApiCall<any>) => ({
  type: RECEIVE_ACCESSION_MAPINFO,
  payload: { apiCall },
});

// Wrapped API calls
const apiListAccessions = createApiCaller(AccessionService.list, APPEND_ACCESSIONS);
const apiListAccessionSugestions = createApiCaller(AccessionService.listSuggestions, APPEND_ACCESSIONS_WITH_SUGGESTIONS);
const apiAccessionsOverview = createApiCaller(AccessionService.listOverview, RECEIVE_ACCESSION_OVERVIEW);
const apiAccessionsMapInfo = createApiCaller(AccessionService.mapInfo, RECEIVE_ACCESSION_MAPINFO);

const apiGeoJson = createPureApiCaller(AccessionService.geoJson);
const apiClimateInfo = createPureApiCaller(ClimateService.getCurrentClimate);
const apiAutocomplete = createPureApiCaller(AccessionService.autocomplete);

const apiListAccessionByUuid = createPureApiCaller(AccessionService.listAllByUuid);
const apiAccessionByUuid = createApiCaller(AccessionService.getDetailsByUuid, RECEIVE_ACCESSION);
const apiAccessionByDoi = createApiCaller(AccessionService.getDetailsByDoi, RECEIVE_ACCESSION);

const apiAccessionAuditByUuid = createApiCaller(AccessionService.getAccessionAuditLogByUUID, RECEIVE_ACCESSION_AUDIT_LOG);
const apiAccessionAuditByDoi = createApiCaller(AccessionService.getAccessionAuditLogByDoi, RECEIVE_ACCESSION_AUDIT_LOG);


export const updateRoute = (paged: FilteredPage<Accession>, path: string = '/a') => (dispatch) => {
  const qs = {
    s: paged.sort[0].property === Accession.DEFAULT_SORT.property ? undefined : paged.sort[0].property,
    d: paged.sort[0].direction === Accession.DEFAULT_SORT.direction ? undefined : paged.sort[0].direction,
  };
  dispatch(updateRouteWithFilterCode(paged.filterCode, path, qs));
};

export const updateRouteWithFilterCode = (filterCode: string, path: string = '/a', qs?: any, postfix: string = '') => (dispatch) => {
  console.log(`Update route2 ${filterCode} ${path}`, qs);
  dispatch(filterCodeToUrl(path, filterCode, qs, postfix));
};

export const applyFilters = (filters: string | AccessionFilter, page: IPageRequest = { page: 0 }) => (dispatch, getState) => {
  console.log('Applying new filter', filters);
  dispatch(showSnackbar('Applying filters...'));
  dispatch(navigateTo('/a'));

  return dispatch(apiListAccessionSugestions(filters, page))
    .then((paged) => {
      dispatch(updateRoute(paged));
      dispatch(showSnackbar(`Filters applied.`));
    });
};

export const listAccessionsByUuid = (uuidList: string[]) => (dispatch) => {
  return dispatch(apiListAccessionByUuid(uuidList));
};

export const loadMoreAccessions = (paged?: FilteredPage<Accession>) => (dispatch) => {
  console.log('Load more accessions', paged);
  return dispatch(apiListAccessions(paged ? paged.filterCode : '', Page.nextPage(paged)))
    .then((paged) => dispatch(updateRoute(paged)));
};

export const applyOverviewFilters = (filters: string | AccessionFilter) => (dispatch) => {
  console.log('Applying new filter', filters);
  dispatch(navigateTo('/a/overview'));
  return dispatch(apiAccessionsOverview(filters))
    .then((overview) => {
      dispatch(updateRouteWithFilterCode(overview.filterCode, '/a/overview'));
    });
};

export const loadAccessionsOverviewPage = (filterCode: string) => (dispatch) => {
  return dispatch(apiAccessionsOverview(filterCode));
};

export const geoJsonRequest = (filter, limit) => (dispatch) => {
  return dispatch(apiGeoJson(filter, limit));
};

export const currentClimateRequest = (lat, lng) => (dispatch) => {
  return dispatch(apiClimateInfo(lat, lng));
};

export const loadAccessionsMapInfo = (filters: string | AccessionFilter, viewPort?: {center: number[], zoom: number}) => (dispatch) => {
  dispatch(navigateTo('/a/map'));
  return dispatch(apiAccessionsMapInfo(filters))
    .then((mapInfo: AccessionMapInfo) => {
      if (!(mapInfo.bounds[0][0] && mapInfo.bounds[0][1] && mapInfo.bounds[1][0] && mapInfo.bounds[1][1])) {
        mapInfo.bounds = [[-170, 80], [170, -80]];
        console.log('One of map bounds is null, setting to default.');
        dispatch(receiveAccessionMapInfo(ApiCall.success(mapInfo)));
      }
      if (viewPort && viewPort.zoom && viewPort.center && viewPort.center.length === 2) {
        console.log(`viewPort @..,z${viewPort.zoom}`, viewPort);
        dispatch(updateRouteWithFilterCode(mapInfo.filterCode, '/a/map', null, viewPort && viewPort.center && `/@${viewPort.center[0]},${viewPort.center[1]},${viewPort.zoom}z`));
      } else {
        dispatch(updateRouteWithFilterCode(mapInfo.filterCode, '/a/map'));
      }
    });
};

export const loadAccession = ({ uuid, doi }: { uuid?: string, doi?: string }) => (dispatch) => {
  const loader = doi ? apiAccessionByDoi : apiAccessionByUuid;
  const lookup = doi ? doi : uuid;

  return dispatch(loader(lookup));
};

export const loadAccessionAuditLog = ({uuid, doi}: {uuid?: string, doi?: string}) => (dispatch) => {
  const loader = doi ? apiAccessionAuditByDoi : apiAccessionAuditByUuid;
  const lookup = doi ? doi : uuid;

  return dispatch(loader(lookup))
    .then((auditLog) => {
      if (_.isEmpty(auditLog.auditAccession) && _.isEmpty(auditLog.auditAccessionCollect) && _.isEmpty(auditLog.auditAccessionGeo) && _.isEmpty(auditLog.auditAccessionId)) {
        return dispatch(showSnackbar('common:label.noChanges'));
      }
    });
};

export const overviewAccessions = (filterCode: string) => (dispatch) => {
  return dispatch(apiAccessionsOverview(filterCode));
};

// TileLayers
const receiveTileLayerInfo = (tileLayer: MapLayer) => ({
  type: RECEIVE_TILE_LAYER,
  payload: {tileLayer},
});

export const updateTileLayerInfo = (tileLayer: MapLayer) => (dispatch) => {
  return dispatch(receiveTileLayerInfo(tileLayer));
};


const makeRange = (variable: number, diff: number) => {
  return {
    ge: Math.round(variable - diff),
    le: Math.round(variable + diff),
  };
};

export const autocomplete = (field: string, term: string, filters: string | AccessionFilter) => (dispatch, getState) => {
  return dispatch(apiAutocomplete(field, term, filters));
};

export const applyClimateFilters = (climate: TileClimate, extraFilters?: any) => (dispatch) => {
  // BIO1 = Annual Mean Temperature !!
  // BIO2 = Mean Diurnal Range (Mean of monthly (max temp - min temp))
  // BIO3 = Isothermality (BIO2/BIO7) (* 100)
  // BIO4 = Temperature Seasonality (standard deviation *100)
  // BIO5 = Max Temperature of Warmest Month
  // BIO6 = Min Temperature of Coldest Month
  // BIO7 = Temperature Annual Range (BIO5-BIO6)
  // BIO8 = Mean Temperature of Wettest Quarter
  // BIO9 = Mean Temperature of Driest Quarter
  // BIO10 = Mean Temperature of Warmest Quarter
  // BIO11 = Mean Temperature of Coldest Quarter
  // BIO12 = Annual Precipitation
  // BIO13 = Precipitation of Wettest Month
  // BIO14 = Precipitation of Driest Month
  // BIO15 = Precipitation Seasonality (Coefficient of Variation)
  // BIO16 = Precipitation of Wettest Quarter
  // BIO17 = Precipitation of Driest Quarter
  // BIO18 = Precipitation of Warmest Quarter !!
  // BIO19 = Precipitation of Coldest Quarter !!
  const tempDiff = 2;

  const filter = {
    // taxa: {
    //   genus: [ accession.taxonomy.genus ],
    //   // species: [ accession.taxonomy.species ],
    // },
    geo: {
      climate: {
        // temperature
        bio1: makeRange(climate.bio1, tempDiff),
        // bio2: makeRange(climate.bio2, tempDiff),
        bio4: makeRange(climate.bio4, climate.bio4 * .50),

        // bio7: makeRange(climate.bio7, tempDiff),
        // bio8: makeRange(climate.bio8, tempDiff),
        // bio9: makeRange(climate.bio9, tempDiff),
        // bio10: makeRange(climate.bio10, tempDiff),
        // bio11: makeRange(climate.bio11, tempDiff),
        // precipitation
        bio12: makeRange(climate.bio12, climate.bio12 * .25),
        // bio13: makeRange(climate.bio13, precDif),
        // bio14: makeRange(climate.bio14, precDif),
        // bio15: makeRange(climate.bio15, climate.bio15 * .25),
        bio18: makeRange(climate.bio18, climate.bio18 * .25),
        bio19: makeRange(climate.bio19, climate.bio19 * .25),
      },
    },
    ...extraFilters,
  };
  dispatch(applyFilters(filter));
};