3987 - DataExport: GrowingStockComposition -> always export most recent year

src/client/pages/DataExport/DataExport.tsx

@@ -44,7 +44,7 @@ const DataExport: React.FC = () => {
   const table = tables?.find((table) => table.props.dataExport)
   if (table) {
     tableName = table.props.name
-    rows = table.rows.filter((row) => !!row.props.variableName)
+    rows = table.rows.filter((row) => !!row.props.variableName && !row.props.excludeFromDataExport?.[cycle.uuid])
     columns = table.props.columnsExport[cycle.uuid] ?? table.props.columnNames[cycle.uuid]
   }
 

src/client/pages/DataExport/ResultsTable/ResultsTable.tsx

@@ -5,7 +5,7 @@ import { useTranslation } from 'react-i18next'
 import { Objects } from 'utils/objects'
 
 import { Areas, CountryIso } from 'meta/area'
-import { Unit } from 'meta/dataExport'
+import { Unit } from 'meta/assessment'
 
 import { useCycle } from 'client/store/assessment'
 import { useTableSections } from 'client/store/metadata'
@@ -32,7 +32,9 @@ const ResultsTable: React.FC<{ tableName: string }> = ({ tableName }) => {
   const baseUnit = table?.props?.unit
   const columns = selection.sections[sectionName].columns ?? []
 
-  const columnsAlwaysExport = table?.props?.columnsExportAlways[cycle.uuid] ?? []
+  const cellsExportAlways = table?.props?.cellsExportAlways?.[cycle.uuid] ?? []
+  const columnsAlwaysExport = table?.props?.columnsExportAlways?.[cycle.uuid] ?? []
+
   const columnsResults = [...columnsAlwaysExport, ...columns]
   const { variables } = selection.sections[sectionName]
 
@@ -44,11 +46,12 @@ const ResultsTable: React.FC<{ tableName: string }> = ({ tableName }) => {
   })
   const [units, setUnits] = useState<Record<string, Unit>>(initialUnits)
   const { results, resultsLoading } = useFetchResults({
-    columnsAlwaysExport,
-    tableName,
-    sectionName,
     assessmentName,
+    cellsExportAlways,
+    columnsAlwaysExport,
     cycleName,
+    sectionName,
+    tableName,
   })
 
   const onUnitChange = (value: Unit, variable: string) => {
@@ -77,24 +80,43 @@ const ResultsTable: React.FC<{ tableName: string }> = ({ tableName }) => {
     <div className="fra-table__container results-table">
       <div className="fra-table__scroll-wrapper">
         <ButtonTableExport
-          tableRef={tableRef}
-          filename={`${assessmentName}-${sectionName}`}
           disabled={exportDisabled}
+          filename={`${assessmentName}-${sectionName}`}
+          tableRef={tableRef}
         />
 
         <table ref={tableRef} className="fra-table data-table">
           <thead>
             <tr>
-              <th className="fra-table__header-cell-left" rowSpan={2}>
+              <th aria-hidden="true" className="fra-table__header-cell-left" rowSpan={2}>
                 &nbsp;
               </th>
+              {cellsExportAlways.map((cell) => {
+                const { columnName, unit, variableName } = cell
+                return (
+                  <th key={variableName} className="fra-table__header-cell" colSpan={1} rowSpan={2}>
+                    {unit !== null && (
+                      <Title
+                        baseUnit={unit ?? baseUnit}
+                        onUnitChange={onUnitChange}
+                        resultsLoading={resultsLoading}
+                        variable={variableName}
+                      />
+                    )}
+                    {unit === null &&
+                      getColumnLabelKeys(String(columnName), sectionName, assessmentName).map(
+                        (key) => `${i18n.t(key)} `
+                      )}
+                  </th>
+                )
+              })}
               {variables.map((variable) => (
                 <th key={variable} className="fra-table__header-cell" colSpan={columnsResults.length}>
                   <Title
                     baseUnit={baseUnit}
-                    variable={variable}
                     onUnitChange={onUnitChange}
                     resultsLoading={resultsLoading}
+                    variable={variable}
                   />
                 </th>
               ))}
@@ -121,17 +143,37 @@ const ResultsTable: React.FC<{ tableName: string }> = ({ tableName }) => {
                   <th className="fra-table__category-cell" colSpan={1}>
                     {i18n.t(label)} {deskStudy && `(${i18n.t('assessment.deskStudy')})`}
                   </th>
+                  {cellsExportAlways.map((cell) => {
+                    const { columnName, format, unit, variableName } = cell
+                    const { columnKey, value } = formatValue({
+                      assessmentName,
+                      colName: String(columnName),
+                      countryIso: countryIso as CountryIso,
+                      cycleName,
+                      data: results,
+                      format,
+                      tableName,
+                      variableName,
+                    })
+                    return (
+                      <td key={`${countryIso}${columnKey || columnName}`} className="fra-table__cell">
+                        <div className="number-input__readonly-view">
+                          {convertValue(value, unit ?? baseUnit, units[variableName])}
+                        </div>
+                      </td>
+                    )
+                  })}
                   {variables.map((variable) =>
                     columnsResults.map((column) => {
-                      const { columnKey, value } = formatValue(
+                      const { columnKey, value } = formatValue({
                         assessmentName,
+                        colName: String(column),
+                        countryIso: countryIso as CountryIso,
                         cycleName,
-                        String(column),
-                        countryIso as CountryIso,
-                        results,
+                        data: results,
                         tableName,
-                        variable
-                      )
+                        variableName: variable,
+                      })
 
                       return (
                         <td key={`${countryIso}${columnKey || column}`} className="fra-table__cell">

src/client/pages/DataExport/ResultsTable/Title/Title.tsx

@@ -4,8 +4,8 @@ import { useParams } from 'react-router-dom'
 
 import { Objects } from 'utils/objects'
 
-import { Cols, Row } from 'meta/assessment'
-import { Unit, UnitFactors } from 'meta/dataExport'
+import { Cols, Row, Unit } from 'meta/assessment'
+import { UnitFactors } from 'meta/dataExport'
 
 import { useCycle } from 'client/store/assessment'
 import { useTableSections } from 'client/store/metadata'

src/client/pages/DataExport/ResultsTable/useFetchResults.ts

@@ -2,17 +2,19 @@ import { useEffect } from 'react'
 
 import { ApiEndPoint } from 'meta/api/endpoint'
 import { AssessmentName } from 'meta/assessment'
+import { TableCell } from 'meta/assessment/table'
 import { RecordAssessmentData } from 'meta/data'
 
 import { useDataExportSelection } from 'client/store/ui/dataExport'
 import { useCountryIso, useGetRequest } from 'client/hooks'
 
 type Props = {
-  columnsAlwaysExport: Array<string>
-  tableName: string
-  sectionName: string
   assessmentName: AssessmentName
+  cellsExportAlways: Array<TableCell>
+  columnsAlwaysExport: Array<string>
   cycleName: string
+  sectionName: string
+  tableName: string
 }
 
 type UseFetchResults = {
@@ -21,10 +23,13 @@ type UseFetchResults = {
 }
 
 export const useFetchResults = (props: Props): UseFetchResults => {
-  const { columnsAlwaysExport, tableName, sectionName, assessmentName, cycleName } = props
+  const { assessmentName, cellsExportAlways, columnsAlwaysExport, cycleName, sectionName, tableName } = props
   const selection = useDataExportSelection(sectionName)
   const countryIso = useCountryIso()
 
+  const cellsExportAlwaysColumns = cellsExportAlways.map((cell) => cell.columnName)
+  const cellsExportAlwaysVariables = cellsExportAlways.map((cell) => cell.variableName)
+
   const {
     data: results = {},
     dispatch: fetchResults,
@@ -36,11 +41,10 @@ export const useFetchResults = (props: Props): UseFetchResults => {
       cycleName,
       tableNames: [tableName],
       countryISOs: selection.countryISOs,
-      variables: selection.sections[sectionName].variables,
-      columns: [...columnsAlwaysExport, ...selection.sections[sectionName].columns],
+      variables: [...cellsExportAlwaysVariables, ...selection.sections[sectionName].variables],
+      columns: [...cellsExportAlwaysColumns, ...columnsAlwaysExport, ...selection.sections[sectionName].columns],
     },
   })
-
   // eslint-disable-next-line react-hooks/exhaustive-deps
   useEffect(fetchResults, [selection])
 

src/client/pages/DataExport/utils/format.ts

@@ -1,9 +1,9 @@
 import { Numbers } from 'utils/numbers'
 
 import { CountryIso } from 'meta/area'
-import { AssessmentName, AssessmentNames, CycleName } from 'meta/assessment'
+import { AssessmentName, AssessmentNames, CycleName, TableCellNumberFormat, Unit } from 'meta/assessment'
 import { RecordAssessmentDatas, RecordCountryData } from 'meta/data'
-import { Unit, UnitConverter, UnitFactors } from 'meta/dataExport'
+import { UnitConverter, UnitFactors } from 'meta/dataExport'
 
 // import { getPanEuropeanTableMapping } from 'client/pages/DataExport/utils/panEuropean'
 
@@ -22,15 +22,30 @@ const sections: Record<string, string> = {
  * @param {string} variableName - url params: current variable
  * @returns {{columnKey: string, value: string}} - formatted column and value, from results
  */
-export const formatValue = (
-  assessmentName: AssessmentName,
-  cycleName: CycleName,
-  colName: string,
-  countryIso: CountryIso,
-  data: RecordCountryData,
-  tableName: string,
+type FormatValueProps = {
+  assessmentName: AssessmentName
+  colName: string
+  countryIso: CountryIso
+  cycleName: CycleName
+  data: RecordCountryData
+  tableName: string
   variableName: string
-): { columnKey: string; value: string } => {
+  format?: TableCellNumberFormat
+}
+
+type Returned = { columnKey: string; value: string }
+
+export const formatValue = (props: FormatValueProps): Returned => {
+  const {
+    assessmentName,
+    colName,
+    countryIso,
+    cycleName,
+    data,
+    format = TableCellNumberFormat.decimal,
+    tableName,
+    variableName,
+  } = props
   const columnKey = colName
 
   let value = RecordAssessmentDatas.getDatum({
@@ -42,9 +57,18 @@ export const formatValue = (
     colName,
     variableName,
   })
-
   // Convert value to string and check if it's a number
-  if (value && !Number.isNaN(+value)) value = Numbers.format(Number(value))
+  if (value && !Number.isNaN(+value)) {
+    const numericValue = Number(value)
+    if (format === TableCellNumberFormat.year) {
+      value = Numbers.toFixed(numericValue, 0)
+    } else {
+      let precision
+      if (format === TableCellNumberFormat.integer) precision = 0
+      value = Numbers.format(numericValue, precision)
+    }
+  }
+
   if (value === 'NaN') value = ''
 
   return { columnKey, value }

src/client/pages/DataExport/utils/labelKeys.ts

@@ -1,5 +1,4 @@
-import { AssessmentName, AssessmentNames } from 'meta/assessment'
-import { Unit } from 'meta/dataExport'
+import { AssessmentName, AssessmentNames, Unit } from 'meta/assessment'
 
 import { isYearWithWord } from './checks'
 
@@ -15,11 +14,12 @@ const unitLabelKeys: Record<string, string> = {
 
 const columnLabelKeys: Record<string, string> = {
   common_name: 'commonName',
-  scientific_name: 'scientificName',
+  growingStockMillionCubicMeter: 'millionCubicMeter',
+  growingStockPercent: 'growingStockPercent',
+  mostRecentYear: 'mostRecentYear',
   national_yes_no: 'national',
+  scientific_name: 'scientificName',
   sub_national_yes_no: 'subnational',
-  growingStockPercent: 'growingStockPercent',
-  growingStockMillionCubicMeter: 'millionCubicMeter',
 }
 
 export const getUnitLabelKey = (unit: string): string => (unitLabelKeys[unit] ? `unit.${unitLabelKeys[unit]}` : unit)

src/i18n/resources/en.js

@@ -654,6 +654,7 @@ The FRA team [email protected]
     totalGrowingStock: 'Total growing stock',
     rankingYear: 'Ranking year 2015',
     growingStockPercent: '$t(unit.growingStockPercent)',
+    mostRecentYear: '$t(fra.growingStockComposition.mostRecentYear)',
   },
 
   biomassStock: {

src/meta/assessment/index.ts

@@ -68,8 +68,8 @@ export { SectionNames } from './section'
 export { Sections } from './sections'
 export type { Settings } from './settings'
 export { SubSections } from './subSections'
-export type { Table, TableColumnNames, TableName, TableProps } from './table'
-export { TableNames } from './table'
+export type { Table, TableCell, TableCellNames, TableColumnNames, TableName, TableProps } from './table'
+export { TableCellNumberFormat, TableNames } from './table'
 export { Tables } from './tables'
 export type { TableSection, TableSectionProps } from './tableSection'
 export { TableSections } from './tableSections'

src/meta/assessment/row.ts

@@ -43,6 +43,7 @@ export interface RowProps {
    * even if forestCharacteristics.naturalForestArea is included in its calculation formula.
    */
   dependantsExclude?: Array<VariableCache>
+  excludeFromDataExport?: Record<CycleUuid, boolean>
   format?: {
     integer?: boolean
   }

src/meta/assessment/rows.ts

@@ -13,6 +13,8 @@ const cloneProps = (props: { cycleSource: Cycle; cycleTarget: Cycle; row: Row })
   if (_props.calculateFn?.[cycleSourceUuid]) _props.calculateFn[cycleTargetUuid] = _props.calculateFn[cycleSourceUuid]
   if (_props.calculateIf?.[cycleSourceUuid]) _props.calculateIf[cycleTargetUuid] = _props.calculateIf[cycleSourceUuid]
   if (_props.chart?.[cycleSourceUuid]) _props.chart[cycleTargetUuid] = _props.chart[cycleSourceUuid]
+  if (_props.excludeFromDataExport?.[cycleSourceUuid])
+    _props.excludeFromDataExport[cycleTargetUuid] = _props.excludeFromDataExport[cycleSourceUuid]
   if (_props.linkToSection?.[cycleSourceUuid])
     _props.linkToSection[cycleTargetUuid] = _props.linkToSection[cycleSourceUuid]
   if (_props.validateFns?.[cycleSourceUuid]) _props.validateFns[cycleTargetUuid] = _props.validateFns[cycleSourceUuid]

src/meta/assessment/table.ts

@@ -27,12 +27,28 @@ export enum TableNames {
   originalDataPointValue = 'originalDataPointValue',
 }
 
+export enum TableCellNumberFormat {
+  decimal = 'decimal',
+  integer = 'integer',
+  year = 'year',
+}
+
+export type TableCell = {
+  columnName: ColName
+  variableName: VariableName
+  format?: TableCellNumberFormat
+  unit?: Unit | null
+}
+
+export type TableCellNames = Record<CycleUuid, Array<TableCell>>
+
 // array of column names indexed by cycle uuid
 export type TableColumnNames = Record<CycleUuid, Array<ColName>>
 
 export type TableName = string
 
 export interface TableProps {
+  cellsExportAlways?: TableCellNames
   columnNames: TableColumnNames
   columnsExport?: TableColumnNames
   columnsExportAlways?: TableColumnNames

src/meta/dataExport/index.ts

@@ -1,2 +1,2 @@
 export type { UnitFactor } from './unit'
-export { Unit, UnitConverter, UnitFactors } from './unit'
+export { UnitConverter, UnitFactors } from './unit'

src/meta/dataExport/unit.ts

@@ -1,24 +1,5 @@
 import { Numbers } from 'utils/numbers'
 
-export enum Unit {
-  haThousand = 'haThousand',
-  haThousandPerYear = 'haThousandPerYear',
-  tonnesPerHa = 'tonnesPerHa',
-  cubicMeterPerHa = 'cubicMeterPerHa',
-  millionTonnes = 'millionTonnes',
-  millionsCubicMeterOverBark = 'millionsCubicMeterOverBark',
-  thousandCubicMeter = 'thousandCubicMeter',
-  thousandCubicMeterOverBark = 'thousandCubicMeterOverBark',
-  thousandCubicMeterRWE = 'thousandCubicMeterRWE',
-  thousandPersons = 'thousandPersons',
-  fte1000 = 'fte1000',
-  numberOfStudents = 'numberOfStudents',
-  absoluteNumber = 'absoluteNumber',
-  annualNumberOfVisitsMillion = 'annualNumberOfVisitsMillion',
-  millionNationalCurrency = 'millionNationalCurrency',
-  facilityLengthIn1000Km = 'facilityLengthIn1000Km',
-}
-
 export interface UnitFactor extends Record<string, number> {
   haThousand: number
   ha: number