Migration notes 6.0

public static AdjustmentInputParser parseInput() {
    return (req, def) -> {
        Map<String, Object> inputMap = new HashMap<>();
        req.getInput().forEach(
                input -> {
                    String name = input.getName();
                    String value = input.getValue();
                    IParser<Object> parser = Registry.getPluginValue(IParser.class, def.typeOf(name));
                    inputMap.put(name, parser == null ? value : parser.parse(value));
                }
        );
        return inputMap;
    };
}

@Slf4j
public class CustomSignOffService extends SignOffService {
    public CustomSignOffService(IActivePivotManager manager, ILocalDataExtractionService dataExtractionService,
            ISignOffServiceParams serviceParams) {
        super(manager, dataExtractionService, serviceParams);
    }

    /**
     * Export the data related to the instance following the DEE templates
     *
     * @param instance The sign-off task definition that needs to be exported
     * @return The list of export names with the associated task ID
     */
    @Override
    public Map<String, String> export(SignOffProcessInstanceExportDTO instance) {
        validateRequest(instance);

        try {
            if (log.isInfoEnabled()) {
                log.info("[EXPORT][SERVICE] Received \"export\" call for {} for definition {}.", JacksonSerializer.serialize(instance),
                        JacksonSerializer.serialize(instance));
            }
        } catch (SerializerException e) {
            log.error("[EXPORT][SERVICE] Error serializing object", e);
        }

        IMultiVersionActivePivot pivot = manager.getActivePivots().get(instance.getDomain());
        if (pivot == null) {
            throw new BadRequestException("[EXPORT][SERVICE] Requested an export on the " + instance.getDomain() + " cube, which does not exist.");
        }

        List<IDeeOrder> templates = getTemplates(instance.getDomain());

        List<IDeeOrder> orders = new ArrayList<>();
        for (var template : templates) {
            orders.add(adjustDeeOrderToInstance(template, instance));
        }

        IDeeOrder order = new CompositeDeeOrder(orders);
        List<String> taskIds = dataExtractionService.submitLocalTask(order);

        Map<String, String> deeTasks = new HashMap<>();
        for (int i = 0; i < taskIds.size(); i++) {
            deeTasks.put(orders.get(i).getName(), taskIds.get(i));
        }
        return deeTasks;
    }

    /**
     * Get all the templates need to fulfill an export request
     *
     * @param domain   the selected cube
     * @return A list of export templates
     */
    protected List<IDeeOrder> getTemplates(String domain) {
        List<String> templatesName = serviceParams.getDomainTemplates(domain, List.of());
        if (templatesName == null) {
            return List.of();
        }
        return templatesName.stream().map(deeTemplates::get).filter(Objects::nonNull).map(DeeOrderStr::getDeeOrder).toList();
    }

    /**
     * Check that all the parameters are provided on the request
     *
     * @param instance The request
     * @throws BadRequestException when the request is not well filled
     */
    @Override
    protected void validateRequest(SignOffProcessInstanceExportDTO instance) {
        if (instance == null) {
            throw new BadRequestException("[EXPORT][SERVICE] DTO not provided.");
        }

        String domain = instance.getDomain();
        if (domain == null) {
            throw new BadRequestException("[EXPORT][SERVICE] The export request is missing a domain (cube).");
        }

        if (instance.getFilters() == null) {
            throw new BadRequestException("[EXPORT][SERVICE] The export request is missing filters.");
        }

        if (instance.getAsOfDate() == null) {
            throw new BadRequestException("[EXPORT][SERVICE] The export request is missing an as-of date.");
        }
    }
}

@Configuration
public class SignOffServiceConfig {

    protected final CommonSignOffHierarchyProperties commonSignOffHierarchyProperties;

    protected final SignOffProperties signOffProperties;

    /**
     * The configuration property used to define the folder in which the DEE templates used for
     * the export of the sign-off are defined
     */
    public static final String EXPORT_TEMPLATE_FOLDER_PROP = "data.extraction.templates.base.dir.path";

