Examples with InvalidColumnException de.symeda.sormas.api.importexport.InvalidColumnException used on opensource projects

Example 16 with InvalidColumnException

use of de.symeda.sormas.api.importexport.InvalidColumnException in project SORMAS-Project by hzi-braunschweig.

the class CaseImportFacadeEjb method insertColumnEntryIntoRelatedObject.

/**
 * Inserts the entry of a single cell into the sample, pathogen test, vaccinations or any other related object
 */
private void insertColumnEntryIntoRelatedObject(Object currentElement, String entry, String[] entryHeaderPath) throws InvalidColumnException, ImportErrorException {
    for (int i = 0; i < entryHeaderPath.length; i++) {
        String headerPathElementName = entryHeaderPath[i];
        try {
            if (i != entryHeaderPath.length - 1) {
                currentElement = new PropertyDescriptor(headerPathElementName, currentElement.getClass()).getReadMethod().invoke(currentElement);
            } else {
                PropertyDescriptor pd = new PropertyDescriptor(headerPathElementName, currentElement.getClass());
                Class<?> propertyType = pd.getPropertyType();
                // according to the types of the sample or pathogen test fields
                if (importFacade.executeDefaultInvoke(pd, currentElement, entry, entryHeaderPath, false)) {
                    continue;
                } else if (propertyType.isAssignableFrom(FacilityReferenceDto.class)) {
                    List<FacilityReferenceDto> lab = facilityFacade.getLaboratoriesByName(entry, false);
                    if (lab.isEmpty()) {
                        throw new ImportErrorException(I18nProperties.getValidationError(Validations.importEntryDoesNotExist, entry, buildEntityProperty(entryHeaderPath)));
                    } else if (lab.size() > 1) {
                        throw new ImportErrorException(I18nProperties.getValidationError(Validations.importLabNotUnique, entry, buildEntityProperty(entryHeaderPath)));
                    } else {
                        pd.getWriteMethod().invoke(currentElement, lab.get(0));
                    }
                } else {
                    throw new UnsupportedOperationException(I18nProperties.getValidationError(Validations.importCasesPropertyTypeNotAllowed, propertyType.getName()));
                }
            }
        } catch (IntrospectionException e) {
            throw new InvalidColumnException(buildEntityProperty(entryHeaderPath));
        } catch (InvocationTargetException | IllegalAccessException e) {
            throw new ImportErrorException(I18nProperties.getValidationError(Validations.importErrorInColumn, buildEntityProperty(entryHeaderPath)));
        } catch (IllegalArgumentException e) {
            throw new ImportErrorException(entry, buildEntityProperty(entryHeaderPath));
        } catch (ParseException e) {
            throw new ImportErrorException(I18nProperties.getValidationError(Validations.importInvalidDate, buildEntityProperty(entryHeaderPath), DateHelper.getAllowedDateFormats(I18nProperties.getUserLanguage().getDateFormat())));
        } catch (ImportErrorException e) {
            throw e;
        } catch (Exception e) {
            LOGGER.error("Unexpected error when trying to import a case: " + e.getMessage());
            throw new ImportErrorException(I18nProperties.getValidationError(Validations.importCasesUnexpectedError));
        }
    }
}

Example 17 with InvalidColumnException

use of de.symeda.sormas.api.importexport.InvalidColumnException in project SORMAS-Project by hzi-braunschweig.

the class TravelEntryImportFacadeEjb method insertColumnEntryIntoData.

