@sis-cc/dotstatsuite-components 22.6.0 → 23.0.0

package/src/rules/src/header/getHeaderUnits.js

@@ -1,17 +0,0 @@
-import * as R from 'ramda';
-import { dimensionValueDisplay, parseDisplay } from '../';
-
-export const getHeaderUnits = ({ units, display }) => {
-  const _display = parseDisplay(display);
-  return R.converge(
-    (header, label) => R.isEmpty(label) ? null : { header, label },
-    [
-      (units) => `${dimensionValueDisplay(_display)(units)}:`,
-      R.pipe(
-        R.propOr([], 'values'),
-        R.map(R.pipe(R.propOr({}, 'value'), dimensionValueDisplay(_display))),
-        R.join(', ')
-      )
-    ]
-  )(units);
-};

package/src/rules/src/header/getSubtitleFlags.js

@@ -1,43 +0,0 @@
-import * as R from 'ramda';
-import { dimensionValueDisplay, getFlags, parseDisplay } from '../';
-import { DEFAULT_REJECTED_SUBTITLE_IDS } from '../constants';
-
-export const getSubtitleFlags = ({ customAttributes, dimensions, display, units }) =>  {
-  const _display = parseDisplay(display);
-  const formatter = dimensionValueDisplay(_display);
-  const _getFlags =  getFlags(customAttributes, formatter, {});
-  const unitsValuesIds = R.pipe(R.propOr([], 'values'), R.pluck('id'))(units);
-
-  return R.pipe(
-    R.propOr([], 'one'),
-    R.values,
-    R.sortBy(R.prop('__index')),
-    R.reduce(
-      (acc, dim) => {
-        if (!R.propOr(true, 'display', dim)) {
-          return acc;
-        }
-        if (R.includes(dim.id, unitsValuesIds)) {
-          return acc;
-        }
-        const value = R.path(['values', 0], dim);
-
-        if (R.includes(value.id, DEFAULT_REJECTED_SUBTITLE_IDS) || !R.propOr(true, 'display', value)) {
-          return acc;
-        }
-
-        const flags = _getFlags({ attributes: R.propOr({}, 'attributes', value), notes: R.propOr([], 'notes', value) });
-        if (R.isEmpty(flags)) {
-          return acc;
-        }
-
-        return R.append({
-          header: `${formatter(dim)}:`,
-          label: formatter(value),
-          sub: flags
-        }, acc);
-      },
-      []
-    )
-  )(dimensions);
-};

package/src/rules/src/header/getTitleFlags.js

@@ -1,8 +0,0 @@
-import * as R from 'ramda';
-import { parseDisplay, dimensionValueDisplay, getFlags } from '../';
-
-export const getTitleFlags = ({ customAttributes, dataflowAttributes, display }) => {
-  const _display = parseDisplay(display);
-  const formatter = dimensionValueDisplay(_display);
-  return getFlags(customAttributes, formatter, {})({ attributes: dataflowAttributes });
-};

package/src/rules/src/header/index.js

@@ -1,4 +0,0 @@
-export { getDefaultSubtitle } from './getDefaultSubtitle';
-export { getSubtitleFlags } from './getSubtitleFlags';
-export { getHeaderUnits } from './getHeaderUnits';
-export { getTitleFlags } from './getTitleFlags';

package/src/rules/src/preparators/enhanceObservations.js

