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