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