--- /dev/null
+/*-
+ * ============LICENSE_START=======================================================
+ * ECOMP-REST
+ * ================================================================================
+ * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved.
+ * ================================================================================
+ * 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.
+ * ============LICENSE_END=========================================================
+ */
+
+package org.openecomp.policy.rest.util;
+
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Map;
+import java.util.Map.Entry;
+
+import org.apache.commons.lang.StringUtils;
+import org.apache.commons.logging.Log;
+import org.apache.commons.logging.LogFactory;
+import org.eclipse.emf.common.util.EList;
+import org.eclipse.emf.common.util.TreeIterator;
+import org.eclipse.emf.ecore.EAnnotation;
+import org.eclipse.emf.ecore.EClass;
+import org.eclipse.emf.ecore.EClassifier;
+import org.eclipse.emf.ecore.EEnum;
+import org.eclipse.emf.ecore.EObject;
+import org.eclipse.emf.ecore.EPackage;
+import org.eclipse.emf.ecore.EReference;
+import org.eclipse.emf.ecore.EStructuralFeature;
+
+import org.json.JSONObject;
+import org.openecomp.policy.rest.XACMLRestProperties;
+
+import com.att.research.xacml.util.XACMLProperties;
+
+import org.eclipse.emf.common.util.URI;
+import org.eclipse.emf.ecore.resource.Resource;
+import org.eclipse.emf.ecore.resource.ResourceSet;
+import org.eclipse.emf.ecore.resource.impl.ResourceSetImpl;
+import org.eclipse.emf.ecore.xmi.impl.XMIResourceFactoryImpl;
+
+
+public class MSModelUtitils {
+
+ private static final Log logger = LogFactory.getLog(MSModelUtitils.class);
+
+ private HashMap<String,MSAttributeObject > classMap = new HashMap<String,MSAttributeObject>();
+
+ public HashMap<String, MSAttributeObject> processEpackage(String xmiFile){
+ EPackage root = getEpackage(xmiFile);
+ TreeIterator<EObject> treeItr = root.eAllContents();
+ String className = null;
+ String returnValue = null;
+
+ // Pulling out dependency from file
+ while (treeItr.hasNext()) {
+ EObject obj = (EObject) treeItr.next();
+ if (obj instanceof EClassifier) {
+ EClassifier eClassifier = (EClassifier) obj;
+ className = eClassifier.getName();
+
+ if (obj instanceof EEnum) {
+ // getEEnum();
+ returnValue = null;
+ }else if (obj instanceof EClass) {
+ String temp = getDependencyList(eClassifier, className).toString();
+ returnValue = StringUtils.replaceEach(temp, new String[]{"[", "]"}, new String[]{"", ""});
+ getAttributes(className, returnValue, root);
+ }
+ }
+ }
+ return classMap;
+ }
+
+ private EPackage getEpackage(String xmiFile) {
+ ResourceSet resSet = new ResourceSetImpl();
+ Resource.Factory.Registry reg = Resource.Factory.Registry.INSTANCE;
+ Map<String, Object> m = reg.getExtensionToFactoryMap();
+ m.put("xmi", new XMIResourceFactoryImpl());
+ Resource resource = resSet.getResource(URI.createFileURI(xmiFile), true);
+ try {
+ resource.load(Collections.EMPTY_MAP);
+ } catch (IOException e) {
+ logger.error("Error loading Encore Resource for new Model");
+ }
+
+ EPackage root = (EPackage) resource.getContents().get(0);
+
+ return root;
+ }
+
+ private void getEEnum() {
+
+ }
+
+ public void getAttributes(String className, String dependency, EPackage root) {
+ List<String> dpendList = null;
+ if (dependency!=null){
+ dpendList = new ArrayList<String>(Arrays.asList(dependency.split(",")));
+ }
+ MSAttributeObject msAttributeObject = new MSAttributeObject();
+ msAttributeObject.setClassName(className);
+ HashMap<String, String> returnRefList = getRefAttributeList(root, className);
+ HashMap<String, String> returnAttributeList = getAttributeList(root, className);
+ HashMap<String, String> returnSubList = getSubAttributeList(root, className);
+ msAttributeObject.setAttribute(returnAttributeList);
+ msAttributeObject.setRefAttribute(returnRefList);
+ msAttributeObject.setSubClass(returnSubList);
+ msAttributeObject.setDependency(dpendList.toString());
+ this.classMap.put(className, msAttributeObject);
+ }
+
+ private HashMap<String, String> getSubAttributeList(EPackage root, String className) {
+ //EPackage root = (EPackage) resource.getContents().get(0);
+ TreeIterator<EObject> treeItr = root.eAllContents();
+ boolean requiredAttribute = false;
+ HashMap<String, String> subAttribute = new HashMap<String, String>();
+ int rollingCount = 0;
+ int processClass = 0;
+ boolean annotation = false;
+
+ // Pulling out dependency from file
+ while (treeItr.hasNext() && rollingCount < 2) {
+
+ EObject obj = treeItr.next();
+ if (obj instanceof EClassifier) {
+ requiredAttribute = isRequiredAttribute(obj, className);
+ if (requiredAttribute){
+ processClass++;
+ }
+ rollingCount = rollingCount+processClass;
+ }
+
+ if (requiredAttribute) {
+ if (obj instanceof EStructuralFeature) {
+ EStructuralFeature eStrucClassifier = (EStructuralFeature) obj;
+ if (eStrucClassifier.getEAnnotations().size() != 0) {
+ annotation = testAnnotation(eStrucClassifier);
+ if (annotation && obj instanceof EReference) {
+ EClass refType = ((EReference) obj).getEReferenceType();
+ // String array = arrayCheck(((EStructuralFeature) obj).getUpperBound());
+ if(!refType.toString().contains("eProxyURI:")){
+ subAttribute.put(eStrucClassifier.getName(), refType.getName());
+ }
+ }
+ }
+ }
+ }
+ }
+ return subAttribute;
+ }
+
+ public String checkDefultValue(String defultValue) {
+ if (defultValue!=null){
+ return ":defaultValue-"+ defultValue;
+ }
+ return ":defaultValue-NA";
+
+ }
+
+ public String checkRequiredPattern(int upper, int lower) {
+ String pattern = XACMLProperties.getProperty(XACMLRestProperties.PROP_XCORE_REQUIRED_PATTERN);
+
+ if (pattern!=null){
+ if (upper == Integer.parseInt(pattern.split(",")[1]) && lower==Integer.parseInt(pattern.split(",")[0])){
+ return ":required-true";
+ }
+ }
+
+ return ":required-false";
+ }
+
+ public JSONObject buildJavaObject(HashMap<String, String> map, String attributeType){
+
+ JSONObject returnValue = new JSONObject(map);
+
+ return returnValue;
+
+ }
+
+ public HashMap<String, String> getRefAttributeList(EPackage root, String className){
+
+ TreeIterator<EObject> treeItr = root.eAllContents();
+ boolean requiredAttribute = false;
+ HashMap<String, String> refAttribute = new HashMap<String, String>();
+ int rollingCount = 0;
+ int processClass = 0;
+ boolean annotation = false;
+
+ // Pulling out dependency from file
+ while (treeItr.hasNext()) {
+ EObject obj = treeItr.next();
+ if (obj instanceof EClassifier) {
+ requiredAttribute = isRequiredAttribute(obj, className);
+ if (requiredAttribute){
+ processClass++;
+ }
+ rollingCount = rollingCount+processClass;
+ }
+
+ if (requiredAttribute) {
+ if (obj instanceof EStructuralFeature) {
+ EStructuralFeature eStrucClassifier = (EStructuralFeature) obj;
+ if (eStrucClassifier.getEAnnotations().size() != 0) {
+ annotation = testAnnotation(eStrucClassifier);
+ if ( annotation && obj instanceof EReference) {
+ EClass refType = ((EReference) obj).getEReferenceType();
+ if(refType.toString().contains("eProxyURI:")){
+ String one = refType.toString().split("eProxyURI:")[1];
+ String refValue = StringUtils.replaceEach(one.split("#")[1], new String[]{"//", ")"}, new String[]{"", ""});
+ refAttribute.put(eStrucClassifier.getName(), refValue);
+ } else {
+ String array = arrayCheck(((EStructuralFeature) obj).getUpperBound());
+ if (array.contains("false")){
+ array = "";
+ }
+ refAttribute.put(eStrucClassifier.getName(), refType.getName() + array);
+ }
+ }
+ }
+ }
+ }
+ }
+ return refAttribute;
+ }
+
+ private boolean testAnnotation(EStructuralFeature eStrucClassifier) {
+ String annotationType = null;
+ EAnnotation eAnnotation = null;
+ String ecompType = null;
+
+ EList<EAnnotation> value = eStrucClassifier.getEAnnotations();
+
+ for (int i = 0; i < value.size(); i++){
+ annotationType = value.get(i).getSource();
+ eAnnotation = eStrucClassifier.getEAnnotations().get(i);
+ ecompType = eAnnotation.getDetails().get(0).getValue();
+ if (annotationType.contains("http://localhost.com") && ecompType.contains("configuration")){
+ return true;
+ }
+ }
+
+ return false;
+ }
+
+ public boolean isRequiredAttribute(EObject obj, String className){
+ EClassifier eClassifier = (EClassifier) obj;
+ String workingClass = eClassifier.getName();
+ workingClass.trim();
+ if (workingClass.equalsIgnoreCase(className)){
+ return true;
+ }
+
+ return false;
+ }
+
+ public HashMap<String, String> getAttributeList(EPackage root, String className){
+
+ TreeIterator<EObject> treeItr = root.eAllContents();
+ boolean reference = false;
+ boolean requiredAttribute = false;
+ HashMap<String, String> refAttribute = new HashMap<String, String>();
+ String workingClass = null;
+ boolean annotation = false;
+
+ // Pulling out dependency from file
+ while (treeItr.hasNext()) {
+ reference = false;
+ EObject obj = treeItr.next();
+ if (obj instanceof EClassifier) {
+ requiredAttribute = isRequiredAttribute(obj, className );
+ }
+
+ if (requiredAttribute){
+ if (obj instanceof EStructuralFeature) {
+ EStructuralFeature eStrucClassifier = (EStructuralFeature) obj;
+ if (eStrucClassifier.getEAnnotations().size() != 0) {
+ annotation = testAnnotation(eStrucClassifier);
+ if (annotation && !(obj instanceof EReference)) {
+ String name = eStrucClassifier.getName();
+ String defaultValue = checkDefultValue(((EStructuralFeature) obj).getDefaultValueLiteral());
+ String eType = eStrucClassifier.getEType().getInstanceClassName();
+ String array = arrayCheck(((EStructuralFeature) obj).getUpperBound());
+ String required = checkRequiredPattern(((EStructuralFeature) obj).getUpperBound(), ((EStructuralFeature) obj).getLowerBound());
+ String attributeValue = eType + defaultValue + required + array;
+ refAttribute.put(name, attributeValue);
+ }
+ }
+ }
+ }
+ }
+ return refAttribute;
+
+ }
+
+ public String arrayCheck(int upperBound) {
+
+ if (upperBound == -1){
+ return ":MANY-true";
+ }
+
+ return ":MANY-false";
+ }
+
+ public List<String> getDependencyList(EClassifier eClassifier, String className){
+ List<String> returnValue = new ArrayList<>();;
+ EList<EClass> somelist = ((EClass) eClassifier).getEAllSuperTypes();
+ if (somelist.isEmpty()){
+ return returnValue;
+ }
+ for(EClass depend: somelist){
+ if (depend.toString().contains("eProxyURI:")){
+ String one = depend.toString().split("eProxyURI:")[1];
+ String value = StringUtils.replaceEach(one.split("#")[1], new String[]{"//", ")"}, new String[]{"", ""});
+ returnValue.add(value);
+ }
+ }
+
+ return returnValue;
+ }
+
+ public String createJson(HashMap<String, String> subClassAttributes, HashMap<String, MSAttributeObject> classMap, String className) {
+ String json = "";
+ JSONObject jsonObj;
+
+ jsonObj = new JSONObject();
+
+ Map<String, String> missingValues = new HashMap<String, String>();
+ Map<String, String> workingMap = new HashMap<String, String>();
+
+ for ( Entry<String, String> map : classMap.get(className).getRefAttribute().entrySet()){
+ String value = map.getValue().split(":")[0];
+ if (value!=null){
+ workingMap = classMap.get(value).getRefAttribute();
+ for ( Entry<String, String> subMab : workingMap.entrySet()){
+ String value2 = subMab.getValue().split(":")[0];
+ if (!subClassAttributes.containsValue(value2)){
+ missingValues.put(subMab.getKey(), subMab.getValue());
+ classMap.get(value).addAttribute(subMab.getKey(), subMab.getValue());
+ }
+ }
+
+ }
+ }
+
+ if (!missingValues.isEmpty()){
+ for (Entry<String, String> addValue : missingValues.entrySet()){
+ subClassAttributes.put(addValue.getKey(), addValue.getValue().split(":")[0]);
+ }
+ }
+
+ for ( Map.Entry<String, String> map : subClassAttributes.entrySet()){
+ jsonObj.put(map.getValue().split(":")[0], classMap.get(map.getValue().split(":")[0]).getAttribute());
+ }
+
+ if (logger.isDebugEnabled()) {
+ logger.debug("Json value: " + jsonObj);
+ }
+
+ return jsonObj.toString();
+ }
+
+ public String createSubAttributes(ArrayList<String> dependency, HashMap<String, MSAttributeObject> classMap, String modelName) {
+
+ HashMap <String, String> workingMap = new HashMap<String,String>();
+ MSAttributeObject tempObject = new MSAttributeObject();
+ HashMap <String, String> refAttribute = new HashMap<String,String>();
+ HashMap <String, String> workingSubMap = new HashMap<String,String>();
+ Map<String, String> tempPefAttribute = null;
+ LinkedList linkedList = new LinkedList();
+ String addedValue = null;
+
+ boolean addingValues = false;
+
+ if (dependency!=null){
+ if (dependency.size()==0){
+ return "{}";
+ }
+ dependency.add(modelName);
+ for (String element: dependency){
+ tempObject = classMap.get(element);
+ if (tempObject!=null){
+ workingMap.putAll(classMap.get(element).getSubClass());
+ // workingSubMap = CheckForSecondSubClass(classMap.get(element).getSubClass(), classMap);
+ // if (workingSubMap!=null){
+ // workingMap.putAll(workingSubMap);
+ // }
+ }
+ }
+ }
+
+ String returnValue = createJson(workingMap, classMap, modelName);
+ return returnValue;
+ }
+
+ private HashMap<String, String> CheckForSecondSubClass(HashMap<String, String> subClass, HashMap<String, MSAttributeObject> mainMap) {
+ MSAttributeObject tempObject = new MSAttributeObject();
+ HashMap<String, String> subClassValue = new HashMap<String,String>();
+
+ for (Entry<String, String> classSet : subClass.entrySet()){
+ String key = classSet.getKey();
+ String value = classSet.getValue();
+ tempObject = mainMap.get(value);
+ subClassValue = tempObject.getSubClass();
+ if (subClassValue!=null){
+ return subClassValue;
+ }
+ }
+ return null;
+
+ }
+
+ public ArrayList<String> getFullDependencyList(ArrayList<String> dependency, HashMap<String,MSAttributeObject > classMap) {
+ ArrayList<String> returnList = new ArrayList<String>();
+ ArrayList<String> workingList = new ArrayList<String>();
+ int i = 0;
+ MSAttributeObject newDepend = null;
+ returnList.addAll(dependency);
+ for (String element : dependency ){
+ if (classMap.containsKey(element)){
+ MSAttributeObject value = classMap.get(element);
+ String rawValue = StringUtils.replaceEach(value.getDependency(), new String[]{"[", "]"}, new String[]{"", ""});
+ workingList = new ArrayList<String>(Arrays.asList(rawValue.split(",")));
+ for(String depend : workingList){
+ if (!returnList.contains(depend) && !depend.isEmpty()){
+ returnList.add(depend.trim());
+ }
+ }
+ }
+ }
+
+ return returnList;
+ }
+}
Code Review / policy / engine.git / blobdiff