    protected final String signOffDataExtractionTemplatesBaseDirPath;

    public SignOffServiceConfig(
            @Value("${" + EXPORT_TEMPLATE_FOLDER_PROP + "}") String signOffDataExtractionTemplatesBaseDirPath,
            CommonSignOffHierarchyProperties commonSignOffHierarchyProperties,
            SignOffProperties signOffProperties) {
        this.signOffDataExtractionTemplatesBaseDirPath = signOffDataExtractionTemplatesBaseDirPath;
        this.commonSignOffHierarchyProperties = commonSignOffHierarchyProperties;
        this.signOffProperties = signOffProperties;
    }

    @Bean
    public ISignOffService signOffService(IActivePivotManager manager, ILocalDataExtractionService dataExtractionService,
            @Qualifier(SP_QUALIFIER__TEMPLATES) Map<String, SignOffProperties.ExportFilenamesMdxTemplate> templatesFileName) {
        return new CustomSignOffService(manager, dataExtractionService, getSignOffServiceParams(templatesFileName));
    }

    @Bean
    @ConditionalOnVectorizedSensitivity
    @Deprecated(since = "5.4.0", forRemoval = true)
    @Qualifier(SP_QUALIFIER__TEMPLATES)
    protected Map<String, SignOffProperties.ExportFilenamesMdxTemplate> scalarTemplate() {
        return signOffProperties.getExtractionTemplates();
    }

    @Bean
    @ConditionalOnScalarSensitivity
    @Qualifier(SP_QUALIFIER__TEMPLATES)
    protected Map<String, SignOffProperties.ExportFilenamesMdxTemplate> vectorisedTemplate() {
        return signOffProperties.getExtractionTemplatesScalar();
    }

    protected ISignOffServiceParams getSignOffServiceParams(Map<String, SignOffProperties.ExportFilenamesMdxTemplate> templatesFileName) {
        Map<IPair<String, Set<String>>, List<String>> cubeToTemplates = new HashMap<>();
        for (var templatesFileNameValue : templatesFileName.values()) {
            var cubeName = templatesFileNameValue.getCubeName();
            Set<String> measuresAsSet = templatesFileNameValue.getMeasures();
            List<String> exportFileNames = templatesFileNameValue.getExportFileNames();
            cubeToTemplates.put(new Pair<>(cubeName, measuresAsSet), exportFileNames);
        }

        Map<String, LevelIdentifier> dateLevels = signOffProperties.getDateHierarchies();
        Map<String, LevelIdentifier> taskLevels = signOffProperties.getTaskLevels();

        return new ISignOffServiceParams() {
            @Override public String getKpiMdxTemplate() {
                return signOffProperties.getExportFilenamesMdxTemplate();
            }

            @Override public List<String> getDomainTemplates(String domain, List<String> measures) {
                Set<String> templates = new HashSet<>();
                templates.addAll(cubeToTemplates.getOrDefault(new Pair<>(domain, null), List.of()));
                templates.addAll(cubeToTemplates.getOrDefault(new Pair<>(DOMAIN_DEFAULT, null), List.of()));
                return new ArrayList<>(templates);
            }

            @Override public String getSignOffDataExtractionTemplatesBaseDirPath() {
                return signOffDataExtractionTemplatesBaseDirPath;
            }

            @Override public LevelIdentifier getDateLevel(String domain) {
                return dateLevels.getOrDefault(domain, dateLevels.get(DOMAIN_DEFAULT));
            }

            @Override public LevelIdentifier getSignOffLevel(String domain) {
                return taskLevels.getOrDefault(domain, taskLevels.get(DOMAIN_DEFAULT));
            }

            @Override public String getReviewableMember() {
                return commonSignOffHierarchyProperties.getLevelMembers().get(1);
            }
        };
    }
}