@@ -1,152 +0,0 @@
-import * as R from 'ramda';
-import { formatValue } from './formatValue';
-
-/*
-  options = {
-    attachmentSeriesIndexes, //units
-    customAttributes: {
-      decimals: id,
-      prefscale: id,
-    },
-    unitsArtefacts,
-    obsAttributes,
-    rejectedValueIds,
-  }
-*/
-
-const getSerieKey = (dimValuesIndexes, options) => {
-  let indexes = R.propOr([], 'attachmentSeriesIndexes', options);
-  return R.pipe(
-    R.addIndex(R.map)((valueIndex, dimIndex) => {
-      if (dimIndex === R.head(indexes)) {
-        indexes = R.tail(indexes);
-        return valueIndex;
-      }
-      return 'x';
-    }),
-    R.join(':')
-  )(dimValuesIndexes);
-};
-
-const getUnitsValues = (indexes, options) => R.reduce(
-  (acc, codelist) => {
-    const { id } = codelist;
-    if (!R.includes(id, R.propOr([], 'unitsIds', options))) {
-      return acc;
-    }
-    const valueIndex = R.prop(codelist.__index, indexes);
-    if (R.isNil(valueIndex) || !R.propOr(true, 'display', codelist)) {
-      return acc;
-    }
-    const value = R.path(['values', Number(valueIndex)], codelist);
-    if (R.isNil(value) || R.includes(value.id, R.propOr([], 'rejectedValueIds', options))
-      || !R.propOr(true, 'display', value)) {
-      return acc;
-    }
-    return R.assoc(
-      id,
-      {
-        ...R.pick(['id', 'name', '__index'], codelist),
-        value: R.when(R.complement(R.isNil), R.assoc('index', Number(valueIndex)))(value)
-      },
-      acc
-    );
-  },
-  {}
-);
-
-const getObservationUnits = (observation, dimensions, attributes, options) => {
-  const dimensionsUnits = getUnitsValues(
-    R.propOr([], 'dimValuesIndexes', observation),
-    options
-  )(dimensions);
-
-  const attributesUnits = getUnitsValues(
-    R.propOr([], 'attrValuesIndexes', observation),
-    options
-  )(attributes);
-  
-  const serieKey = getSerieKey(R.propOr([], 'dimValuesIndexes', observation), options);
-
-  return ({ ...dimensionsUnits, ...attributesUnits, serieKey });
-};
-
-const getFormatAttributesIndexes = (attributes, customAttributes) => R.addIndex(R.reduce)(
-  (acc, attribute, index) => {
-    if (R.equals(attribute.id, customAttributes.decimals)) {
-      return ({ ...acc, decimals: index });
-    }
-    if (R.equals(attribute.id, customAttributes.prefscale)) {
-      return ({ ...acc, prefscale: index });
-    }
-    return acc;
-  },
-  { prefscale: null, decimals: null },
-  attributes
-);
-
-const getAttributeValue = (attribute, valueIndex, options) => {
-  if (!R.propOr(true, 'display', attribute)) {
-    return null;
-  }
-  const value = R.pipe(
-    R.propOr([], 'values'),
-    R.nth(valueIndex)
-  )(attribute);
-
-  if (R.isNil(value) || !R.propOr(true, 'display', value) || R.includes(value.id,R.propOr([],'rejectedValueIds')(options))) {
-    return null;
-  }
-
-  return ({
-    ...R.pick(['id', 'name'], attribute),
-    value: R.pick(['id', 'name'], value)
-  });
-};
-
-
-export const enhanceObservations = (dimensions = [], observations = {}, attributes = [], options = {}) => {
-  const formatAttributesIndexes = getFormatAttributesIndexes(attributes, R.propOr({}, 'customAttributes', options));
-  const _attributes = R.addIndex(R.map)((attr, index) => R.assoc('__index', index, attr), attributes);
-  const _obsAttributes = R.pipe(
-    R.indexBy(R.prop('id')),
-    R.props(options.attributesIds || [])
-  )(_attributes);
-
-  return R.mapObjIndexed(
-    (observation) => {
-      const { attrValuesIndexes, dimValuesIndexes } = observation;
-      const obsAttributes = R.reduce(
-        (acc, attribute) => {
-          const attrValue = getAttributeValue(attribute, R.nth(attribute.__index, attrValuesIndexes), options);
-          if (R.isNil(attrValue)) {
-            return acc;
-          }
-          return R.assoc(attribute.id, attrValue, acc);
-        },
-        {},
-        _obsAttributes
-      );
-
-      const indexedDimValIds = R.addIndex(R.reduce)(
-        (acc, dimension, dimensionIndex) => {
-          const id = dimension.id;
-          const valueIndex = R.nth(dimensionIndex, dimValuesIndexes);
-          const valueId = R.path(['values', Number(valueIndex), 'id'], dimension);
-          return R.assoc(id, valueId, acc);
-        },
-        {},
-        dimensions
-      );
-
-      return ({
-        ...observation,
-        attributes: obsAttributes,
-        formattedValue: formatValue(observation, formatAttributesIndexes, attributes),
-        units: getObservationUnits(observation, dimensions, _attributes, options),
-        indexedDimValIds,
-      });
-    },
-    observations
-  );
-};

package/src/rules/src/properties/errors.js

