restapi-call-node/provider/src/main/java/org/onap/ccsdk/sli/plugins/restapicall/XmlJsonUtil.java

   1 /*-
   2  * ============LICENSE_START=======================================================
   3  * openECOMP : SDN-C
   4  * ================================================================================
   5  * Copyright (C) 2017 AT&T Intellectual Property. All rights
   6  *                      reserved.
   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
  11  *
  12  *      http://www.apache.org/licenses/LICENSE-2.0
  13  *
  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=========================================================
  20  */
  21
  22 package org.onap.ccsdk.sli.plugins.restapicall;
  23
  24 import java.util.ArrayList;
  25 import java.util.HashMap;
  26 import java.util.List;
  27 import java.util.Map;
  28
  29 import org.slf4j.Logger;
  30 import org.slf4j.LoggerFactory;
  31
  32 public class XmlJsonUtil {
  33
  34         private static final Logger log = LoggerFactory.getLogger(XmlJsonUtil.class);
  35
  36         public static String getXml(Map<String, String> varmap, String var) {
  37                 boolean escape = true;
  38                 if (var.startsWith("'")) {
  39                         var = var.substring(1);
  40                         escape = false;
  41                 }
  42
  43                 Object o = createStructure(varmap, var);
  44                 return generateXml(o, 0, escape);
  45         }
  46
  47         public static String getJson(Map<String, String> varmap, String var) {
  48                 boolean escape = true;
  49                 if (var.startsWith("'")) {
  50                         var = var.substring(1);
  51                         escape = false;
  52                 }
  53
  54                 Object o = createStructure(varmap, var);
  55                 return generateJson(o, escape);
  56         }
  57
  58         private static Object createStructure(Map<String, String> flatmap, String var) {
  59                 if (flatmap.containsKey(var)) {
  60                         if (var.endsWith("_length") || var.endsWith("].key"))
  61                                 return null;
  62                         return flatmap.get(var);
  63                 }
  64
  65                 Map<String, Object> mm = new HashMap<>();
  66                 for (String k : flatmap.keySet())
  67                         if (k.startsWith(var + ".")) {
  68                                 int i1 = k.indexOf('.', var.length() + 1);
  69                                 int i2 = k.indexOf('[', var.length() + 1);
  70                                 int i3 = k.length();
  71                                 if (i1 > 0 && i1 < i3)
  72                                         i3 = i1;
  73                                 if (i2 > 0 && i2 < i3)
  74                                         i3 = i2;
  75                                 String k1 = k.substring(var.length() + 1, i3);
  76                                 String var1 = k.substring(0, i3);
  77                                 if (!mm.containsKey(k1)) {
  78                                         Object str = createStructure(flatmap, var1);
  79                                         if (str != null && (!(str instanceof String) || ((String) str).trim().length() > 0))
  80                                                 mm.put(k1, str);
  81                                 }
  82                         }
  83                 if (!mm.isEmpty())
  84                         return mm;
  85
  86                 boolean arrayFound = false;
  87                 for (String k : flatmap.keySet())
  88                         if (k.startsWith(var + "[")) {
  89                                 arrayFound = true;
  90                                 break;
  91                         }
  92
  93                 if (arrayFound) {
  94                         List<Object> ll = new ArrayList<>();
  95
  96                         int length = Integer.MAX_VALUE;
  97                         String lengthStr = flatmap.get(var + "_length");
  98                         if (lengthStr != null) {
  99                                 try {
 100                                         length = Integer.parseInt(lengthStr);
 101                                 } catch (Exception e) {
 102                                         log.warn("Invalid number for " + var + "_length:" + lengthStr);
 103                                 }
 104                         }
 105
 106                         for (int i = 0; i < length; i++) {
 107                                 Object v = createStructure(flatmap, var + '[' + i + ']');
 108                                 if (v == null)
 109                                         break;
 110                                 ll.add(v);
 111                         }
 112
 113                         if (!ll.isEmpty())
 114                                 return ll;
 115                 }
 116
 117                 return null;
 118         }
 119
 120         @SuppressWarnings("unchecked")
 121         private static String generateXml(Object o, int indent, boolean escape) {
 122                 if (o == null)
 123                         return null;
 124
 125                 if (o instanceof String)
 126                         return escape ? escapeXml((String) o) : (String) o;;
 127
 128                 if (o instanceof Map) {
 129                         StringBuilder ss = new StringBuilder();
 130                         Map<String, Object> mm = (Map<String, Object>) o;
 131                         for (String k : mm.keySet()) {
 132                                 Object v = mm.get(k);
 133                                 if (v instanceof String) {
 134                                         String s = escape ? escapeXml((String) v) : (String) v;
 135                                         ss.append(pad(indent)).append('<').append(k).append('>');
 136                                         ss.append(s);
 137                                         ss.append("</").append(k).append('>').append('\n');
 138                                 } else if (v instanceof Map) {
 139                                         ss.append(pad(indent)).append('<').append(k).append('>').append('\n');
 140                                         ss.append(generateXml(v, indent + 1, escape));
 141                                         ss.append(pad(indent)).append("</").append(k).append('>').append('\n');
 142                                 } else if (v instanceof List) {
 143                                         List<Object> ll = (List<Object>) v;
 144                                         for (Object o1 : ll) {
 145                                                 ss.append(pad(indent)).append('<').append(k).append('>').append('\n');
 146                                                 ss.append(generateXml(o1, indent + 1, escape));
 147                                                 ss.append(pad(indent)).append("</").append(k).append('>').append('\n');
 148                                         }
 149                                 }
 150                         }
 151                         return ss.toString();
 152                 }
 153
 154                 return null;
 155         }
 156
 157         private static String generateJson(Object o, boolean escape) {
 158                 if (o == null)
 159                         return null;
 160
 161                 StringBuilder ss = new StringBuilder();
 162                 generateJson(ss, o, 0, false, escape);
 163                 return ss.toString();
 164         }
 165
 166         @SuppressWarnings("unchecked")
 167         private static void generateJson(StringBuilder ss, Object o, int indent, boolean padFirst, boolean escape) {
 168                 if (o instanceof String) {
 169                         String s = escape ? escapeJson((String) o) : (String) o;
 170                         if (padFirst)
 171                                 ss.append(pad(indent));
 172                         ss.append('"').append(s).append('"');
 173                         return;
 174                 }
 175
 176                 if (o instanceof Map) {
 177                         Map<String, Object> mm = (Map<String, Object>) o;
 178
 179                         if (padFirst)
 180                                 ss.append(pad(indent));
 181                         ss.append("{\n");
 182
 183                         boolean first = true;
 184                         for (String k : mm.keySet()) {
 185                                 if (!first)
 186                                         ss.append(",\n");
 187                                 first = false;
 188
 189                                 Object v = mm.get(k);
 190                                 ss.append(pad(indent + 1)).append('"').append(k).append("\": ");
 191                                 generateJson(ss, v, indent + 1, false, escape);
 192                         }
 193
 194                         ss.append("\n");
 195                         ss.append(pad(indent)).append('}');
 196
 197                         return;
 198                 }
 199
 200                 if (o instanceof List) {
 201                         List<Object> ll = (List<Object>) o;
 202
 203                         if (padFirst)
 204                                 ss.append(pad(indent));
 205                         ss.append("[\n");
 206
 207                         boolean first = true;
 208                         for (Object o1 : ll) {
 209                                 if (!first)
 210                                         ss.append(",\n");
 211                                 first = false;
 212
 213                                 generateJson(ss, o1, indent + 1, true, escape);
 214                         }
 215
 216                         ss.append("\n");
 217                         ss.append(pad(indent)).append(']');
 218                 }
 219         }
 220
 221         public static String removeLastCommaJson(String s) {
 222                 StringBuilder sb = new StringBuilder();
 223                 int k = 0;
 224                 int start = 0;
 225                 while (k < s.length()) {
 226                         int i11 = s.indexOf('}', k);
 227                         int i12 = s.indexOf(']', k);
 228                         int i1 = -1;
 229                         if (i11 < 0)
 230                                 i1 = i12;
 231                         else if (i12 < 0)
 232                                 i1 = i11;
 233                         else
 234                                 i1 = i11 < i12 ? i11 : i12;
 235                         if (i1 < 0)
 236                                 break;
 237
 238                         int i2 = s.lastIndexOf(',', i1);
 239                         if (i2 < 0) {
 240                                 k = i1 + 1;
 241                                 continue;
 242                         }
 243
 244                         String between = s.substring(i2 + 1, i1);
 245                         if (between.trim().length() > 0) {
 246                                 k = i1 + 1;
 247                                 continue;
 248                         }
 249
 250                         sb.append(s.substring(start, i2));
 251                         start = i2 + 1;
 252                         k = i1 + 1;
 253                 }
 254
 255                 sb.append(s.substring(start, s.length()));
 256
 257                 return sb.toString();
 258         }
 259
 260         public static String removeEmptyStructJson(String s) {
 261                 int k = 0;
 262                 while (k < s.length()) {
 263                         boolean curly = true;
 264                         int i11 = s.indexOf('{', k);
 265                         int i12 = s.indexOf('[', k);
 266                         int i1 = -1;
 267                         if (i11 < 0) {
 268                                 i1 = i12;
 269                                 curly = false;
 270                         } else if (i12 < 0)
 271                                 i1 = i11;
 272                         else
 273                                 if (i11 < i12)
 274                                         i1 = i11;
 275                                 else {
 276                                         i1 = i12;
 277                                         curly = false;
 278                                 }
 279
 280                         if (i1 >= 0) {
 281                                 int i2 = curly ? s.indexOf('}', i1) : s.indexOf(']', i1);
 282                                 if (i2 > 0) {
 283                                         String value = s.substring(i1 + 1, i2);
 284                                         if (value.trim().length() == 0) {
 285                                                 int i4 = s.lastIndexOf('\n', i1);
 286                                                 if (i4 < 0)
 287                                                         i4 = 0;
 288                                                 int i5 = s.indexOf('\n', i2);
 289                                                 if (i5 < 0)
 290                                                         i5 = s.length();
 291
 292                                                 s = s.substring(0, i4) + s.substring(i5);
 293                                                 k = 0;
 294                                         } else
 295                                                 k = i1 + 1;
 296                                 } else
 297                                         break;
 298                         } else
 299                                 break;
 300                 }
 301
 302                 return s;
 303         }
 304
 305         public static String removeEmptyStructXml(String s) {
 306                 int k = 0;
 307                 while (k < s.length()) {
 308                         int i1 = s.indexOf('<', k);
 309                         if (i1 < 0 || i1 == s.length() - 1)
 310                                 break;
 311
 312                         char c1 = s.charAt(i1 + 1);
 313                         if (c1 == '?' || c1 == '!') {
 314                                 k = i1 + 2;
 315                                 continue;
 316                         }
 317
 318                         int i2 = s.indexOf('>', i1);
 319                         if (i2 < 0) {
 320                                 k = i1 + 1;
 321                                 continue;
 322                         }
 323
 324                         String closingTag = "</" + s.substring(i1 + 1, i2 + 1);
 325                         int i3 = s.indexOf(closingTag, i2 + 1);
 326                         if (i3 < 0) {
 327                                 k = i2 + 1;
 328                                 continue;
 329                         }
 330
 331                         String value = s.substring(i2 + 1, i3);
 332                         if (value.trim().length() > 0) {
 333                                 k = i2 + 1;
 334                                 continue;
 335                         }
 336
 337                         int i4 = s.lastIndexOf('\n', i1);
 338                         if (i4 < 0)
 339                                 i4 = 0;
 340                         int i5 = s.indexOf('\n', i3);
 341                         if (i5 < 0)
 342                                 i5 = s.length();
 343
 344                         s = s.substring(0, i4) + s.substring(i5);
 345                         k = 0;
 346                 }
 347
 348                 return s;
 349         }
 350
 351         private static String escapeXml(String v) {
 352                 String s = v.replaceAll("&", "&amp;");
 353                 s = s.replaceAll("<", "&lt;");
 354                 s = s.replaceAll("'", "&apos;");
 355                 s = s.replaceAll("\"", "&quot;");
 356                 s = s.replaceAll(">", "&gt;");
 357                 return s;
 358         }
 359
 360         private static String escapeJson(String v) {
 361                 String s = v.replaceAll("\\\\", "\\\\\\\\");
 362                 s = s.replaceAll("\"", "\\\\\"");
 363                 return s;
 364         }
 365
 366         private static String pad(int n) {
 367                 String s = "";
 368                 for (int i = 0; i < n; i++)
 369                         s += '\t';
 370                 return s;
 371         }
 372 }