2 * ============LICENSE_START=======================================================
4 * ================================================================================
5 * Copyright © 2017-2018 AT&T Intellectual Property. All rights reserved.
6 * Copyright © 2017-2018 European Software Marketing Ltd.
7 * ================================================================================
8 * Licensed under the Apache License, Version 2.0 (the "License");
9 * you may not use this file except in compliance with the License.
10 * You may obtain a copy of the License at
12 * http://www.apache.org/licenses/LICENSE-2.0
14 * Unless required by applicable law or agreed to in writing, software
15 * distributed under the License is distributed on an "AS IS" BASIS,
16 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
17 * See the License for the specific language governing permissions and
18 * limitations under the License.
19 * ============LICENSE_END=========================================================
21 package org.onap.aai.modelloader.entity.model;
23 import java.io.StringReader;
24 import java.util.ArrayList;
25 import java.util.List;
26 import java.util.Objects;
27 import java.util.function.BiConsumer;
28 import java.util.stream.Collector;
29 import java.util.stream.IntStream;
30 import javax.xml.parsers.DocumentBuilder;
31 import javax.xml.parsers.DocumentBuilderFactory;
32 import org.onap.aai.cl.api.Logger;
33 import org.onap.aai.cl.eelf.LoggerFactory;
34 import org.onap.aai.modelloader.entity.Artifact;
35 import org.onap.aai.modelloader.service.ModelLoaderMsgs;
36 import org.w3c.dom.Document;
37 import org.w3c.dom.Element;
38 import org.w3c.dom.Node;
39 import org.w3c.dom.NodeList;
40 import org.xml.sax.InputSource;
43 * This class provides common behaviour for implementations of IModelParser.
45 * Some of the common behaviour takes the form of abstract methods that will be implemented in concrete classes.
47 * Some other behaviour will be overridden in concrete classes.
49 public abstract class AbstractModelArtifactParser implements IModelParser {
50 private static Logger logger = LoggerFactory.getInstance().getLogger(AbstractModelArtifactParser.class);
52 protected static final String RELATIONSHIP_DATA = "relationship-data";
53 private static final String RELATIONSHIP_KEY = "relationship-key";
54 private static final String RELATIONSHIP_VALUE = "relationship-value";
56 BiConsumer<Pair<String, String>, Node> applyRelationshipValue = (p, n) -> {
57 if (n.getNodeName().equalsIgnoreCase(RELATIONSHIP_KEY)) {
58 p.setKey(n.getTextContent().trim());
60 p.setValue(n.getTextContent().trim());
66 * This method is responsible for parsing the payload to produce a list of artifacts.
68 * @param artifactPayload the payload to be parsed
69 * @param artifactName the name of the artifact to be parsed
70 * @return List<Artifact> a list of artifacts that have been parsed from the payload.
73 public List<Artifact> parse(String artifactPayload, String artifactName) {
74 List<Artifact> modelList = new ArrayList<>();
77 DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
78 factory.setFeature("http://apache.org/xml/features/disallow-doctype-decl", true);
79 DocumentBuilder builder = factory.newDocumentBuilder();
80 InputSource is = new InputSource(new StringReader(artifactPayload));
81 Document doc = builder.parse(is);
83 IModelArtifact model = parseModel(doc.getDocumentElement(), artifactPayload);
85 if (!processParsedModel(modelList, artifactName, model)) {
88 } catch (Exception ex) {
89 logger.error(ModelLoaderMsgs.ARTIFACT_PARSE_ERROR,
90 buildArtifactParseExceptionMessage(artifactName, ex.getLocalizedMessage()));
96 private IModelArtifact parseModel(Node modelNode, String payload) {
97 IModelArtifact model = createModelArtifactInstance();
98 model.setPayload(payload);
100 Element e = (Element) modelNode;
101 model.setModelNamespace(e.getAttribute("xmlns"));
103 parseNode(modelNode, model);
105 return modelIsValid(model) ? model : null;
109 * This method is responsible for creating a new instance of IModel that represents the model id for a concrete
110 * implementation of IArtifactParser.
112 * @return IModelArtifact implementation of IModel that represents the model id for a concrete implementation of
115 abstract IModelArtifact createModelArtifactInstance();
118 * This method is responsible for the actual parsing of a node.
120 * It will do one of three things:
122 * <li>set the version id if the name of the node is the same as the name of the node that is the version Id</li>
123 * <li>if the node is contains data about the relationship it will parse the node accordingly</li>
124 * <li>if it does neither of option 1 or 2 it will parse the children of this node</li>
127 * @param node node to be parsed
128 * @param model the model artifact to be updated with either the versionId or details of dependent node
130 void parseNode(Node node, IModelArtifact model) {
131 if (node.getNodeName().equalsIgnoreCase(getVersionIdNodeName())) {
132 setVersionId(model, node);
133 } else if (node.getNodeName().equalsIgnoreCase(RELATIONSHIP_DATA)) {
134 parseRelationshipNode(node, model);
136 parseChildNodes(node, model);
141 * This method gets the name of the node that acts as the version Id for the node.
143 * @return String name of the node that acts as the version Id for the node
145 abstract String getVersionIdNodeName();
148 * This method is responsible for setting the values on the model artifact that represent the version Id. Each
149 * implementation of a IModelArtifact has its own properties that define the version Id.
151 * @param model the model artifact upon which the version Id will be set
152 * @param node the source of the data that holds the actual value of the version id to be set on the model artifact
154 abstract void setVersionId(IModelArtifact model, Node node);
157 * @param relationshipNode a node containing child nodes storing relationship data
158 * @param model artifact whose dependent node id will be update with any relationship data if it exists
160 void parseRelationshipNode(Node relationshipNode, IModelArtifact model) {
161 NodeList nodeList = getChildNodes(relationshipNode);
163 IModelId modelId = buildModelId(nodeList);
165 updateModelsDependentNodeId(model, modelId);
168 private NodeList getChildNodes(Node relationshipNode) {
169 Objects.requireNonNull(relationshipNode);
170 NodeList nodeList = relationshipNode.getChildNodes();
171 Objects.requireNonNull(nodeList);
177 * This method is responsible for building an instance of IModelId representing the id of the model.
179 * @param nodeList list of modes used to build the model id.
180 * @return IModelId instance of IModelId representing the id of the model
182 IModelId buildModelId(NodeList nodeList) {
183 Pair<String, String> relationship = IntStream.range(0, nodeList.getLength()).mapToObj(nodeList::item) //
184 .filter(this::filterRelationshipNode)
185 .collect(Collector.of(Pair::new, applyRelationshipValue, (p, n) -> p));
187 IModelId modelId = createModelIdInstance();
188 modelId.setRelationship(relationship);
194 * This method tests if a node is either one that either represents a relationship key or a relationship value.
196 * @param n the node to to be tested
197 * @return <code>true</code> if the node is either represents a relationship key or a relationship value
199 boolean filterRelationshipNode(Node n) {
200 return n.getNodeName().equalsIgnoreCase(RELATIONSHIP_KEY)
201 || n.getNodeName().equalsIgnoreCase(RELATIONSHIP_VALUE);
205 * This method is responsible for creating an instance of {@link AbstractModelArtifactParser.ModelId}
207 * @return IModelId instance of {@link AbstractModelArtifactParser.ModelId}
209 IModelId createModelIdInstance() {
210 return new ModelId();
213 private void updateModelsDependentNodeId(IModelArtifact model, IModelId modelId) {
214 if (modelId.defined()) {
215 model.addDependentModelId(modelId.toString());
220 * This method is responsible for parsing the children of a given node.
222 * @param node node whose children, if any, should be parsed.
223 * @param model model to be updated as a result of parsing the node
225 void parseChildNodes(Node node, IModelArtifact model) {
226 NodeList nodeList = node.getChildNodes();
227 for (int i = 0; i < nodeList.getLength(); i++) {
228 Node childNode = nodeList.item(i);
229 parseNode(childNode, model);
234 * Validates if the mode is valid or not by examining specific properties of the model.
236 * @param model model to be validated
237 * @return <code>true</code> if the mode is valid otherwise <code>false</code>
239 abstract boolean modelIsValid(IModelArtifact model);
242 * This method is responsible for building a message used for logging artifact parsing errors.
244 * @param artifactName the name of the artifact
245 * @param localisedMessage the message associated with the exception that is raised by the error
246 * @return String a message used for logging artifact parsing errors
248 abstract String buildArtifactParseExceptionMessage(String artifactName, String localisedMessage);
251 * This method is responsible for either adding the model artifact to the list of model artifacts or reporting an
254 * If the model is not null then it will be added to the list of artifacts otherwise an error will be logged.
256 * @param modelList the list of artifacts to which the model will be added if it is not null
257 * @param artifactName the name of the artifact
258 * @param artifactModel the model artifact to be added to the list of model artifacts
259 * @return <code>true/code> if the model is not null otherwise <code>false</code>
261 abstract boolean processParsedModel(List<Artifact> modelList, String artifactName, IModelArtifact artifactModel);
263 private class ModelId implements IModelId {
264 private String modelIdValue;
267 public void setRelationship(Pair<String, String> p) {
268 if (getModelElementRelationshipKey().equals(p.getKey())) {
269 modelIdValue = p.getValue();
274 public boolean defined() {
275 return modelIdValue != null;
279 public String toString() {
285 * This method gets the name of the key of the element relationship for the model.
287 * @return String name of the key of the element relationship for the model
289 abstract String getModelElementRelationshipKey();