@@ -1,19 +0,0 @@
-import * as R from 'ramda';
-import { TIMELINE } from '../constants';
-import { getTimePeriodDimension } from '@sis-cc/dotstatsuite-sdmxjs';
-
-export const getHasNoTimePeriodError = ({ data, type }) => {
-  if (!R.equals(TIMELINE, type)) {
-    return false;
-  }
-  const dimensions = R.pathOr([], ['structure', 'dimensions', 'observation'], data);
-  const timeDimension = getTimePeriodDimension({ dimensions });
-  if (R.isNil(timeDimension)) {
-    return true;
-  }
-  return R.pipe(
-    R.propOr([], 'values'),
-    R.length,
-    R.gte(1)
-  )(timeDimension);
-};

package/src/rules/src/properties/getInformationsStateFromNewProps.js

@@ -1,47 +0,0 @@
-import * as R from 'ramda';
-import { extractSdmxArtefacts, prepareData } from '../';
-
-const initialState = {
-  dataflow: null,
-  dataflowAttributes: null,
-  dimensions: null,
-  units: null,
-  id: null,
-  sourceLabel: null,
-  subtitle: null,
-  title: null,
-  withCopyright: true,
-  withLogo: true
-};
-
-export const getInformationsStateFromNewProps = (props, state) => {
-  if (R.isNil(props.data)) {
-    return initialState
-  }
-  const id = R.pipe(
-    R.prop('data'),
-    extractSdmxArtefacts,
-    R.prop('id')
-  )(props);
-  if (id === state.id && props.display === state.display) {
-    return {};
-  }
-  const {
-    dataflowAttributes,
-    dataflowName,
-    dimensions,
-    units
-  } = prepareData({ data: props.data }, props.customAttributes, props.units);
-  return {
-    ...initialState,
-    dataflow: {
-      id: props.dataflowId,
-      name: dataflowName
-    },
-    dataflowAttributes,
-    dimensions,
-    display: props.display,
-    id,
-    units
-  };
-};

package/src/rules/src/properties/information.js

