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