• Home
• dev.ikm.jpms
• hapi-fhir-base
• 7.0.2-r9
• source code
• NarrativeTemplateManifest.java

×

Project download

Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance.
Project price only 1 $

You can buy this project and download/modify it how often you want.

ca.uhn.fhir.narrative2.NarrativeTemplateManifest Maven / Gradle / Ivy

/*-
 * #%L
 * HAPI FHIR - Core Library
 * %%
 * Copyright (C) 2014 - 2024 Smile CDR, Inc.
 * %%
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 * #L%
 */
package ca.uhn.fhir.narrative2;

import ca.uhn.fhir.context.ConfigurationException;
import ca.uhn.fhir.context.FhirContext;
import ca.uhn.fhir.i18n.Msg;
import ca.uhn.fhir.rest.server.exceptions.InternalErrorException;
import ca.uhn.fhir.util.ClasspathUtil;
import com.google.common.base.Charsets;
import com.google.common.collect.ArrayListMultimap;
import com.google.common.collect.ListMultimap;
import com.google.common.collect.Multimaps;
import jakarta.annotation.Nonnull;
import org.apache.commons.io.IOUtils;
import org.apache.commons.lang3.StringUtils;
import org.apache.commons.lang3.Validate;
import org.hl7.fhir.instance.model.api.IBase;
import org.hl7.fhir.instance.model.api.IBaseResource;
import org.hl7.fhir.instance.model.api.IPrimitiveType;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.StringReader;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.EnumSet;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Objects;
import java.util.Properties;
import java.util.function.Consumer;
import java.util.stream.Collectors;

import static org.apache.commons.lang3.StringUtils.isNotBlank;

public class NarrativeTemplateManifest implements INarrativeTemplateManifest {
	private static final Logger ourLog = LoggerFactory.getLogger(NarrativeTemplateManifest.class);

	private final ListMultimap myResourceTypeToTemplate;
	private final ListMultimap myDatatypeToTemplate;
	private final ListMultimap myNameToTemplate;
	private final ListMultimap myFragmentNameToTemplate;
	private final ListMultimap myClassToTemplate;
	private final int myTemplateCount;

	private NarrativeTemplateManifest(Collection theTemplates) {
		ListMultimap resourceTypeToTemplate = ArrayListMultimap.create();
		ListMultimap datatypeToTemplate = ArrayListMultimap.create();
		ListMultimap nameToTemplate = ArrayListMultimap.create();
		ListMultimap classToTemplate = ArrayListMultimap.create();
		ListMultimap fragmentNameToTemplate = ArrayListMultimap.create();

		for (NarrativeTemplate nextTemplate : theTemplates) {
			nameToTemplate.put(nextTemplate.getTemplateName(), nextTemplate);
			for (String nextResourceType : nextTemplate.getAppliesToResourceTypes()) {
				resourceTypeToTemplate.put(nextResourceType.toUpperCase(), nextTemplate);
			}
			for (String nextDataType : nextTemplate.getAppliesToDataTypes()) {
				datatypeToTemplate.put(nextDataType.toUpperCase(), nextTemplate);
			}
			for (Class nextAppliesToClass : nextTemplate.getAppliesToClasses()) {
				classToTemplate.put(nextAppliesToClass.getName(), nextTemplate);
			}
			for (String nextFragmentName : nextTemplate.getAppliesToFragmentNames()) {
				fragmentNameToTemplate.put(nextFragmentName, nextTemplate);
			}
		}

		myTemplateCount = theTemplates.size();
		myClassToTemplate = Multimaps.unmodifiableListMultimap(classToTemplate);
		myNameToTemplate = Multimaps.unmodifiableListMultimap(nameToTemplate);
		myResourceTypeToTemplate = Multimaps.unmodifiableListMultimap(resourceTypeToTemplate);
		myDatatypeToTemplate = Multimaps.unmodifiableListMultimap(datatypeToTemplate);
		myFragmentNameToTemplate = Multimaps.unmodifiableListMultimap(fragmentNameToTemplate);
	}