private void insertColumnEntryIntoData(TravelEntryDto travelEntry, PersonDto person, String entry, String[] entryHeaderPath) throws InvalidColumnException, ImportErrorException {
    String propertyCaption = String.join("", entryHeaderPath);
    // Build the SORMAS property based on the DEA caption
    String personProperty = getPersonProperty(propertyCaption);
    Object currentElement = personProperty != null ? person : travelEntry;
    if (personProperty != null) {
        // Map the entry to an expected SORMAS value if necessary
        entry = getPersonValue(personProperty, entry);
    }
    Language language = I18nProperties.getUserLanguage();
    try {
        // Some person-related fields need to be handled in a specific way for the DEA import
        if (PersonDto.BIRTH_DATE.equals(personProperty)) {
            Date birthDate = DateHelper.parseDate(entry, new SimpleDateFormat("dd.MM.yyyy"));
            Calendar calendar = Calendar.getInstance();
            calendar.setTime(birthDate);
            person.setBirthdateDD(calendar.get(Calendar.DAY_OF_MONTH));
            // In calendar API months are indexed from 0 @see https://docs.oracle.com/javase/7/docs/api/java/util/Calendar.html#MONTH
            int birthdateMonth = calendar.get(Calendar.MONTH) + 1;
            person.setBirthdateMM(birthdateMonth);
            person.setBirthdateYYYY(calendar.get(Calendar.YEAR));
            return;
        } else if (PHONE_PRIVATE.equals(personProperty)) {
            person.setPhone(entry);
            return;
        } else if (PHONE_ADDITIONAL.equals(personProperty)) {
            person.setAdditionalPhone(entry);
            return;
        } else if (EMAIL.equals(personProperty)) {
            person.setEmailAddress(entry);
            return;
        }
        String relevantProperty = personProperty != null ? personProperty : propertyCaption;
        PropertyDescriptor pd = new PropertyDescriptor(relevantProperty, currentElement.getClass());
        Class<?> propertyType = pd.getPropertyType();
        // according to the types of the case or person fields
        if (importFacade.executeDefaultInvoke(pd, currentElement, entry, entryHeaderPath, false)) {
        // No action needed
        } else if (propertyType.isAssignableFrom(DistrictReferenceDto.class)) {
            List<DistrictReferenceDto> district = districtFacade.getByName(entry, ImportHelper.getRegionBasedOnDistrict(pd.getName(), null, null, travelEntry, person, currentElement), false);
            if (district.isEmpty()) {
                throw new ImportErrorException(I18nProperties.getValidationError(Validations.importEntryDoesNotExistDbOrRegion, entry, buildEntityProperty(entryHeaderPath)));
            } else if (district.size() > 1) {
                throw new ImportErrorException(I18nProperties.getValidationError(Validations.importDistrictNotUnique, entry, buildEntityProperty(entryHeaderPath)));
            } else {
                pd.getWriteMethod().invoke(currentElement, district.get(0));
            }
        } else if (propertyType.isAssignableFrom(CommunityReferenceDto.class)) {
            List<CommunityReferenceDto> community = communityFacade.getByName(entry, travelEntry.getResponsibleDistrict(), false);
            if (community.isEmpty()) {
                throw new ImportErrorException(I18nProperties.getValidationError(Validations.importEntryDoesNotExistDbOrDistrict, entry, buildEntityProperty(entryHeaderPath)));
            } else if (community.size() > 1) {
                throw new ImportErrorException(I18nProperties.getValidationError(Validations.importCommunityNotUnique, entry, buildEntityProperty(entryHeaderPath)));
            } else {
                pd.getWriteMethod().invoke(currentElement, community.get(0));
            }
        } else if (propertyType.isAssignableFrom(PointOfEntryReferenceDto.class)) {
            PointOfEntryReferenceDto pointOfEntryReference;
            DistrictReferenceDto pointOfEntryDistrict = travelEntry.getPointOfEntryDistrict() != null ? travelEntry.getPointOfEntryDistrict() : travelEntry.getResponsibleDistrict();
            List<PointOfEntryReferenceDto> customPointsOfEntry = pointOfEntryFacade.getByName(entry, pointOfEntryDistrict, false);
            if (customPointsOfEntry.isEmpty()) {
                final String poeName = entry;
                List<PointOfEntryDto> defaultPointOfEntries = pointOfEntryFacade.getByUuids(PointOfEntryDto.CONSTANT_POE_UUIDS);
                Optional<PointOfEntryDto> defaultPointOfEntry = defaultPointOfEntries.stream().filter(defaultPoe -> InfrastructureHelper.buildPointOfEntryString(defaultPoe.getUuid(), defaultPoe.getName()).equals(poeName)).findFirst();
                if (!defaultPointOfEntry.isPresent()) {
                    throw new ImportErrorException(I18nProperties.getValidationError(Validations.importEntryDoesNotExistDbOrDistrict, entry, buildEntityProperty(entryHeaderPath)));
                }
                pointOfEntryReference = defaultPointOfEntry.get().toReference();
            } else if (customPointsOfEntry.size() > 1) {
                throw new ImportErrorException(I18nProperties.getValidationError(Validations.importPointOfEntryNotUniqueInDistrict, entry, buildEntityProperty(entryHeaderPath)));
            } else {
                pointOfEntryReference = customPointsOfEntry.get(0);
            }
            pd.getWriteMethod().invoke(currentElement, pointOfEntryReference);
        } else {
            throw new UnsupportedOperationException(I18nProperties.getValidationError(Validations.importPropertyTypeNotAllowed, propertyType.getName()));
        }
    } catch (IntrospectionException e) {
        // Add the property to the deaContent field of the travel entry
        if (travelEntry.getDeaContent() == null) {
            travelEntry.setDeaContent(new ArrayList<>());
        }
        travelEntry.getDeaContent().add(new DeaContentEntry(propertyCaption, entry));
    } catch (InvocationTargetException | IllegalAccessException e) {
        throw new ImportErrorException(I18nProperties.getValidationError(Validations.importErrorInColumn, buildEntityProperty(entryHeaderPath)));
    } catch (IllegalArgumentException | EnumService.InvalidEnumCaptionException e) {
        throw new ImportErrorException(entry, buildEntityProperty(entryHeaderPath));
    } catch (ParseException e) {
        throw new ImportErrorException(I18nProperties.getValidationError(Validations.importInvalidDate, buildEntityProperty(entryHeaderPath), DateHelper.getAllowedDateFormats(language.getDateFormat())));
    } catch (ImportErrorException | UnsupportedOperationException e) {
        throw e;
    } catch (Exception e) {
        LOGGER.error("Unexpected error when trying to import a travel entry: " + e.getMessage(), e);
        throw new ImportErrorException(I18nProperties.getValidationError(Validations.importUnexpectedError));
    }
}

