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 (String k : mm.keySet()) {
 136                 Object v = mm.get(k);
 137                 if (v instanceof String) {
 138                     String s = escape ? escapeXml((String) v) : (String) v;
 139                     ss.append(pad(indent)).append('<').append(k).append('>');
 140                     ss.append(s);
 141                     ss.append("</").append(k).append('>').append('\n');
 142                 } else if (v instanceof Map) {
 143                     ss.append(pad(indent)).append('<').append(k).append('>').append('\n');
 144                     ss.append(generateXml(v, indent + 1, escape));
 145                     ss.append(pad(indent)).append("</").append(k).append('>').append('\n');
 146                 } else if (v instanceof List) {
 147                     List<Object> ll = (List<Object>) v;
 148                     for (Object o1 : ll) {
 149                         ss.append(pad(indent)).append('<').append(k).append('>').append('\n');
 150                         ss.append(generateXml(o1, indent + 1, escape));
 151                         ss.append(pad(indent)).append("</").append(k).append('>').append('\n');
 152                     }
 153                 }
 154             }
 155             return ss.toString();
 156         }
 157
 158         return null;
 159     }
 160
 161     private static String generateJson(Object o, boolean escape) {
 162         if (o == null)
 163             return null;
 164
 165         StringBuilder ss = new StringBuilder();
 166         generateJson(ss, o, 0, false, escape);
 167         return ss.toString();
 168     }
 169
 170     @SuppressWarnings("unchecked")
 171     private static void generateJson(StringBuilder ss, Object o, int indent, boolean padFirst, boolean escape) {
 172         if (o instanceof String) {
 173             String s = escape ? escapeJson((String) o) : (String) o;
 174             if (padFirst)
 175                 ss.append(pad(indent));
 176             ss.append('"').append(s).append('"');
 177             return;
 178         }
 179
 180         if (o instanceof Map) {
 181             Map<String, Object> mm = (Map<String, Object>) o;
 182
 183             if (padFirst)
 184                 ss.append(pad(indent));
 185             ss.append("{\n");
 186
 187             boolean first = true;
 188             for (String k : mm.keySet()) {
 189                 if (!first)
 190                     ss.append(",\n");
 191                 first = false;
 192
 193                 Object v = mm.get(k);
 194                 ss.append(pad(indent + 1)).append('"').append(k).append("\": ");
 195                 generateJson(ss, v, indent + 1, false, escape);
 196             }
 197
 198             ss.append("\n");
 199             ss.append(pad(indent)).append('}');
 200
 201             return;
 202         }
 203
 204         if (o instanceof List) {
 205             List<Object> ll = (List<Object>) o;
 206
 207             if (padFirst)
 208                 ss.append(pad(indent));
 209             ss.append("[\n");
 210
 211             boolean first = true;
 212             for (Object o1 : ll) {
 213                 if (!first)
 214                     ss.append(",\n");
 215                 first = false;
 216
 217                 generateJson(ss, o1, indent + 1, true, escape);
 218             }
 219
 220             ss.append("\n");
 221             ss.append(pad(indent)).append(']');
 222         }
 223     }
 224
 225     public static String removeLastCommaJson(String s) {
 226         StringBuilder sb = new StringBuilder();
 227         int k = 0;
 228         int start = 0;
 229         while (k < s.length()) {
 230             int i11 = s.indexOf('}', k);
 231             int i12 = s.indexOf(']', k);
 232             int i1 = -1;
 233             if (i11 < 0)
 234                 i1 = i12;
 235             else if (i12 < 0)
 236                 i1 = i11;
 237             else
 238                 i1 = i11 < i12 ? i11 : i12;
 239             if (i1 < 0)
 240                 break;
 241
 242             int i2 = s.lastIndexOf(',', i1);
 243             if (i2 < 0) {
 244                 k = i1 + 1;
 245                 continue;
 246             }
 247
 248             String between = s.substring(i2 + 1, i1);
 249             if (between.trim().length() > 0) {
 250                 k = i1 + 1;
 251                 continue;
 252             }
 253
 254             sb.append(s.substring(start, i2));
 255             start = i2 + 1;
 256             k = i1 + 1;
 257         }
 258
 259         sb.append(s.substring(start, s.length()));
 260
 261         return sb.toString();
 262     }
 263
 264     public static String removeEmptyStructJson(String s) {
 265         int k = 0;
 266         while (k < s.length()) {
 267             boolean curly = true;
 268             int i11 = s.indexOf('{', k);
 269             int i12 = s.indexOf('[', k);
 270             int i1 = -1;
 271             if (i11 < 0) {
 272                 i1 = i12;
 273                 curly = false;
 274             } else if (i12 < 0)
 275                 i1 = i11;
 276             else
 277                 if (i11 < i12)
 278                     i1 = i11;
 279                 else {
 280                     i1 = i12;
 281                     curly = false;
 282                 }
 283
 284             if (i1 >= 0) {
 285                 int i2 = curly ? s.indexOf('}', i1) : s.indexOf(']', i1);
 286                 if (i2 > 0) {
 287                     String value = s.substring(i1 + 1, i2);
 288                     if (value.trim().length() == 0) {
 289                         int i4 = s.lastIndexOf('\n', i1);
 290                         if (i4 < 0)
 291                             i4 = 0;
 292                         int i5 = s.indexOf('\n', i2);
 293                         if (i5 < 0)
 294                             i5 = s.length();
 295
 296                         s = s.substring(0, i4) + s.substring(i5);
 297                         k = 0;
 298                     } else
 299                         k = i1 + 1;
 300                 } else
 301                     break;
 302             } else
 303                 break;
 304         }
 305
 306         return s;
 307     }
 308
 309     public static String removeEmptyStructXml(String s) {
 310         int k = 0;
 311         while (k < s.length()) {
 312             int i1 = s.indexOf('<', k);
 313             if (i1 < 0 || i1 == s.length() - 1)
 314                 break;
 315
 316             char c1 = s.charAt(i1 + 1);
 317             if (c1 == '?' || c1 == '!') {
 318                 k = i1 + 2;
 319                 continue;
 320             }
 321
 322             int i2 = s.indexOf('>', i1);
 323             if (i2 < 0) {
 324                 k = i1 + 1;
 325                 continue;
 326             }
 327
 328             String closingTag = "</" + s.substring(i1 + 1, i2 + 1);
 329             int i3 = s.indexOf(closingTag, i2 + 1);
 330             if (i3 < 0) {
 331                 k = i2 + 1;
 332                 continue;
 333             }
 334
 335             String value = s.substring(i2 + 1, i3);
 336             if (value.trim().length() > 0) {
 337                 k = i2 + 1;
 338                 continue;
 339             }
 340
 341             int i4 = s.lastIndexOf('\n', i1);
 342             if (i4 < 0)
 343                 i4 = 0;
 344             int i5 = s.indexOf('\n', i3);
 345             if (i5 < 0)
 346                 i5 = s.length();
 347
 348             s = s.substring(0, i4) + s.substring(i5);
 349             k = 0;
 350         }
 351
 352         return s;
 353     }
 354
 355     private static String escapeXml(String v) {
 356         String s = v.replaceAll("&", "&amp;");
 357         s = s.replaceAll("<", "&lt;");
 358         s = s.replaceAll("'", "&apos;");
 359         s = s.replaceAll("\"", "&quot;");
 360         s = s.replaceAll(">", "&gt;");
 361         return s;
 362     }
 363
 364     private static String escapeJson(String v) {
 365         String s = v.replaceAll("\\\\", "\\\\\\\\");
 366         s = s.replaceAll("\"", "\\\\\"");
 367         return s;
 368     }
 369
 370     private static String pad(int n) {
 371         StringBuilder s = new StringBuilder();
 372         for (int i = 0; i < n; i++)
 373             s.append(Character.toString('\t'));
 374         return s.toString();
 375     }
 376 }