gerrit.onap Code Review - ccsdk/sli.git/blob

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