Example 18 with InvalidColumnException

use of de.symeda.sormas.api.importexport.InvalidColumnException in project SORMAS-Project by hzi-braunschweig.

the class CampaignFormDataImporter method insertImportRowIntoData.

private void insertImportRowIntoData(CampaignFormDataDto campaignFormData, String[] entry, String[] entryHeaderPath) throws InvalidColumnException, ImportErrorException {
    CampaignFormMetaDto campaignMetaDto = FacadeProvider.getCampaignFormMetaFacade().getCampaignFormMetaByUuid(campaignFormMetaUuid);
    campaignFormData.setCampaignFormMeta(new CampaignFormMetaReferenceDto(campaignFormMetaUuid, campaignMetaDto.getFormName()));
    List<String> formDataDtoFields = Stream.of(campaignFormData.getClass().getDeclaredFields()).map(Field::getName).collect(Collectors.toList());
    for (int i = 0; i < entry.length; i++) {
        final String propertyPath = entryHeaderPath[i];
        if (formDataDtoFields.contains(propertyPath)) {
            try {
                PropertyDescriptor propertyDescriptor = new PropertyDescriptor(propertyPath, campaignFormData.getClass());
                Class<?> propertyType = propertyDescriptor.getPropertyType();
                if (!executeDefaultInvoke(propertyDescriptor, campaignFormData, entry[i], new String[] { propertyPath })) {
                    final UserDto currentUserDto = userFacade.getByUuid(currentUser.getUuid());
                    final JurisdictionLevel jurisdictionLevel = UserRole.getJurisdictionLevel(currentUserDto.getUserRoles());
                    if (propertyType.isAssignableFrom(DistrictReferenceDto.class)) {
                        if (jurisdictionLevel == JurisdictionLevel.DISTRICT && !currentUserDto.getDistrict().getCaption().equals(entry[i])) {
                            throw new ImportErrorException(I18nProperties.getValidationError(Validations.importEntryDistrictNotInUsersJurisdiction, entry[i], propertyPath));
                        }
                        List<DistrictReferenceDto> district = FacadeProvider.getDistrictFacade().getByName(entry[i], campaignFormData.getRegion(), true);
                        if (district.isEmpty()) {
                            throw new ImportErrorException(I18nProperties.getValidationError(Validations.importEntryDoesNotExistDbOrRegion, entry[i], propertyPath));
                        } else if (district.size() > 1) {
                            throw new ImportErrorException(I18nProperties.getValidationError(Validations.importDistrictNotUnique, entry[i], propertyPath));
                        } else {
                            propertyDescriptor.getWriteMethod().invoke(campaignFormData, district.get(0));
                        }
                    } else if (propertyType.isAssignableFrom(CommunityReferenceDto.class)) {
                        if (jurisdictionLevel == JurisdictionLevel.COMMUNITY && !currentUserDto.getCommunity().getCaption().equals(entry[i])) {
                            throw new ImportErrorException(I18nProperties.getValidationError(Validations.importEntryCommunityNotInUsersJurisdiction, entry[i], propertyPath));
                        }
                        List<CommunityReferenceDto> community = FacadeProvider.getCommunityFacade().getByName(entry[i], campaignFormData.getDistrict(), true);
                        if (community.isEmpty()) {
                            throw new ImportErrorException(I18nProperties.getValidationError(Validations.importEntryDoesNotExistDbOrDistrict, entry[i], propertyPath));
                        } else if (community.size() > 1) {
                            throw new ImportErrorException(I18nProperties.getValidationError(Validations.importCommunityNotUnique, entry[i], propertyPath));
                        } else {
                            propertyDescriptor.getWriteMethod().invoke(campaignFormData, community.get(0));
                        }
                    }
                }
            } catch (InvocationTargetException | IllegalAccessException e) {
                throw new ImportErrorException(I18nProperties.getValidationError(Validations.importErrorInColumn, propertyPath));
            } catch (IntrospectionException e) {
            // skip unknown fields
            } catch (ImportErrorException e) {
                throw e;
            } catch (Exception e) {
                LOGGER.error("Unexpected error when trying to import campaign form data: " + e.getMessage(), e);
                throw new ImportErrorException(I18nProperties.getValidationError(Validations.importUnexpectedError));
            }
        } else {
            CampaignFormDataEntry formEntry = new CampaignFormDataEntry(propertyPath, entry[i]);
            Optional<CampaignFormElement> existingFormElement = campaignMetaDto.getCampaignFormElements().stream().filter(e -> e.getId().equals(formEntry.getId())).findFirst();
            if (!existingFormElement.isPresent()) {
                // skip unknown fields
                continue;
            } else if (Objects.nonNull(formEntry.getValue()) && StringUtils.isNotBlank(formEntry.getValue().toString()) && !isEntryValid(existingFormElement.get(), formEntry)) {
                throw new ImportErrorException(I18nProperties.getValidationError(Validations.importWrongDataTypeError, entry[i], propertyPath));
            }
            if (formEntry.getValue() == null || StringUtils.isBlank(formEntry.getValue().toString())) {
                continue;
            }
            // Convert yes/no values to true/false
            if (CampaignFormElementType.YES_NO.toString().equals(existingFormElement.get().getType())) {
                String value = formEntry.getValue().toString();
                if ("yes".equalsIgnoreCase(value) || "true".equalsIgnoreCase(value)) {
                    formEntry.setValue(true);
                } else if ("no".equalsIgnoreCase(value) || "false".equalsIgnoreCase(value)) {
                    formEntry.setValue(false);
                }
            }
            if (Objects.nonNull(campaignFormData.getFormValues())) {
                List<CampaignFormDataEntry> currentElementFormValues = campaignFormData.getFormValues();
                currentElementFormValues.add(formEntry);
                campaignFormData.setFormValues(currentElementFormValues);
            } else {
                List<CampaignFormDataEntry> formValues = new LinkedList<>();
                formValues.add(formEntry);
                campaignFormData.setFormValues(formValues);
            }
        }
    }
    ImportLineResultDto<CampaignFormDataDto> constraintErrors = validateConstraints(campaignFormData);
    if (constraintErrors.isError()) {
        throw new ImportErrorException(constraintErrors.getMessage());
    }
}

