DecisionDataFactoryImpl.java

  1. /*
  2.  * Copyright 2010-2025 James Pether Sörling
  3.  *
  4.  * Licensed under the Apache License, Version 2.0 (the "License");
  5.  * you may not use this file except in compliance with the License.
  6.  * You may obtain a copy of the License at
  7.  *
  8.  *   http://www.apache.org/licenses/LICENSE-2.0
  9.  *
  10.  * Unless required by applicable law or agreed to in writing, software
  11.  * distributed under the License is distributed on an "AS IS" BASIS,
  12.  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13.  * See the License for the specific language governing permissions and
  14.  * limitations under the License.
  15.  *
  16.  *  $Id$
  17.  *  $HeadURL$
  18. */
  19. package com.hack23.cia.web.impl.ui.application.views.common.dataseriesfactory.impl;

  21. import java.util.List;
  22. import java.util.Locale;
  23. import java.util.Objects;
  24. import java.util.regex.Pattern;
  25. import java.util.stream.Collectors;

  27. import org.apache.commons.lang3.StringUtils;
  28. import org.springframework.beans.factory.annotation.Autowired;
  29. import org.springframework.stereotype.Service;
  30. import org.springframework.transaction.annotation.Propagation;
  31. import org.springframework.transaction.annotation.Transactional;

  33. import com.hack23.cia.model.external.riksdagen.dokumentstatus.impl.DocumentProposalData;
  34. import com.hack23.cia.model.external.riksdagen.dokumentstatus.impl.DocumentStatusContainer;
  35. import com.hack23.cia.service.api.ApplicationManager;
  36. import com.hack23.cia.web.impl.ui.application.views.common.dataseriesfactory.api.DecisionDataFactory;
  37. import com.hack23.cia.web.impl.ui.application.views.common.dataseriesfactory.api.ProposalCommitteeeSummary;

  39. /**
  40.  * Implementation of DecisionDataFactory for processing parliamentary committee decisions.
  41.  * Handles document status data and creates summaries of committee proposals.
  42.  */
  43. @Service
  44. @Transactional(propagation = Propagation.REQUIRED, readOnly = true)
  45. public final class DecisionDataFactoryImpl implements DecisionDataFactory {

  47.     /**  Document type constants. */
  48.     private static final String PROPOSITION = "Proposition";

  50.     /** The Constant MOTION. */
  51.     private static final String MOTION = "Motion";

  53.     /** The Constant PROP_TYPE. */
  54.     private static final String PROP_TYPE = "prop";

  56.     /**  Chamber text length constraints for valid proposals. */
  57.     private static final int CHAMBER_MIN_LENGTH = "avslag".length(); // 6

  59.     /** The Constant CHAMBER_MAX_LENGTH. */
  60.     private static final int CHAMBER_MAX_LENGTH = "återförvisning till utskottet".length(); // 29

  62.     /**
  63.      * Pattern for standardizing committee decision text.
  64.      * Removes or replaces parliamentary specific tokens:
  65.      * - (UTSKOTTET)
  66.      * - Parentheses
  67.      * - Various committee spelling variants
  68.      */
  69.     private static final Pattern COMMITTEE_TEXT_CLEANUP_PATTERN = Pattern.compile(
  70.         "(\\(UTSKOTTET\\))|(\\()|(\\))|(UTBSKOTTET)|(UBTSKOTTET)|(UTKOTTET)",
  71.         Pattern.CASE_INSENSITIVE
  72.     );

  74.     /** The application manager. */
  75.     @Autowired
  76.     private ApplicationManager applicationManager;

  78.     /**
  79.      * Creates committee summaries for a specific processing location.
  80.      *
  81.      * @param processedIn the location where proposals were processed
  82.      * @return List of committee summaries
  83.      * @throws IllegalArgumentException if processedIn is blank
  84.      */
  85.     @Override
  86.     public List<ProposalCommitteeeSummary> createCommitteeSummary(final String processedIn) {
  87.         validateProcessedIn(processedIn);

  89.         return applicationManager.getDataContainer(DocumentStatusContainer.class)
  90.                 .getAll()
  91.                 .parallelStream()
  92.                 .filter(doc -> isValidDocument(doc, processedIn))
  93.                 .map(doc -> createProposalSummary(doc))
  94.                 .filter(Objects::nonNull)
  95.                 .collect(Collectors.toList());
  96.     }

  98.     /**
  99.      * Validates the processedIn parameter.
  100.      *
  101.      * @param processedIn location to validate
  102.      * @throws IllegalArgumentException if validation fails
  103.      */
  104.     private void validateProcessedIn(final String processedIn) {
  105.         if (StringUtils.isBlank(processedIn)) {
  106.             throw new IllegalArgumentException("ProcessedIn parameter cannot be blank");
  107.         }
  108.     }

  110.     /**
  111.      * Validates if a document meets the criteria for processing.
  112.      *
  113.      * @param document the document to validate
  114.      * @param processedIn the required processing location
  115.      * @return true if document is valid for processing
  116.      */
  117.     private boolean isValidDocument(final DocumentStatusContainer document, final String processedIn) {
  118.         if (document == null || document.getDocumentProposal() == null ||
  119.             document.getDocumentProposal().getProposal() == null) {
  120.             return false;
  121.         }

  123.         final DocumentProposalData proposal = document.getDocumentProposal().getProposal();
  124.         return isValidProposal(proposal, processedIn);
  125.     }

  127.     /**
  128.      * Validates proposal data for processing requirements.
  129.      *
  130.      * @param proposal the proposal to validate
  131.      * @param processedIn the required processing location
  132.      * @return true if proposal meets requirements
  133.      */
  134.     private boolean isValidProposal(final DocumentProposalData proposal, final String processedIn) {
  135.         if (proposal == null || StringUtils.isBlank(proposal.getChamber()) ||
  136.             StringUtils.isBlank(proposal.getProcessedIn()) ||
  137.             StringUtils.isBlank(proposal.getCommittee())) {
  138.             return false;
  139.         }

  141.         final int chamberLength = proposal.getChamber().length();
  142.         return chamberLength >= CHAMBER_MIN_LENGTH &&
  143.                chamberLength <= CHAMBER_MAX_LENGTH &&
  144.                proposal.getProcessedIn().contains(processedIn);
  145.     }

  147.     /**
  148.      * Creates a ProposalCommitteeeSummary from a valid document.
  149.      *
  150.      * @param document source document
  151.      * @return ProposalCommitteeeSummary or null if invalid
  152.      */
  153.     private ProposalCommitteeeSummary createProposalSummary(final DocumentStatusContainer document) {
  154.         try {
  155.             final DocumentProposalData proposal = document.getDocumentProposal().getProposal();
  156.             return new ProposalCommitteeeSummary(
  157.                 extractCommitteeShortName(proposal),
  158.                 determineDocumentType(document),
  159.                 standardizeDecisionText(proposal.getChamber()),
  160.                 document.getDocument().getHangarId(),
  161.                 proposal.getWording(),
  162.                 proposal.getWording2(),
  163.                 proposal.getDecisionType()
  164.             );
  165.         } catch (final Exception e) {
  166.             // Log error if needed
  167.             return null;
  168.         }
  169.     }

  171.     /**
  172.      * Standardizes the decision text by removing variations and normalizing format.
  173.      *
  174.      * @param chamber the original chamber text
  175.      * @return standardized decision text
  176.      */
  177.     private static String standardizeDecisionText(final String chamber) {
  178.         if (StringUtils.isBlank(chamber)) {
  179.             return "";
  180.         }

  182.         String standardized = chamber.toUpperCase(Locale.ENGLISH);
  183.         standardized = COMMITTEE_TEXT_CLEANUP_PATTERN.matcher(standardized).replaceAll("");

  185.         // Normalize committee spelling
  186.         if (standardized.contains("UTKOTTET")) {
  187.             standardized = standardized.replace("UTKOTTET", "UTSKOTTET");
  188.         }

  190.         return standardized.trim();
  191.     }

  193.     /**
  194.      * Extracts the standardized committee short name.
  195.      *
  196.      * @param proposal source proposal
  197.      * @return committee short name
  198.      */
  199.     private static String extractCommitteeShortName(final DocumentProposalData proposal) {
  200.         final String processedIn = proposal.getProcessedIn();
  201.         if (StringUtils.isBlank(processedIn)) {
  202.             return "";
  203.         }

  205.         final String shortName = processedIn
  206.             .replaceAll("\\d", "")
  207.             .replace("/:", "")
  208.             .toUpperCase(Locale.ENGLISH);

  210.         final int commaIndex = shortName.indexOf(',');
  211.         return (commaIndex >= 0) ? shortName.substring(0, commaIndex) : shortName;
  212.     }

  214.     /**
  215.      * Determines the human-readable document type.
  216.      *
  217.      * @param document source document
  218.      * @return document type string
  219.      */
  220.     private static String determineDocumentType(final DocumentStatusContainer document) {
  221.         if (PROP_TYPE.equalsIgnoreCase(document.getDocument().getDocumentType())) {
  222.             return PROPOSITION;
  223.         }

  225.         final String subType = document.getDocument().getSubType();
  226.         return (subType != null && subType.length() > MOTION.length())
  227.                ? subType
  228.                : MOTION;
  229.     }
  230. }
Created with JaCoCo 0.8.12.202403310830