	public int getNamedTemplateCount() {
		return myTemplateCount;
	}

	@Override
	public List getTemplateByResourceName(
			@Nonnull FhirContext theFhirContext,
			@Nonnull EnumSet theStyles,
			@Nonnull String theResourceName,
			@Nonnull Collection theProfiles) {
		return getFromMap(theStyles, theResourceName.toUpperCase(), myResourceTypeToTemplate, theProfiles);
	}

	@Override
	public List getTemplateByName(
			@Nonnull FhirContext theFhirContext,
			@Nonnull EnumSet theStyles,
			@Nonnull String theName) {
		return getFromMap(theStyles, theName, myNameToTemplate, Collections.emptyList());
	}

	@Override
	public List getTemplateByFragmentName(
			@Nonnull FhirContext theFhirContext,
			@Nonnull EnumSet theStyles,
			@Nonnull String theFragmentName) {
		return getFromMap(theStyles, theFragmentName, myFragmentNameToTemplate, Collections.emptyList());
	}

	@SuppressWarnings("PatternVariableCanBeUsed")
	@Override
	public List getTemplateByElement(
			@Nonnull FhirContext theFhirContext,
			@Nonnull EnumSet theStyles,
			@Nonnull IBase theElement) {
		List retVal = Collections.emptyList();

		if (theElement instanceof IBaseResource) {
			IBaseResource resource = (IBaseResource) theElement;
			String resourceName = theFhirContext.getResourceDefinition(resource).getName();
			List profiles = resource.getMeta().getProfile().stream()
					.filter(Objects::nonNull)
					.map(IPrimitiveType::getValueAsString)
					.filter(StringUtils::isNotBlank)
					.collect(Collectors.toList());
			retVal = getTemplateByResourceName(theFhirContext, theStyles, resourceName, profiles);
		}

		if (retVal.isEmpty()) {
			retVal = getFromMap(theStyles, theElement.getClass().getName(), myClassToTemplate, Collections.emptyList());
		}

		if (retVal.isEmpty()) {
			String datatypeName =
					theFhirContext.getElementDefinition(theElement.getClass()).getName();
			retVal = getFromMap(theStyles, datatypeName.toUpperCase(), myDatatypeToTemplate, Collections.emptyList());
		}
		return retVal;
	}

	public static NarrativeTemplateManifest forManifestFileLocation(String... thePropertyFilePaths) {
		return forManifestFileLocation(Arrays.asList(thePropertyFilePaths));
	}

	public static NarrativeTemplateManifest forManifestFileLocation(Collection thePropertyFilePaths) {
		ourLog.debug("Loading narrative properties file(s): {}", thePropertyFilePaths);

		List manifestFileContents = new ArrayList<>(thePropertyFilePaths.size());
		for (String next : thePropertyFilePaths) {
			String resource = loadResource(next);
			manifestFileContents.add(resource);
		}

		return forManifestFileContents(manifestFileContents);
	}

	public static NarrativeTemplateManifest forManifestFileContents(String... theResources) {
		return forManifestFileContents(Arrays.asList(theResources));
	}

	public static NarrativeTemplateManifest forManifestFileContents(Collection theResources) {
		try {
			List templates = new ArrayList<>();
			for (String next : theResources) {
				templates.addAll(loadProperties(next));
			}
			return new NarrativeTemplateManifest(templates);
		} catch (IOException e) {
			throw new InternalErrorException(Msg.code(1808) + e);
		}
	}