Example 19 with InvalidColumnException

use of de.symeda.sormas.api.importexport.InvalidColumnException in project SORMAS-Project by hzi-braunschweig.

the class CampaignFormDataImporter method importDataFromCsvLine.

@Override
protected ImportLineResult importDataFromCsvLine(String[] values, String[] entityClasses, String[] entityProperties, String[][] entityPropertyPaths, boolean firstLine) throws IOException, InterruptedException {
    if (values.length > entityProperties.length) {
        writeImportError(values, I18nProperties.getValidationError(Validations.importLineTooLong));
        return ImportLineResult.ERROR;
    }
    CampaignFormDataDto campaignFormData = CampaignFormDataDto.build();
    campaignFormData.setCreatingUser(userFacade.getCurrentUserAsReference());
    try {
        insertImportRowIntoData(campaignFormData, values, entityProperties);
        campaignFormData.setCampaign(campaignReferenceDto);
        CampaignFormDataDto existingData = FacadeProvider.getCampaignFormDataFacade().getExistingData(new CampaignFormDataCriteria().campaign(campaignFormData.getCampaign()).campaignFormMeta(campaignFormData.getCampaignFormMeta()).community(campaignFormData.getCommunity()).formDate(campaignFormData.getFormDate()));
        if (existingData != null) {
            final CampaignFormDataImportLock lock = new CampaignFormDataImportLock();
            synchronized (lock) {
                handleDetectedDuplicate(campaignFormData, existingData, lock);
                try {
                    if (!lock.wasNotified) {
                        lock.wait();
                    }
                } catch (InterruptedException e) {
                    logger.error("InterruptedException when trying to perform LOCK.wait() in campaign form data import: " + e.getMessage());
                    throw e;
                }
                if (lock.similarityChoice == CampaignFormDataSimilarityChoice.CANCEL) {
                    cancelImport();
                    return ImportLineResult.SKIPPED;
                } else if (lock.similarityChoice == CampaignFormDataSimilarityChoice.SKIP) {
                    return ImportLineResult.SKIPPED;
                } else {
                    FacadeProvider.getCampaignFormDataFacade().overwriteCampaignFormData(existingData, campaignFormData);
                }
            }
        } else {
            FacadeProvider.getCampaignFormDataFacade().saveCampaignFormData(campaignFormData);
        }
    } catch (ImportErrorException | InvalidColumnException | ValidationRuntimeException e) {
        writeImportError(values, e.getLocalizedMessage());
        return ImportLineResult.ERROR;
    }
    return ImportLineResult.SUCCESS;
}