@@ -1,84 +0,0 @@
-import { is, isEmpty, isNil, map, not, of, path, pipe, prop, length, split, when } from 'ramda';
-import {
-  defaultSubtitle,
-  extractSdmxArtefacts,
-  headerUprsLabel,
-  parseDisplay,
-  uprAttributes,
-  uprAttributesWithOneRelevantValue,
-} from '../';
-
-import { dimensionValueDisplay } from '../dimension-utils';
-
-export const initialState = {
-  subtitle: undefined,
-  title: undefined,
-  sourceLabel: undefined,
-};
-
-export const informationStateFromNewProps = (props, state) => {
-  const { id } = extractSdmxArtefacts(props.data);
-  if (id !== state.id) {
-    return initialState;
-  }
-  return ({});
-};
-
-const getDataflowCode = (url) => {
-  if (isNil(url) || isEmpty(url)) {
-    return null;
-  }
-  const match = url.match(/[\w\/]+\/data\/([^\/]+)\//);
-  if (!is(Array, match)) {
-    return null;
-  }
-  //v8 case: 'AGENCY,CODE,VERSION'
-  const id = match[1];
-  const splitId = split(',', id);
-  if ((length(splitId) === 1)) {
-    return splitId[0];
-  }
-  return splitId[1];
-};
-
-const defaultTitle = (props, display) => {
-  const name = path(['data', 'structure', 'name'], props);
-  const code = getDataflowCode(props.sdmxUrl);
-  return dimensionValueDisplay(display)({ id: code, name });
-};
-
-const defaultSourceLabel = (props, title) => {
-  const propsLabel = path(['source', 'label'], props);
-  return (isNil(propsLabel) || isEmpty(propsLabel))
-    ? title : propsLabel;
-}
-
-export const toHeader = (props, state) => { 
-  const display = parseDisplay(props.display);
-  const stateTitle = prop('title', state);
-  const stateSubtitle = prop('subtitle', state);
-  const stateSourceLabel = prop('sourceLabel', state);
-  const propsSourceLink = path(['source', 'link'], props);
-  const title = (isNil(stateTitle) || isEmpty(stateTitle))
-    ? defaultTitle(props, display) : stateTitle;
-  const subtitle = (isNil(stateSubtitle) || isEmpty(stateSubtitle))
-    ? defaultSubtitle(props.data, display) : stateSubtitle;
-  const sourceLink = (isNil(propsSourceLink) || isEmpty(propsSourceLink))
-    ? props.sdmxUrl : propsSourceLink;
-  const sourceLabel = (isNil(stateSourceLabel) || isEmpty(stateSourceLabel))
-    ? defaultSourceLabel(props, title) : stateSourceLabel;
-  return ({
-    footnotes: { source: sourceLink, sourceLabel },
-    title: { label: title },
-    subtitle: pipe(
-      when(pipe(is(Array), not), of),
-      map(entry => ({ label: entry }))
-    )(subtitle),
-    uprs: pipe(
-      extractSdmxArtefacts,
-      ({ attributes }) => uprAttributes(attributes),
-      uprAttributesWithOneRelevantValue,
-      headerUprsLabel(display),
-    )(props.data)
-  });
-};

package/src/rules/src/v8-transformer.js

@@ -1,177 +0,0 @@
-import * as R from 'ramda';
-import {
-  isTimePeriodDimension,
-} from '@sis-cc/dotstatsuite-sdmxjs';
-import {
-  getRelationnalAnnotations,
-  setAnnotationsLayout,
-  getIsHidden,
-} from './sdmx-data';
-import { getReportingYearStart } from './preparators/getReportingYearStart';
-import { getNotDisplayedIds } from '../../rules2/src';
-import { getValuesEnhanced } from './get-values-enhanced';
-
-const TIME_PERIOD_ID = 'TIME_PERIOD';
-
-export const dataTransformer = (dataNew, options = {}) => {
-  const { locale } = options;
-  const reportYearStart = getReportingYearStart(dataNew);
-  const getName = R.prop('name')
-  //---------------------------------------------------------------------------------------Annotations
-  const getStructure = R.pathOr({}, ['data', 'structure']);
-  const structure = getStructure(dataNew);
-  const getAnnotations = R.propOr([], 'annotations');
-  const annotations = getAnnotations(structure);
-  const getDataSets = R.pathOr({}, ['data', 'dataSets']);
-  const dataSets = getDataSets(dataNew);
-
-  const dataSetsAnnotations = R.props(
-    R.pathOr([], [0, 'annotations'], dataSets),
-    annotations,
-  );
-
-  /*
-    hiddenValues => codelistIds or codelistValuesIds for display computation
-    hiddenCombinations => used only for dimensions, if dimension values match the provided set, all dimension is removed
-  */
-  const { hiddenValues, hiddenCombinations } = getNotDisplayedIds(dataSetsAnnotations);
-  const getIsAllDimHidden = ({ id, values }) => {
-    if (!R.has(id, hiddenCombinations)) {
-      return false;
-    }
-    const valuesIds = R.pluck('id', values);
-    return R.isEmpty(R.difference(valuesIds, hiddenCombinations[id]));
-  }
-
-  //--------------------------------------------------------------------------------------------Header
-  const getMeta = R.propOr({}, 'meta');
-  const meta = getMeta(dataNew);
-
-  const getSender = R.propOr({}, 'sender');
-  const sender = getSender(meta);
-
-  const resHeader = {
-    ...meta,
-    sender: { ...sender, name: getName(sender) },
-  };
-
-  //----------------------------------------------------------------------------------------Attributes
-  const getAttributes = R.propOr({}, 'attributes');
-  const attributes = getAttributes(structure);
-
-  const getAttrObservations = R.propOr([], 'observation');
-  const attrObservations = getAttrObservations(attributes);
-
-  const resAttrObservations = R.addIndex(R.map)((observation, index) => {
-    const obsAnnotations = R.props(observation.annotations || [], annotations);
-    return {
-      ...observation,
-      __index: index,
-      display:
-        !R.has(observation.id, hiddenValues) && !getIsHidden(obsAnnotations),
-      name: getName(observation),
-      values: getValuesEnhanced({
-        locale,
-        annotations,
-        parent: observation.id,
-        reportYearStart,
-        hiddenIds: hiddenValues,
-        options,
-      })(R.propOr([], 'values', observation)),
-      roles: !R.isNil(observation.role) ? R.head(observation.role) : null,
-    };
-  }, attrObservations);
-
-  const datasetAttributes = R.map((attr) => {
-    const attrAnnotations = R.props(attr.annotations || [], annotations);
-    return {
-      ...attr,
-      display: !R.has(attr.id, hiddenValues) && !getIsHidden(attrAnnotations),
-      name: getName(attr),
-      values: getValuesEnhanced({
-        locale,
-        annotations,
-        parent: attr.id,
-        hiddenIds: hiddenValues,
-        options,
-        reportYearStart,
-      })(R.propOr([], 'values', attr)),
-    };
-  }, R.propOr([], 'dataSet', attributes));
-
-  const resAttributes = {
-    ...attributes,
-    observation: R.concat(resAttrObservations, datasetAttributes),
-  };
-
-  //----------------------------------------------------------------------------------------Dimensions
-  const getDimensions = R.propOr({}, 'dimensions');
-  const dimensions = getDimensions(structure);
-
-  const getDimObservations = R.propOr([], 'observation');
-  const dimObservations = getDimObservations(dimensions);
-
-  const getObservations = (locale) =>
-    R.addIndex(R.reduce)(
-      (acc, observation, obsIndex) => {
-        const id = R.prop('id')(observation);
-        const dimAnnotations = getRelationnalAnnotations(
-          R.propOr([], 'annotations')(observation),
-        )(annotations);
-        const isTimeDimension = isTimePeriodDimension(observation);
-        const values = getValuesEnhanced({
-          locale,
-          annotations,
-          isTimeDimension,
-          reportYearStart,
-          parent: id,
-          hiddenIds: hiddenValues,
-          options,
-        })(R.propOr([], 'values', observation));
-        const isAllDimHidden = getIsAllDimHidden({ id, values });
-        const isHidden = isAllDimHidden || R.has(id, hiddenValues)
-          || getIsHidden(dimAnnotations);
-        return {
-          observation: R.append({
-            ...observation,
-            rejected: isAllDimHidden || R.isEmpty(values),
-            display: !isHidden,
-            __index: obsIndex,
-            name: getName(observation),
-            values,
-            role: isTimeDimension
-              ? TIME_PERIOD_ID
-              : R.head(R.propOr([], 'roles', observation)),
-          })(acc.observation),
-          dimensionsLayout: setAnnotationsLayout(
-            id,
-            acc.dimensionsLayout,
-          )(dimAnnotations),
-        };
-      },
-      { observation: [], dimensionsLayout: {} },
-    );
-
-  //-----------------------------------------------------------------------------------------Structure
-  const { dimensionsLayout, observation } =
-    getObservations(locale)(dimObservations);
-  const resStructure = {
-    ...structure,
-    name: getName({ ...structure, id: options.dataflowId }),
-    annotations,
-    attributes: resAttributes,
-    dimensions: { observation },
-  };
-
-  //------------------------------------------------------------------------------------------------------Layout
-  const dataSetsLayout = R.reduce((acc, dataSetsAnnotation) => {
-    const title = R.propOr('', 'title')(dataSetsAnnotation);
-    if (R.isEmpty(title)) return acc;
-    return setAnnotationsLayout(title, acc)([dataSetsAnnotation]);
-  }, {})(dataSetsAnnotations);
-
-  return {
-    data: { header: resHeader, dataSets, structure: resStructure },
-    layout: R.mergeRight(dimensionsLayout, dataSetsLayout),
-  };
-};

package/src/rules2/src/getAdvAttrSeriesAtCoordinates.js

@@ -1,29 +0,0 @@
-import * as R from 'ramda';
-
-const attribueValueDisplay = (display) => data => {
-  if (display === 'code') {
-    return R.prop('id', data);
-  }
-  if (display ===  'both') {
-    return `${R.prop('id', data)}: ${R.prop('name', data)}`;
-  }
-  return R.prop('name', data);
-};
-
-export const getAdvAttrSeriesAtCoordinates = (coordinates, advancedAttributes, display) => R.pipe(
-  R.filter(serie => {
-    const mergedCoord = R.mergeLeft(serie.coordinates, coordinates);
-    return R.equals(mergedCoord, coordinates);
-  }),
-  R.map(serie => {
-    return R.pipe(
-      R.propOr({}, 'attributes'),
-      R.values,
-      R.map(attribute => ({
-        id: attribute.id,
-        label: attribueValueDisplay(display)(attribute),
-        value: attribueValueDisplay(display)(attribute.value)
-      }))
-    )(serie);
-  }),
-)(advancedAttributes);

package/src/rules2/src/getMetadataStructureFromData.js

@@ -1,17 +0,0 @@
-import * as R from 'ramda';
-
-export const getDataflowMetadataStructure = sdmxJson => {
-  const annotations = R.pathOr([], ['data', 'stucture', 'annotations'], sdmxJson);
-  const dataSetAnnotIndexes = R.pathOr([], ['data', 'dataSets', 0, 'annotations'], sdmxJson);
-  const dataSetAnnotations = R.props(dataSetAnnotIndexes, annotations);
-  const metadataAnnotation = R.find(R.propEq('type', 'METADATA'), dataSetAnnotations);
-  if (!metadataAnnotation) {
-    return null;
-  }
-  return R.pipe(
-    R.propOr('', 'title'),
-    R.split('='),
-    R.last,
-    
-  )(metadataAnnotation);
-};

package/src/rules2/src/refineMetadataCoordinates.js

@@ -1,28 +0,0 @@
-import * as R from 'ramda';
-
-export const refineMetadataCoordinates = (metadataCoordinates, layoutIds) => {
-  const relevantIds = R.pipe(R.values, R.unnest)(layoutIds);
-  return R.reduce(
-    (acc, coordinates) => {
-      const refinedCoord = R.pick(relevantIds, coordinates);
-      if (R.isEmpty(refinedCoord)) {
-        return acc;
-      }
-      const removedHeaderCodes = R.omit(layoutIds.header, refinedCoord);
-      if (R.isEmpty(removedHeaderCodes)) {
-        return R.over(R.lensProp('header'), R.append(refinedCoord))(acc);
-      }
-      const removedSectionCodes = R.omit(layoutIds.sections, refinedCoord);
-      if (R.isEmpty(removedSectionCodes)) {
-        return R.over(R.lensProp('sections'), R.append(refinedCoord))(acc);
-      }
-      const removedRowsCodes = R.omit(layoutIds.rows, removedSectionCodes);
-      if (R.isEmpty(removedRowsCodes)) {
-        return R.over(R.lensProp('rows'), R.append(refinedCoord))(acc);
-      }
-      return R.over(R.lensProp('cells'), R.append(refinedCoord))(acc);
-    }, 
-    { cells: [], header: [], sections: [], rows: [] },
-    metadataCoordinates
-  );
-};

package/src/rules2/src/table/getCombinationDimensionsData.js

@@ -1,39 +0,0 @@
-import * as R from 'ramda';
-import { parseValueHierarchy, isSameValueAsPrevious } from './parseValueHierarchy';
-
-export const getCombinationDimensionsData = (indexes, combination, previous, sameSerie) => {
-  let coordinates = {};
-  let ids = [];
-  let _sameSerie = sameSerie;
-  let hasAdvancedAttributes = false;
-
-  const { dimensions=[] } = combination;
-  const dimValues = R.addIndex(R.reduce)(
-    (acc, valIndex, dimIndex) => {
-      const dimension = R.nth(dimIndex, dimensions);
-      const value = R.nth(Math.abs(valIndex), R.propOr([], 'values', dimension));
-      hasAdvancedAttributes = !hasAdvancedAttributes ? value.hasAdvancedAttributes : true;
-      coordinates = R.assoc(dimension.id, value.id, coordinates);
-      ids = R.append(`${dimension.id}=${value.id}`, ids);
-      const previousValue = R.propOr({}, dimension.id, previous);
-      if (isSameValueAsPrevious(value, previousValue) && _sameSerie) {
-        return R.assoc(dimension.id, previousValue, acc);
-      }
-      else {
-        const _parsedValue = parseValueHierarchy(value, _sameSerie ? previousValue || {} : {}, dimension.indexedValues);
-        const parsedValue = R.over(
-          R.lensProp('display'),
-          (display=true) => display && R.propOr(true, 'display', dimension)
-        )(_parsedValue);
-        if (!R.isNil(previous)) {
-          _sameSerie = false;
-        }
-        return R.assoc(dimension.id, parsedValue, acc);
-      }
-    },
-    {},
-    indexes
-  );
-
-  return ({ dimValues, coordinates, ids, sameSerie: _sameSerie, hasAdvancedAttributes });
-};