	@SuppressWarnings("unchecked")
	private static Collection loadProperties(String theManifestText) throws IOException {
		Map nameToTemplate = new HashMap<>();

		Properties file = new Properties();

		file.load(new StringReader(theManifestText));
		for (Object nextKeyObj : file.keySet()) {
			String nextKey = (String) nextKeyObj;
			Validate.isTrue(
					StringUtils.countMatches(nextKey, ".") == 1, "Invalid narrative property file key: %s", nextKey);
			String name = nextKey.substring(0, nextKey.indexOf('.'));
			Validate.notBlank(name, "Invalid narrative property file key: %s", nextKey);

			NarrativeTemplate nextTemplate =
					nameToTemplate.computeIfAbsent(name, t -> new NarrativeTemplate().setTemplateName(name));

			if (nextKey.endsWith(".class")) {
				String className = file.getProperty(nextKey);
				if (isNotBlank(className)) {
					try {
						nextTemplate.addAppliesToClass((Class) Class.forName(className));
					} catch (ClassNotFoundException theE) {
						throw new InternalErrorException(Msg.code(1867) + "Could not find class " + className
								+ " declared in narrative manifest");
					}
				}
			} else if (nextKey.endsWith(".profile")) {
				String profile = file.getProperty(nextKey);
				if (isNotBlank(profile)) {
					nextTemplate.addAppliesToProfile(profile);
				}
			} else if (nextKey.endsWith(".resourceType")) {
				String resourceType = file.getProperty(nextKey);
				parseValuesAndAddToMap(resourceType, nextTemplate::addAppliesToResourceType);
			} else if (nextKey.endsWith(".fragmentName")) {
				String resourceType = file.getProperty(nextKey);
				parseValuesAndAddToMap(resourceType, nextTemplate::addAppliesToFragmentName);
			} else if (nextKey.endsWith(".dataType")) {
				String dataType = file.getProperty(nextKey);
				parseValuesAndAddToMap(dataType, nextTemplate::addAppliesToDatatype);
			} else if (nextKey.endsWith(".style")) {
				String templateTypeName = file.getProperty(nextKey).toUpperCase();
				TemplateTypeEnum templateType = TemplateTypeEnum.valueOf(templateTypeName);
				nextTemplate.setTemplateType(templateType);
			} else if (nextKey.endsWith(".contextPath")) {
				String contextPath = file.getProperty(nextKey);
				nextTemplate.setContextPath(contextPath);
			} else if (nextKey.endsWith(".narrative")) {
				String narrativePropName = name + ".narrative";
				String narrativeName = file.getProperty(narrativePropName);
				if (StringUtils.isNotBlank(narrativeName)) {
					nextTemplate.setTemplateFileName(narrativeName);
				}
			} else if (nextKey.endsWith(".title")) {
				ourLog.debug("Ignoring title property as narrative generator no longer generates titles: {}", nextKey);
			} else {
				throw new ConfigurationException(Msg.code(1868) + "Invalid property name: " + nextKey
						+ " - the key must end in one of the expected extensions "
						+ "'.profile', '.resourceType', '.dataType', '.style', '.contextPath', '.narrative', '.title'");
			}
		}

		return nameToTemplate.values();
	}

	private static void parseValuesAndAddToMap(String resourceType, Consumer addAppliesToResourceType) {
		Arrays.stream(resourceType.split(","))
				.map(String::trim)
				.filter(StringUtils::isNotBlank)
				.forEach(addAppliesToResourceType);
	}

	static String loadResource(String theName) {
		if (theName.startsWith("classpath:")) {
			return ClasspathUtil.loadResource(theName);
		} else if (theName.startsWith("file:")) {
			File file = new File(theName.substring("file:".length()));
			if (file.exists() == false) {
				throw new InternalErrorException(Msg.code(1870) + "File not found: " + file.getAbsolutePath());
			}
			try (FileInputStream inputStream = new FileInputStream(file)) {
				return IOUtils.toString(inputStream, Charsets.UTF_8);
			} catch (IOException e) {
				throw new InternalErrorException(Msg.code(1869) + e.getMessage(), e);
			}
		} else {
			throw new InternalErrorException(
					Msg.code(1871) + "Invalid resource name: '" + theName + "' (must start with classpath: or file: )");
		}
	}

	private static  List getFromMap(
			EnumSet theStyles,
			T theKey,
			ListMultimap theMap,
			Collection theProfiles) {
		return theMap.get(theKey).stream()
				.filter(t -> theStyles.contains(t.getTemplateType()))
				.filter(t -> theProfiles.isEmpty()
						|| t.getAppliesToProfiles().stream().anyMatch(theProfiles::contains))
				.collect(Collectors.toList());
	}
}