Example 20 with InvalidColumnException

use of de.symeda.sormas.api.importexport.InvalidColumnException in project SORMAS-Project by hzi-braunschweig.

the class CountryImporter method importDataFromCsvLine.

@Override
protected ImportLineResult importDataFromCsvLine(String[] values, String[] entityClasses, String[] entityProperties, String[][] entityPropertyPaths, boolean firstLine) throws IOException, InvalidColumnException {
    if (values.length > entityProperties.length) {
        writeImportError(values, I18nProperties.getValidationError(Validations.importLineTooLong));
        return ImportLineResult.ERROR;
    }
    CountryDto newEntityDto = CountryDto.build();
    boolean iHasImportError = insertRowIntoData(values, entityClasses, entityPropertyPaths, false, (cellData) -> {
        try {
            if (!StringUtils.isEmpty(cellData.getValue())) {
                insertColumnEntryIntoData(newEntityDto, cellData.getValue(), cellData.getEntityPropertyPath());
            }
        } catch (ImportErrorException | InvalidColumnException e) {
            return e;
        }
        return null;
    });
    if (!iHasImportError) {
        try {
            FacadeProvider.getCountryFacade().save(newEntityDto, allowOverwrite);
            return ImportLineResult.SUCCESS;
        } catch (EmptyValueException e) {
            writeImportError(values, e.getMessage());
            return ImportLineResult.ERROR;
        } catch (ValidationRuntimeException e) {
            writeImportError(values, e.getMessage());
            return ImportLineResult.DUPLICATE;
        }
    } else {
        return ImportLineResult.ERROR;
    }
}