PageRenderTime 78ms CodeModel.GetById 21ms RepoModel.GetById 0ms app.codeStats 1ms

/MercerPoC/src/in/lnt/validations/FormValidator.java

https://bitbucket.org/team_mercer/mercer_api_production
Java | 2381 lines | 1859 code | 207 blank | 315 comment | 640 complexity | 17eeaa7c46418656d542ba51425f132e MD5 | raw file
    

  1. package in.lnt.validations;

    2. 

  2. 

    3. 

  3. import java.io.ByteArrayInputStream;

    4. 

  4. import java.io.IOException;

    5. 

  5. import java.io.UnsupportedEncodingException;

    6. 

  6. import java.text.SimpleDateFormat;

    7. 

  7. import java.util.ArrayList;

    8. 

  8. import java.util.Calendar;

    9. 

  9. import java.util.Date;

    10. 

  10. import java.util.HashMap;

    11. 

  11. import java.util.HashSet;

    12. 

  12. import java.util.Iterator;

    13. 

  13. import java.util.LinkedHashMap;

    14. 

  14. import java.util.List;

    15. 

  15. import java.util.Map;

    16. 

  16. import java.util.Map.Entry;

    17. 

  17. import java.util.Set;

    18. 

  18. import java.util.UUID;

    19. 

  19. import java.util.regex.Matcher;

    20. 

  20. import java.util.regex.Pattern;

    21. 

  21. 

    22. 

  22. import org.apache.commons.lang3.EnumUtils;

    23. 

  23. import org.apache.commons.lang3.StringUtils;

    24. 

  24. import org.json.JSONArray;

    25. 

  25. import org.json.JSONException;

    26. 

  26. import org.json.JSONObject;

    27. 

  27. import org.slf4j.Logger;

    28. 

  28. import org.slf4j.LoggerFactory;

    29. 

  29. 

    30. 

  30. import com.fasterxml.jackson.core.JsonParseException;

    31. 

  31. import com.fasterxml.jackson.core.JsonProcessingException;

    32. 

  32. import com.fasterxml.jackson.databind.JsonMappingException;

    33. 

  33. import com.fasterxml.jackson.databind.JsonNode;

    34. 

  34. import com.fasterxml.jackson.databind.ObjectMapper;

    35. 

  35. import com.fasterxml.jackson.databind.node.ArrayNode;

    36. 

  36. import com.fasterxml.jackson.databind.node.JsonNodeFactory;

    37. 

  37. import com.fasterxml.jackson.databind.node.JsonNodeType;

    38. 

  38. import com.fasterxml.jackson.databind.node.NullNode;

    39. 

  39. import com.fasterxml.jackson.databind.node.ObjectNode;

    40. 

  40. import com.lti.mosaic.function.def.InversionAndRangeCheckFunctions;

    41. 

  41. import com.lti.mosaic.parser.utils.ExpressionBuilderConstants;

    42. 

  42. import com.mongodb.util.JSON;

    43. 

  43. import com.rabbitmq.tools.json.JSONUtil;

    44. 

  44. 

    45. 

  45. import in.lnt.constants.Constants;

    46. 

  46. import in.lnt.enums.ValidationTypes;

    47. 

  47. import in.lnt.exceptions.CustomStatusException;

    48. 

  48. import in.lnt.ml.MachineLearningRestClient;

    49. 

  49. import in.lnt.parser.CSVParser;

    50. 

  50. import in.lnt.utility.constants.CacheConstats;

    51. 

  51. import in.lnt.utility.constants.ErrorCacheConstant;

    52. 

  52. import in.lnt.utility.general.Cache;

    53. 

  53. import in.lnt.utility.general.DataUtility;

    54. 

  54. import in.lnt.utility.general.JsonUtils;

    55. 

  55. import in.lnt.validations.evaluator.APIExpressionEvaluator;

    56. 

  56. import in.lti.mosaic.api.mongo.MongoObject;

    57. 

  57. import in.lti.mosaic.api.mongo.MongoThread;

    58. 

  58. 

    59. 

  59. public class FormValidator {

    60. 

  60. 	private static final Logger logger = LoggerFactory.getLogger(FormValidator.class);

    61. 

  61. 	static ObjectMapper mapper = new ObjectMapper();

    62. 

  62. 	ArrayList<String> paramValueList=null;

    63. 

  63. 	static Pattern VALID_EMAIL_ADDRESS_REGEX = 

    64. 

  64. 		    Pattern.compile("^(.+)@(.+)$", Pattern.CASE_INSENSITIVE);

    65. 

  65. 	static Pattern VALID_PHONE_NUMBER_REGEX = 

    66. 

  66. 		    Pattern.compile("^(\\(?\\+?[0-9]*\\)?)?[0-9_\\- \\(\\)]*$", Pattern.CASE_INSENSITIVE);

    67. 

  67. 	// ^[A-Z0-9._%+-]+@[A-Z0-9.-]+\\.[A-Z]{2,6}$

    68. 

  68. 	

    69. 

  69. 	private static String MONGODB_ARCHIVE_FLAG = Cache

    70. 

  70. 			.getMLProperty(in.lnt.utility.constants.CacheConstats.MONGODUMP_FLAG);

    71. 

  71. 	

    72. 

  72. 	public JsonNode parseAndValidate(String entitiesJson, String csvJsonString, boolean isAggregateRequest,

    73. 

  73. 			HashMap<String, String> xslJsonMap, String firstSheetName, boolean isMultiPartRequest) throws Exception {

    74. 

  74. 		// logger.info(String.format("%s %s", Constants.INTIATE ,Constants.LOG_PARSEANDVALIDATE));

    75. 

  75. 		JsonNode resultNode = null;

    76. 

  76. 		

    77. 

  77. 	    //Generating UUID for a Request and Response

    78. 

  78. 	    final String uuid = UUID.randomUUID().toString().replace("-", "");

    79. 

  79. 		

    80. 

  80. 		JsonNode entitiesNodeResponse = preparingL1Input(entitiesJson, csvJsonString, isAggregateRequest, xslJsonMap,

    81. 

  81. 				firstSheetName, isMultiPartRequest, null);

    82. 

  82. 		

    83. 

  83. 		//Adding Request into MongoDB

    84. 

  84. 		dumpToMongo(uuid, mapper.writeValueAsString(entitiesNodeResponse), Constants.REQUEST);

    85. 

  85. 

    86. 

  86. 		if (isAggregateRequest) {

    87. 

  87. 			resultNode = performValidateAggregateRequest(entitiesNodeResponse, isAggregateRequest, isMultiPartRequest);

    88. 

  88. 		} else

    89. 

  89. 			resultNode = perform_L1_L2Validations(entitiesNodeResponse, isAggregateRequest, isMultiPartRequest);

    90. 

  90. 		

    91. 

  91. 		//Adding Response into MongoDB

    92. 

  92. 		dumpToMongo(uuid, mapper.writeValueAsString(resultNode), Constants.RESPONSE);

    93. 

  93. 

    94. 

  94. 		return resultNode;

    95. 

  95. 	}

    96. 

  96. 

    97. 

  97. 	/**

    98. 

  98. 	 * @param uuid

    99. 

  99. 	 * @param data

    100. 

  100. 	 * @throws JsonProcessingException

    101. 

  101. 	 * @author Vivek Kasadwar

    102. 

  102. 	 */

    103. 

  103. 	public static void dumpToMongo(final String uuid, String data,String type){

    104. 

  104. 		if (StringUtils.equals(MONGODB_ARCHIVE_FLAG,Constants.YES)) {

    105. 

  105. 			MongoObject mongoObject = new MongoObject();

    106. 

  106. 			mongoObject.setRequestId(uuid);

    107. 

  107. 			mongoObject.setObjectType(type);

    108. 

  108. 			mongoObject.setObjectJson(data);

    109. 

  109. 			mongoObject.setTimeStamp(Calendar.getInstance().getTime());

    110. 

  110. 			MongoThread.addToQueue(mongoObject);

    111. 

  111. 		}

    112. 

  112. 	}

    113. 

  113. 	

    114. 

  114. 	public HashMap<String, JsonNode> parseJsonObjectMap(String key, JsonNode value, HashMap<String, JsonNode> map,

    115. 

  115. 			String datakey, JsonNode columnListJson,List<String> otherAndContextKeys) throws Exception {		// PE-7056

    116. 

  116. 		Iterator<Map.Entry<String, JsonNode>> it = value.fields();

    117. 

  117. 		Map.Entry<String, JsonNode> entry = null;

    118. 

  118. 		try {

    119. 

  119. 			while (it.hasNext()) {

    120. 

  120. 				entry = it.next();

    121. 

  121. 				if (entry.getValue().getNodeType() != JsonNodeType.OBJECT) {

    122. 

  122. 					if (datakey != null) {

    123. 

  123. 						map.put((datakey + "." + key + "." + entry.getKey()).trim(), entry.getValue());

    124. 

  124. 						if(otherAndContextKeys!=null)

    125. 

  125. 						otherAndContextKeys.add((datakey + "." + key + "." + entry.getKey()).trim());

    126. 

  126. //						addDimensionsInDatamap(datakey+"."+key, map, columnListJson);

    127. 

  127. 					} else {

    128. 

  128. 						map.put((key + "." + entry.getKey()).trim(), entry.getValue());

    129. 

  129. 						if(otherAndContextKeys!=null)

    130. 

  130. 						otherAndContextKeys.add((key + "." + entry.getKey()).trim());

    131. 

  131. 						//addDimensionsInDatamap(key, map, columnListJson);							// TODO Take this outside while.					

    132. 

  132. 					}	

    133. 

  133. 				} else {

    134. 

  134. 					parseJsonObjectMap(key + "." + entry.getKey(), entry.getValue(), map, datakey, columnListJson,otherAndContextKeys);

    135. 

  135. 				}

    136. 

  136. 			}

    137. 

  137. 		} finally {

    138. 

  138. 			if(null!=it)	it=null;

    139. 

  139. 			if(null!=entry)	entry=null;

    140. 

  140. 		}

    141. 

  141. 		return map;

    142. 

  142. 	}

    143. 

  143. 	

    144. 

  144. 	/*

    145. 

  145. 	 *  PE-7506 Populate all undefined dimensions to null.

    146. 

  146. 	 */

    147. 

  147. 	/*public static HashMap<String, JsonNode> addDimensionsInDatamap(String key, HashMap<String, JsonNode> map, JsonNode columnListJson) {

    148. 

  148. 		ArrayNode dimensionArray = null;

    149. 

  149. 		if(null!=columnListJson) {

    150. 

  150. 			for(int i=0; i<columnListJson.size(); i++) {

    151. 

  151. 				

    152. 

  152. 				if(!JsonUtils.isNullOrBlankOrNullNode(columnListJson.get(i).get(Constants.CODE))) {

    153. 

  153. 					if(key.equals(columnListJson.get(i).get(Constants.CODE).asText())) {

    154. 

  154. 						

    155. 

  155. 						if(!JsonUtils.isNullOrBlankOrNullNode(columnListJson.get(i).get(Constants.DIMENSIONS))) {

    156. 

  156. 							dimensionArray = (ArrayNode) columnListJson.get(i).get(Constants.DIMENSIONS);

    157. 

  157. 							for(int j = 0; j<dimensionArray.size(); j++) {

    158. 

  158. 								if(!JsonUtils.isNullOrBlankOrNullNode(dimensionArray.get(j))) {

    159. 

  159. 									String key_dimension = dimensionArray.get(j).asText();

    160. 

  160. 									if(!map.containsKey((key+"."+key_dimension).trim())) {

    161. 

  161. 										map.put((key+"."+key_dimension).trim(), null);

    162. 

  162. 									}

    163. 

  163. 									key_dimension = null;

    164. 

  164. 								}

    165. 

  165. 							}

    166. 

  166. 							dimensionArray = null;

    167. 

  167. 							break;

    168. 

  168. 						}

    169. 

  169. 					}

    170. 

  170. 				}

    171. 

  171. 			}

    172. 

  172. 		}

    173. 

  173. 		return map;

    174. 

  174. 	}*/

    175. 

  175. 

    176. 

  176. 	public JsonNode validate(HashMap<String, JsonNode> dataMap, ArrayList<JsonNode> columnNodeList, JsonNode dataNode,

    177. 

  177. 			 APIExpressionEvaluator apiExpressionEvaluator, boolean isAggregateRequest,

    178. 

  178. 			HashMap<String, String> columnMappingMap,HashMap<String, JsonNode> dimMap, List<String> metaDataColumnsOnly,

    179. 

  179. 			boolean mlAutoCoorect) throws Exception {

    180. 

  180. 		//logger.info(String.format("%s %s", Constants.INTIATE ,Constants.LOG_VALIDATE));

    181. 

  181. 		JsonNode validationNode = null;

    182. 

  182. 		ObjectNode obj = null;

    183. 

  183. 		ArrayList<ObjectNode> predefinedObjList = null;

    184. 

  184. 		List<ObjectNode> rangeOrSeqObjList = null;

    185. 

  185. 		String code = null;

    186. 

  186. 		String mappedColumnName = null;

    187. 

  187. 		ArrayNode arr = null;

    188. 

  188. 		JsonNode nodeDTObject = null;

    189. 

  189. 		JsonNode dnCodeObject = null;

    190. 

  190. 		Boolean flag = null;

    191. 

  191. 		String result = null;

    192. 

  192. 		String skip = null;

    193. 

  193. 		JsonNode validationObjNode = null;

    194. 

  194. 		ObjectNode jobInversionObjNode = null;

    195. 

  195. 		ArrayNode jobInversionArr = null;

    196. 

  196. 		// PE-5643 by default true because for true type do not fire validations.

    197. 

  197. 		boolean isOptionType = true;

    198. 

  198. 		String countryCode = null;

    199. 

  199. 		String __COMPENSATION = null;

    200. 

  200. 		String jobInvParameter = null;

    201. 

  201. 

    202. 

  202. 		// PE-5691

    203. 

  203. 		boolean isEmtpyRecord = false;

    204. 

  204. 

    205. 

  205. 		// PE - 7257

    206. 

  206. 		ArrayNode datePatternArray = null;

    207. 

  207. 		ArrayNode numberPatternArray = null;

    208. 

  208. 		String columnName = null;

    209. 

  209. 		JsonNode tempOriginalValue = null;

    210. 

  210. 		// 8421 code changes.

    211. 

  211. 		Map<String, String> incorrectDataType = new HashMap<>();

    212. 

  212. 		JsonNode questionType = null; // Added for 8916 Remove %

    213. 

  213. 		String dataType = null;

    214. 

  214. 			if (columnNodeList != null && columnNodeList.size() > 0) {

    215. 

  215. 				arr = mapper.createArrayNode();

    216. 

  216. 				if (!JsonUtils.isNullOrBlankOrNullNode(dataMap.get(Constants.CONTEXTDATAKEY+Constants.CONTEXTDATA_DATEFORMAT))){

    217. 

  217. 					datePatternArray = (ArrayNode)dataMap.get(Constants.CONTEXTDATAKEY+Constants.CONTEXTDATA_DATEFORMAT);

    218. 

  218. 				}if (!JsonUtils.isNullOrBlankOrNullNode(dataMap.get(Constants.CONTEXTDATAKEY+Constants.CONTEXTDATA_NUMBERFORMAT))){

    219. 

  219. 					numberPatternArray = (ArrayNode)dataMap.get(Constants.CONTEXTDATAKEY+Constants.CONTEXTDATA_NUMBERFORMAT);

    220. 

  220. 				}

    221. 

  221. 				

    222. 

  222. 				// If request is AggregateRequest

    223. 

  223. 				// L3A - Inversion/Aggregate Request Starts Here

    224. 

  224. 				if (isAggregateRequest) {

    225. 

  225. 					// PE - 7257

    226. 

  226. 					for (JsonNode node : columnNodeList) {

    227. 

  227. 						if (node.get(Constants.VALIDATIONS) != null && node.get(Constants.VALIDATIONS).size() > 0) {

    228. 

  228. 

    229. 

  229. 							for (int i = 0; i < node.get(Constants.VALIDATIONS).size(); i++) {

    230. 

  230. 

    231. 

  231. 								validationNode = node.get(Constants.VALIDATIONS).get(i);

    232. 

  232. 

    233. 

  233. 								// For Inversion

    234. 

  234. 								obj = apiExpressionEvaluator.expressionEvaluator(dataMap, validationNode, node,

    235. 

  235. 										dataNode,isAggregateRequest, columnMappingMap, columnNodeList, metaDataColumnsOnly);

    236. 

  236. 								if (obj != null) {

    237. 

  237. 									arr.add(obj);

    238. 

  238. 									obj = null;

    239. 

  239. 								}

    240. 

  240. 							}

    241. 

  241. 						}

    242. 

  242. 					}

    243. 

  243. 

    244. 

  244. 					// PE-4843 Append JobInversion Object

    245. 

  245. 					

    246. 

  246. 					//logger.info("Before calling JobInversion.jobInversion()...");

    247. 

  247. 					

    248. 

  248. 					InversionAndRangeCheckFunctions invAndRangeChkFuncObj 

    249. 

  249. 							= new InversionAndRangeCheckFunctions(CSVParser.dataForAggregation, apiExpressionEvaluator.getExpressionEvaluatorDriver().getOtherData());  

    250. 

  250. 					Map<String, Object> requestMap =  invAndRangeChkFuncObj.jobInversion();  // Changed by Nikhil

    251. 

  251. 					

    252. 

  252. 					if (requestMap.containsKey(ExpressionBuilderConstants.CONST_INVERSION_JSON_ARRAY)

    253. 

  253. 							&& null != requestMap.get(ExpressionBuilderConstants.CONST_INVERSION_JSON_ARRAY)) {

    254. 

  254. 						jobInversionArr = (ArrayNode) mapper.readTree(

    255. 

  255. 										requestMap.get(ExpressionBuilderConstants.CONST_INVERSION_JSON_ARRAY).toString());

    256. 

  256. 					}

    257. 

  257. 

    258. 

  258. 					if(requestMap.containsKey(ExpressionBuilderConstants.CONST_COUNTRYCODE) 

    259. 

  259. 							&& null!=requestMap.get(ExpressionBuilderConstants.CONST_COUNTRYCODE)) {

    260. 

  260. 						countryCode = requestMap.get(ExpressionBuilderConstants.CONST_COUNTRYCODE).toString();

    261. 

  261. 					}

    262. 

  262. 

    263. 

  263. 					if(requestMap.containsKey(ExpressionBuilderConstants.CONST___COMPENSATION) 

    264. 

  264. 							&& null!=requestMap.get(ExpressionBuilderConstants.CONST___COMPENSATION)) {

    265. 

  265. 						__COMPENSATION = requestMap.get(ExpressionBuilderConstants.CONST___COMPENSATION).toString();

    266. 

  266. 						

    267. 

  267. 						if(__COMPENSATION.equals(ExpressionBuilderConstants.SALARY_TYPE_TOTAL_GUARANTEED_CASH)) {

    268. 

  268. 							__COMPENSATION = ExpressionBuilderConstants.COL_TOTAL_GUARANTEED_CASH;

    269. 

  269. 							jobInvParameter = ExpressionBuilderConstants.SALARY_TYPE_MSG_TOTAL_GUARANTEED_CASH;

    270. 

  270. 						} else {

    271. 

  271. 							__COMPENSATION = ExpressionBuilderConstants.COL_ANNUAL_BASE;

    272. 

  272. 							jobInvParameter = ExpressionBuilderConstants.SALARY_TYPE_MSG_REGULAR;

    273. 

  273. 						}

    274. 

  274. 					}

    275. 

  275. 					

    276. 

  276. 					logger.info("Creating JobInversion object...");

    277. 

  277. 					jobInversionObjNode = mapper.createObjectNode();

    278. 

  278. 					jobInversionObjNode.put(Constants.ERROR_GROUP, Constants.PERSONAL);

    279. 

  279. 					jobInversionObjNode.put(Constants.ERROR_TYPE, Constants.ERROR);

    280. 

  280. 					jobInversionObjNode.put(Constants.VALIDATION_TYPE, Constants.EXPRESSION);

    281. 

  281. 					jobInversionObjNode.put(Constants.MESSAGE, Constants.JOB_INVERSION_ERRORS);

    282. 

  282. 					jobInversionObjNode.put(Constants.FIELD, __COMPENSATION);

    283. 

  283. 					jobInversionObjNode.put(Constants.CATEGORY, Constants.JOB_INVERSION);

    284. 

  284. 					jobInversionObjNode.put(Constants.PARAMETER, jobInvParameter);

    285. 

  285. 					

    286. 

  286. 					jobInversionObjNode.putArray(Constants.DATA).addAll(jobInversionArr);

    287. 

  287. 					

    288. 

  288. 					arr.add(jobInversionObjNode);

    289. 

  289. 					

    290. 

  290. 					JsonNode objectNode = mapper.convertValue(arr, JsonNode.class);

    291. 

  291. 					return objectNode;

    292. 

  292. 				}

    293. 

  293. 				

    294. 

  294. 				// L3A - Inversion/Aggregate Request Ends Here

    295. 

  295. 

    296. 

  296. 				for (JsonNode node : columnNodeList) {

    297. 

  297. 					isEmtpyRecord=false;

    298. 

  298. 					if (node.get(Constants.CODE) != null)

    299. 

  299. 						code = node.get(Constants.CODE).asText();

    300. 

  300. 					if (node.get(Constants.SKIP) != null)

    301. 

  301. 						skip = node.get(Constants.SKIP).asText();

    302. 

  302. 					if (node.get(Constants.MAPPED_COLUMN_NAME) != null)

    303. 

  303. 						mappedColumnName = node.get(Constants.MAPPED_COLUMN_NAME).asText();

    304. 

  304. 					

    305. 

  305. 					if ( dataNode != null || (dataNode!=null && dataNode.get(mappedColumnName) != null)) {

    306. 

  306. 						

    307. 

  307. 						//Following code written for Mercer JIRA Story PE-5691

    308. 

  308. 

    309. 

  309. 						if(skip==null ) {

    310. 

  310. 							if(code !=null && mappedColumnName!=null && JsonUtils.isNullOrBlankOrNullNode(dataNode.get(code))

    311. 

  311. 									&&  JsonUtils.isNullOrBlankOrNullNode(dataNode.get(mappedColumnName))) 

    312. 

  312. 							{

    313. 

  313. 								//((ObjectNode)dataNode).put(code, JsonNodeFactory.instance.nullNode()) ;  

    314. 

  314. 								isEmtpyRecord = true;

    315. 

  315. 							}

    316. 

  316. 							if(code !=null && mappedColumnName ==null && JsonUtils.isNullOrBlankOrNullNode(dataNode.get(code)) )

    317. 

  317. 							{

    318. 

  318. 								isEmtpyRecord = true;

    319. 

  319. 							}

    320. 

  320. 							if(mappedColumnName !=null && code==null &&JsonUtils.isNullOrBlankOrNullNode(dataNode.get(mappedColumnName)))

    321. 

  321. 							{

    322. 

  322. 								isEmtpyRecord = true;

    323. 

  323. 							}

    324. 

  324. 							if(isEmtpyRecord)

    325. 

  325. 							{

    326. 

  326. 								((ObjectNode)dataNode).set(code, JsonNodeFactory.instance.nullNode()) ;  

    327. 

  327. 							}

    328. 

  328. 								// Modified to prepare datamap correctly in case of Dimensions in datanode

    329. 

  329. //							if(isEmtpyRecord)				// Code is reverting the ML values to original value. Commenting as per discussed with Jwala

    330. 

  330. //							{

    331. 

  331. //								it = dataNode.fields();

    332. 

  332. //								while (it.hasNext()) {

    333. 

  333. //									entry = it.next();

    334. 

  334. //									if (entry.getValue().getNodeType() != JsonNodeType.OBJECT) {

    335. 

  335. //										dataMap.put(entry.getKey().trim(), entry.getValue());

    336. 

  336. //									} else {

    337. 

  337. //										dataMap = parseJsonObjectMap(entry.getKey(), entry.getValue(), dataMap, null, null,null);

    338. 

  338. //									}

    339. 

  339. //								}

    340. 

  340. //							}

    341. 

  341. 								

    342. 

  342. 							}

    343. 

  343. 						//PE-5691 End.	

    344. 

  344. 						flag = false;

    345. 

  345. 						if ((mappedColumnName != null && dataNode.get(mappedColumnName) != null)

    346. 

  346. 								&& (null != code && mappedColumnName != null && !code.equals(mappedColumnName))) {

    347. 

  347. 							// Changing logic

    348. 

  348.  							((ObjectNode) (dataNode)).set(code, dataMap.get(mappedColumnName));

    349. 

  349. 							((ObjectNode) (dataNode)).remove(mappedColumnName);

    350. 

  350. 						}

    351. 

  351. 						if (skip != null && (skip.equals("true") || Boolean.parseBoolean(skip) == true)) {

    352. 

  352. 							if (code != null && !code.equals(""))

    353. 

  353. 								((ObjectNode) (dataNode)).remove(code);

    354. 

  354. 							else

    355. 

  355. 								((ObjectNode) (dataNode)).remove(mappedColumnName);

    356. 

  356. 							skip = null;

    357. 

  357. 							continue;

    358. 

  358. 						}

    359. 

  359. 						// Validate the data type object block starts here.

    360. 

  360. 						if(null != node.get(Constants.DATA_TYPE)){

    361. 

  361. 							dataType = node.get(Constants.DATA_TYPE).asText();

    362. 

  362. 						}

    363. 

  363. 						if (dataType != null) {

    364. 

  364. 							logger.info("Check if  dataType is not empty");

    365. 

  365. 							nodeDTObject = node.get(Constants.DATA_TYPE);

    366. 

  366. 							if (dataNode.get(code) != null)

    367. 

  367. 								dnCodeObject = dataNode.get(code);

    368. 

  368. 							else if (dataNode.get(mappedColumnName) != null)

    369. 

  369. 								dnCodeObject = dataNode.get(mappedColumnName);

    370. 

  370. 							

    371. 

  371. 							validationObjNode = node.get(Constants.VALIDATIONS);

    372. 

  372. 							

    373. 

  373. 							if ( StringUtils.isEmpty(mappedColumnName)) {

    374. 

  374. 								columnName = code;

    375. 

  375. 							}else {

    376. 

  376. 								columnName = mappedColumnName;

    377. 

  377. 							}

    378. 

  378. 							//Added for 8916 Remove %

    379. 

  379. 							 questionType = node.get(Constants.QUESTION_TYPE);

    380. 

  380. 						     if(!JsonUtils.isNullOrBlankOrNullNode(questionType) && questionType.asText().equals(Constants.PERCENTAGE)){

    381. 

  381. 						    	 if (null != dataMap && !JsonUtils.isNullOrBlankOrNullNode(dataMap.get(columnName)) && dataNode.get(columnName) != null) {

    382. 

  382. 						    	 String percentageValue = dataMap.get(columnName).asText().trim();

    383. 

  383. 						    	 if(!percentageValue.isEmpty() && percentageValue.endsWith("%")){

    384. 

  384. 						    		 percentageValue = percentageValue.substring(0, percentageValue.length()-1);

    385. 

  385. 						    		 dataMap.put(columnName, mapper.readTree(percentageValue));

    386. 

  386. 						    		 ((ObjectNode) dataNode).put(code, mapper.readTree(percentageValue));

    387. 

  387. 						    		 dnCodeObject = dataNode.get(columnName);

    388. 

  388. 						    	 }

    389. 

  389. 						    	 }

    390. 

  390. 						     }

    391. 

  391. 				          // If data node is not empty then do data type validation

    392. 

  392. 							if (!isAggregateRequest && !JsonUtils.isNullOrBlankOrNullNode(dnCodeObject)  

    393. 

  393. 									&& !isEmtpyRecord && !StringUtils.isEmpty(dnCodeObject.asText().trim())) { //PE-9268

    394. 

  394. 								//8421 code changes.

    395. 

  395. 								incorrectDataType = dataTypeCheck(dataMap, dataNode, columnName, nodeDTObject, dnCodeObject, flag,

    396. 

  396. 										datePatternArray, numberPatternArray);

    397. 

  397. 								flag = Boolean.parseBoolean(incorrectDataType.get("dataTypeFlag"));

    398. 

  398. 							} else {

    399. 

  399. 								flag = true;

    400. 

  400. 							}

    401. 

  401. 						} else { // if data node is empty then skip data type validations.

    402. 

  402. 							flag = true;

    403. 

  403. 						}

    404. 

  404. 						

    405. 

  405. 						//PE -5216 and PE-5643 Check for drop down options exist in metadata or in database.

    406. 

  406. 						// PE-5643 : Required this functionality at /uploadMulttipleFile also. (Mentioned by Alex)

    407. 

  407. 						if (questionType != null

    408. 

  408. 								&& ( questionType.asText().equals(Constants.DROPDOWN) || 

    409. 

  409. 										questionType.asText().equals(Constants.RADIO_BUTTONS) )) {

    410. 

  410. 							//logger.info(String.format("Question type is..%s", node.get("questionType").asText()));

    411. 

  411. 							

    412. 

  412. 							// PE-8070 Clear & Prepare outputJson for dimensions

    413. 

  413. 							if( !JsonUtils.isNullOrBlankOrNullNode(dataNode.get(code)) && dataNode.get(code).getNodeType()==JsonNodeType.OBJECT) {

    414. 

  414. 								Iterator<String> iter = dataNode.get(code).fieldNames();

    415. 

  415. 								String dimensionKey = null;

    416. 

  416. 								while(null!=iter && iter.hasNext() ) {

    417. 

  417. 									dimensionKey = iter.next();

    418. 

  418. 	   								isOptionType =  FormValidator_CSC.checkAnswerExists(node, dataNode.get(code).get(dimensionKey)); 

    419. 

  419. 	   								

    420. 

  420. 	   								// TODO Further task (Make it a function)	   								

    421. 

  421. 	   								if ( ! isOptionType ) {

    422. 

  422. 		   								

    423. 

  423. //	   									PE-8397

    424. 

  424. //	   									// Implementation start PE : 5643	

    425. 

  425. //	   									// Clear the value anyways if checkAnswerExists==false

    426. 

  426. //	   									((ObjectNode) (dataNode.get(code))).put(dimensionKey, "");	

    427. 

  427. //		   								// Implementation end PE : 5643

    428. 

  428. 	   									

    429. 

  429. 	   									// Generate error for dimension in format : Question1.Dimension1

    430. 

  430. 	   									obj = apiExpressionEvaluator.prepareOutputJson(null, null, null, ValidationTypes.dropDown,

    431. 

  431. 	   										code+"."+dimensionKey, null, null,node.has("displayLabel") ? node.get("displayLabel").asText() : null);

    432. 

  432. 	   								}

    433. 

  433. 	   								if (obj != null) {

    434. 

  434. 	   									arr.add(obj);

    435. 

  435. 	   									obj = null;

    436. 

  436. 	   								}

    437. 

  437. 								}

    438. 

  438. 

    439. 

  439. 							// Clear & Prepare outputJson for non-dimensional questions (ie. simple values)

    440. 

  440. 							} else {

    441. 

  441. 								// PE-6254 ML Integration works start

    442. 

  442. 								if(mlAutoCoorect )

    443. 

  443. 								{

    444. 

  444. 									isOptionType =  FormValidator_CSC.checkAnswerExists(node, dataMap.get(code));

    445. 

  445. 								}

    446. 

  446. 								else

    447. 

  447. 								{

    448. 

  448. 									isOptionType =  FormValidator_CSC.checkAnswerExists(node, dataNode.get(code));

    449. 

  449. 								}

    450. 

  450. 								

    451. 

  451. 								// PE-6254 ML Integration works end

    452. 

  452. 								if ( ! isOptionType ) {

    453. 

  453. 									

    454. 

  454. //   									PE-8397

    455. 

  455. //									// Implementation start PE : 5643	

    456. 

  456. //									// Clear the value anyways if checkAnswerExists==false

    457. 

  457. //									((ObjectNode) (dataNode)).put(code, "");	

    458. 

  458. 									

    459. 

  459. 									obj = apiExpressionEvaluator.prepareOutputJson(null, null, null, ValidationTypes.dropDown,

    460. 

  460. 										code, null, null,JsonUtils.isNullOrBlankOrNullNode(node.get("displayLabel"))? "":node.get("displayLabel").asText() );

    461. 

  461. 								}

    462. 

  462. 	

    463. 

  463. 								if (obj != null) {

    464. 

  464. 									arr.add(obj);

    465. 

  465. 									obj = null;

    466. 

  466. 								}

    467. 

  467. 								// PE-6254 ML Integration works start

    468. 

  468. 								/*if(mlAutoCoorect && !isAggregateRequest)

    469. 

  469. 								{	

    470. 

  470. 									if(!JsonUtils.isNullOrBlankOrNullNode(dataNode.get(code+"_ACflag")) && dataNode.get(code+"_ACflag").asText().equalsIgnoreCase("R"))

    471. 

  471. 									{

    472. 

  472. 										arr.add(prepareMLAutocorrectObject(code,"validationType",tempOriginalValue));

    473. 

  473. 										((ObjectNode) (dataNode)).put(code,dataMap.get(code).asText());

    474. 

  474. 									}

    475. 

  475. 								}*/

    476. 

  476. 								// PE-6254 ML Integration works end

    477. 

  477. 							}

    478. 

  478. 						} 

    479. 

  479. 						tempOriginalValue = dataNode.get(code);

    480. 

  480. 						if(mlAutoCoorect && !isAggregateRequest)

    481. 

  481. 						{	

    482. 

  482. 							if(!JsonUtils.isNullOrBlankOrNullNode(dataNode.get(code+"_ACflag")) && dataNode.get(code+"_ACflag").asText().equalsIgnoreCase("R"))

    483. 

  483. 							{

    484. 

  484. 								arr.add(prepareMLAutocorrectObject(code,"validationType",tempOriginalValue));

    485. 

  485. 								if( !JsonUtils.isNullOrBlankOrNullNode(dataMap.get(code)) ) {	// Handled NullPointerExc

    486. 

  486. 									((ObjectNode) (dataNode)).put(code,dataMap.get(code).asText());

    487. 

  487. 								} else {

    488. 

  488. 									((ObjectNode) (dataNode)).putNull(code);								

    489. 

  489. 								}

    490. 

  490. 							}

    491. 

  491. 						} 

    492. 

  492. 

    493. 

  493.  						if (node.get(Constants.VALIDATIONS) != null && node.get(Constants.VALIDATIONS).size() > 0

    494. 

  494. 								&& flag) { // Aggregate

    495. 

  495. 							for (int i = 0; i < node.get(Constants.VALIDATIONS).size(); i++) {

    496. 

  496. 

    497. 

  497. 								validationNode = node.get(Constants.VALIDATIONS).get(i);

    498. 

  498. 								if (validationNode.get(Constants.VALIDATION_TYPE) != null

    499. 

  499. 										&& EnumUtils.isValidEnum(ValidationTypes.class,

    500. 

  500. 												validationNode.get(Constants.VALIDATION_TYPE).asText())) {

    501. 

  501. 

    502. 

  502. 									switch (ValidationTypes.valueOf(validationNode.get(Constants.VALIDATION_TYPE).asText())) {

    503. 

  503. 									case required:

    504. 

  504. 										// PE - 7241

    505. 

  505. 										predefinedObjList = validatePredefinedValidation(dataNode,node,validationNode,dataMap,mappedColumnName,Constants.REQUIRED);

    506. 

  506. 										break;

    507. 

  507. 									case oneOf:

    508. 

  508. 										obj = apiExpressionEvaluator.checkValidationTypeOneOf(dataMap, code, node,

    509. 

  509. 												validationNode, mappedColumnName);

    510. 

  510. 										break;

    511. 

  511. 									case range:

    512. 

  512. 										rangeOrSeqObjList = apiExpressionEvaluator.prepareRangeObject(dataMap, validationNode, node,

    513. 

  513. 												dataNode);

    514. 

  514. 										break;

    515. 

  515. 									case rangeValidationRefTable:

    516. 

  516. 										rangeOrSeqObjList = apiExpressionEvaluator.prepareRefernceRangeObject(dataMap, validationNode,

    517. 

  517. 												node, dataNode);

    518. 

  518. 										break;

    519. 

  519. 									case eligibility:

    520. 

  520. 										// Last Parameter is weather request of  MDA

    521. 

  521. 										arr.addAll(apiExpressionEvaluator.checkValidity(dataMap, validationNode, node,

    522. 

  522. 												dataNode,false,metaDataColumnsOnly));

    523. 

  523. 										break;

    524. 

  524. 									case phone:

    525. 

  525. 										// PE - 7241

    526. 

  526. 										predefinedObjList = validatePredefinedValidation(dataNode,node,validationNode,null,mappedColumnName,Constants.PHONE);

    527. 

  527. 										break;

    528. 

  528. 									case email:

    529. 

  529. 										// PE - 7241

    530. 

  530. 										predefinedObjList = validatePredefinedValidation(dataNode,node,validationNode,null,mappedColumnName,Constants.EMAIL);

    531. 

  531. 										break;

    532. 

  532. 									case expression:

    533. 

  533. 										obj = apiExpressionEvaluator.expressionEvaluator(dataMap, validationNode, node,	dataNode,

    534. 

  534. 												isAggregateRequest, columnMappingMap, columnNodeList, metaDataColumnsOnly);

    535. 

  535. 										//logger.info(String.format("obj..%s", obj));

    536. 

  536. 										break;

    537. 

  537. 										

    538. 

  538. 									/**

    539. 

  539. 									 * @author Akhileshwar

    540. 

  540. 									 * PE-7045 

    541. 

  541. 									 **/

    542. 

  542. 									case sequentialCheck://PE-7989 metaDataColumnsOnly added in method signature

    543. 

  543. 										rangeOrSeqObjList = apiExpressionEvaluator.performSequentialCheck(dataMap, validationNode, node,

    544. 

  544. 												dataNode, dimMap,apiExpressionEvaluator.getColumnDataTypeMapping(), true, metaDataColumnsOnly);

    545. 

  545. 										break;

    546. 

  546. 									default:

    547. 

  547. 									}

    548. 

  548. 								}else {

    549. 

  549. 									result = Constants.MANDATORY_VALIDATIONTYPE;

    550. 

  550. 									obj = apiExpressionEvaluator.prepareOutputJson(null, null, result, null, null, null,

    551. 

  551. 											null, null);

    552. 

  552. 								}

    553. 

  553. 								if (obj != null) { 

    554. 

  554. 									arr.add(obj);

    555. 

  555. 									obj = null;

    556. 

  556. 								}

    557. 

  557. 								if(rangeOrSeqObjList!=null)

    558. 

  558. 								{

    559. 

  559. 									for(int j=0;j<rangeOrSeqObjList.size();j++)

    560. 

  560. 									{

    561. 

  561. 										arr.add(rangeOrSeqObjList.get(j));

    562. 

  562. 									}

    563. 

  563. 									rangeOrSeqObjList=null;

    564. 

  564. 								}

    565. 

  565. 								if((null != predefinedObjList) && (predefinedObjList.size() > 0)){

    566. 

  566. 									arr.addAll(predefinedObjList);

    567. 

  567. 									predefinedObjList = null;

    568. 

  568. 								}

    569. 

  569. 							}

    570. 

  570. 						} else if (!isAggregateRequest && flag == false) {

    571. 

  571. 							logger.info("Check if flag is false");

    572. 

  572. 							//8421 code changes.

    573. 

  573. 							if(null != dataType && !incorrectDataType.containsKey(dataType)){

    574. 

  574. 								if(Constants.INT.equals(dataType)){

    575. 

  575. 									result = Cache.getPropertyFromError(ErrorCacheConstant.ERR_061);

    576. 

  576. 								}else if(Constants.DOUBLE.equals(dataType)){

    577. 

  577. 									result = Cache.getPropertyFromError(ErrorCacheConstant.ERR_062);

    578. 

  578. 								}else if(Constants.DATE.equals(dataType)){

    579. 

  579. 									result = Cache.getPropertyFromError(ErrorCacheConstant.ERR_063);

    580. 

  580. 								}else{

    581. 

  581. 									//result = Constants.INVALID_DATATYPE_FOR_ERROR;

    582. 

  582. 									result = Cache.getPropertyFromError(ErrorCacheConstant.ERR_043);

    583. 

  583. 								}

    584. 

  584. 							}

    585. 

  585. 							

    586. 

  586. 							if (null != nodeDTObject && null != dnCodeObject) {

    587. 

  587. 								obj = apiExpressionEvaluator.prepareOutputJson(validationObjNode, node, result,

    588. 

  588. 										ValidationTypes.dataTypeError, dnCodeObject.asText(), nodeDTObject.asText(),

    589. 

  589. 										nodeDTObject.asText(), null);

    590. 

  590. 								//logger.info(String.format("Value of object is..%s", obj));

    591. 

  591. 							}

    592. 

  592. 

    593. 

  593. 							if (obj != null) {

    594. 

  594. 								arr.add(obj);

    595. 

  595. 								obj = null;

    596. 

  596. 							}

    597. 

  597. 

    598. 

  598. 						}

    599. 

  599.  						

    600. 

  600.  						// PE-6874 : Fixed by shifting this code down here

    601. 

  601. 						//Following code written for Mercer JIRA Story PE-5691

    602. 

  602. 						// If data node code value is not present then set to Blank and Data map also.

    603. 

  603. 						// PE-7071 : Remove CODE if there is no validation OR validation_errorType != "AUTOCORRECT"

    604. 

  604. 						if(isEmtpyRecord && 

    605. 

  605. 								(validationNode==null || 	

    606. 

  606. 								(null!=validationNode && !JsonUtils.isNullOrBlankOrNullNode(validationNode.get(Constants.ERROR_TYPE)) 

    607. 

  607. 									&& !(validationNode.get(Constants.ERROR_TYPE).asText()).equalsIgnoreCase("AUTOCORRECT")))) {

    608. 

  608. 							((ObjectNode)dataNode).remove(code); 

    609. 

  609. 						}

    610. 

  610. 						//PE-5691 End.	

    611. 

  611.  							

    612. 

  612. 						// PE : 2449 to create auto-correct object for missing EEID

    613. 

  613.  						

    614. 

  614. 						if ((code!=null &&code.equalsIgnoreCase(Constants.EMPLOYEE_EEID)) || 

    615. 

  615. 								(mappedColumnName !=null && mappedColumnName.equalsIgnoreCase(Constants.EMPLOYEE_EEID)))

    616. 

  616. 							obj = prepareEeidAutoCorrectObject(code, dataMap, dataNode,columnMappingMap);

    617. 

  617. 

    618. 

  618. 						if (obj != null) {

    619. 

  619. 							arr.add(obj);

    620. 

  620. 							obj = null;

    621. 

  621. 						}

    622. 

  622. 

    623. 

  623. 						if (node.get("questionType") != null

    624. 

  624. 								&& node.get("questionType").asText().equals("checkboxes")) {

    625. 

  625. 							buildCheckboxArray(dataNode,code, mappedColumnName);

    626. 

  626. 						}

    627. 

  627. 						

    628. 

  628. 					}

    629. 

  629. 					

    630. 

  630. 					code = null;

    631. 

  631. 					validationNode = null;

    632. 

  632. 				}

    633. 

  633. 				// PE-6254 ML Integration work

    634. 

  634. 				if(mlAutoCoorect && !isAggregateRequest)

    635. 

  635. 				{	

    636. 

  636. 					removeDataNodeACFields(dataNode);

    637. 

  637. 				}

    638. 

  638. 				if ((arr != null && arr.size() > 0)) {

    639. 

  639. 					if (!isAggregateRequest) {

    640. 

  640. 						/*

    641. 

  641. 						 * if(dataNode.get(k).get(code)!=null) ((ObjectNode)

    642. 

  642. 						 * (dataNode.get(k))).set(code, dataNode.get(k).get(code));

    643. 

  643. 						 */

    644. 

  644. 							

    645. 

  645. 						((ObjectNode) (dataNode)).set(Constants.VALIDATION_ERRORS, arr);

    646. 

  646. 						arr = null;

    647. 

  647. 					} else { // Aggregate

    648. 

  648. 						JsonNode objectNode = mapper.convertValue(arr, JsonNode.class);

    649. 

  649. 						return objectNode;

    650. 

  650. 					}

    651. 

  651. 				}

    652. 

  652. 

    653. 

  653. 			}

    654. 

  654. 		//logger.info(String.format("%s %s", Constants.EXIT ,Constants.LOG_VALIDATE));

    655. 

  655. 		return dataNode;

    656. 

  656. 	}

    657. 

  657. 

    658. 

  658. 	/**

    659. 

  659. 	 * @param dataNode

    660. 

  660. 	 * @param mappedColumnName

    661. 

  661. 	 * @param nodeDTObject

    662. 

  662. 	 * @param dnCodeObject

    663. 

  663. 	 * @param flag

    664. 

  664. 	 * @param datePatternArray

    665. 

  665. 	 * @param numberPatternArray

    666. 

  666. 	 * @return

    667. 

  667. 	 */

    668. 

  668. 	protected Map<String,String> dataTypeCheck(HashMap<String, JsonNode> dataMap, JsonNode dataNode, String mappedColumnName, JsonNode nodeDTObject,

    669. 

  669. 			JsonNode dnCodeObject, Boolean flag, ArrayNode datePatternArray, ArrayNode numberPatternArray) {

    670. 

  670. 		

    671. 

  671. 		String dnObjetText;

    672. 

  672. 		Map<String,String> incorrectDataTypeMap = new HashMap<>();

    673. 

  673. 		boolean isNullNode = NullNode.class.equals(dnCodeObject.getClass());

    674. 

  674. 		if (!isNullNode) {

    675. 

  675. 			dnObjetText = dnCodeObject.asText();

    676. 

  676. 		}else {

    677. 

  677. 			dnObjetText = null;

    678. 

  678. 		}

    679. 

  679. 		boolean dataTypeFlag = flag;

    680. 

  680. 		String incorrectintegerDataType = "";

    681. 

  681. 		

    682. 

  682. 		boolean isDateArray = false;

    683. 

  683. 		boolean isNumberArray = false;

    684. 

  684. 		

    685. 

  685. 		// 7257  For Multi-part request check following arrays

    686. 

  686. 		if ( null != datePatternArray &&  datePatternArray.size() > 0 ) {

    687. 

  687. 			isDateArray  = true ;

    688. 

  688. 		}

    689. 

  689. 		

    690. 

  690. 		if ( null != numberPatternArray && numberPatternArray.size() > 0 ) {

    691. 

  691. 			isNumberArray = true;

    692. 

  692. 		}

    693. 

  693. 		// Check for integer,boolean,double ,date and string data type object.

    694. 

  694. 		if ("int".equalsIgnoreCase(nodeDTObject.asText()) && (StringUtils.isEmpty(dnObjetText) || isNullNode

    695. 

  695. 				|| (isNumberArray ? DataUtility.isNumeric(dnObjetText, numberPatternArray)

    696. 

  696. 						: DataUtility.isNumeric(dnObjetText)))) {

    697. 

  697. 			//8421 code changes.

    698. 

  698. 			dataTypeFlag = true;

    699. 

  699. 			incorrectintegerDataType = "integer";

    700. 

  700. 			

    701. 

  701. 		   if (isNumberArray && !StringUtils.isEmpty(dnObjetText)) {

    702. 

  702. 			   ((ObjectNode) dataNode).put(mappedColumnName, DataUtility.toNumber(dnObjetText, numberPatternArray)); 

    703. 

  703. 			   //PE-8731

    704. 

  704. 			   dataMap.put(mappedColumnName,dataNode.get(mappedColumnName));

    705. 

  705. 		   }

    706. 

  706. 		} else if ("boolean".equalsIgnoreCase(nodeDTObject.asText()) && ("false".equalsIgnoreCase(dnObjetText)

    707. 

  707. 				|| isNullNode || StringUtils.isEmpty(dnObjetText) || "true".equalsIgnoreCase(dnObjetText))) {

    708. 

  708. 			//8421 code changes.

    709. 

  709. 			dataTypeFlag = true;

    710. 

  710. 			

    711. 

  711. 			incorrectintegerDataType = "boolean";

    712. 

  712. 			((ObjectNode) dataNode).put(mappedColumnName, DataUtility.toNumber(dnObjetText, numberPatternArray));

    713. 

  713. 		} else if ("date".equalsIgnoreCase(nodeDTObject.asText()) && (StringUtils.isEmpty(dnObjetText) || isNullNode

    714. 

  714. 				|| (isDateArray ? DataUtility.isValidDate(dnObjetText, datePatternArray)

    715. 

  715. 						: DataUtility.isValidDate(dnObjetText)))) {

    716. 

  716. 			//8421 code changes.

    717. 

  717. 			dataTypeFlag = true;

    718. 

  718. 			incorrectintegerDataType = "date";

    719. 

  719. 			

    720. 

  720. 			// Convert to ISO-8601 Format

    721. 

  721. 			if (isDateArray && !StringUtils.isEmpty(dnObjetText)) {

    722. 

  722. 				((ObjectNode) dataNode).put(mappedColumnName, DataUtility.customDateConvertor(dnObjetText,datePatternArray));

    723. 

  723. 			}

    724. 

  724. 		} else if ("double".equalsIgnoreCase(nodeDTObject.asText()) && (StringUtils.isEmpty(dnObjetText) || isNullNode

    725. 

  725. 				|| (isNumberArray ? DataUtility.isDecimal(dnObjetText, numberPatternArray)

    726. 

  726. 						: DataUtility.isDecimal(dnObjetText)))) {

    727. 

  727. 			dataTypeFlag = true;

    728. 

  728. 			incorrectintegerDataType = "double";

    729. 

  729. 			

    730. 

  730. 			//Convert to  java decimal

    731. 

  731. 			if (isNumberArray && !StringUtils.isEmpty(dnObjetText)) {

    732. 

  732. 			((ObjectNode) dataNode).put(mappedColumnName, DataUtility.toDecimal(dnObjetText, numberPatternArray));

    733. 

  733. 			//PE-8731

    734. 

  734. 			dataMap.put(mappedColumnName,dataNode.get(mappedColumnName));

    735. 

  735. 			}

    736. 

  736. 		} else if (StringUtils.isEmpty(dnObjetText) || isNullNode || "string".equalsIgnoreCase(nodeDTObject.asText())) {

    737. 

  737. 			dataTypeFlag = true;

    738. 

  738. 		

    739. 

  739. 		}

    740. 

  740. 		//8421 code changes.

    741. 

  741. 		incorrectDataTypeMap.put("dataTypeFlag", Boolean.toString(dataTypeFlag));

    742. 

  742. 		incorrectDataTypeMap.put("datatype", incorrectintegerDataType);

    743. 

  743. 		return incorrectDataTypeMap; 

    744. 

  744. 	}

    745. 

  745. 

    746. 

  746. 	public ArrayNode findAndMerge(JsonNode dataNode, ArrayNode csvNode, String uniqueIdColumnCode) throws Exception {

    747. 

  747. 

    748. 

  748. 		Iterator<String> it = null;

    749. 

  749. 		String key = "";

    750. 

  750. 		boolean isMerged = false;

    751. 

  751. 		if (dataNode != null && dataNode.size() > 0) {

    752. 

  752. 			for (int i = 0; i < dataNode.size(); i++) {

    753. 

  753. 				isMerged = false;

    754. 

  754. 				if (dataNode.get(i).get(uniqueIdColumnCode) != null)

    755. 

  755. 				{

    756. 

  756. 					for (int j = 0; j < csvNode.size(); j++) {

    757. 

  757. 						if (csvNode.get(j).get(uniqueIdColumnCode) != null && csvNode.get(j).get(uniqueIdColumnCode)

    758. 

  758. 								.equals(dataNode.get(i).get(uniqueIdColumnCode))) {

    759. 

  759. 							it = dataNode.get(i).fieldNames();

    760. 

  760. 							while (it != null && it.hasNext()) {

    761. 

  761. 								key = it.next();

    762. 

  762. 								if (csvNode.get(j).get(key) == null || csvNode.get(j).get(key).equals("")) {

    763. 

  763. 									((ObjectNode) csvNode.get(j)).set(key, dataNode.get(i).get(key));

    764. 

  764. 								}

    765. 

  765. 							}

    766. 

  766. 							isMerged = true;

    767. 

  767. 						}

    768. 

  768. 					}

    769. 

  769. 					if (!isMerged) {

    770. 

  770. 						csvNode.add(dataNode.get(i));

    771. 

  771. 					}

    772. 

  772. 				}

    773. 

  773. 			}

    774. 

  774. 		}

    775. 

  775. 		return csvNode;

    776. 

  776. 	}

    777. 

  777. 

    778. 

  778. 	public void buildCheckboxArray(JsonNode dataNode,String code, String mappedColumnName) {

    779. 

  779. 		if (code == null || code.equals("")) {

    780. 

  780. 			code = mappedColumnName;

    781. 

  781. 		}

    782. 

  782. 		if (dataNode.get(code) != null)

    783. 

  783. 

    784. 

  784. 		{

    785. 

  785. 			if (dataNode.get(code).getNodeType() != JsonNodeType.OBJECT

    786. 

  786. 					&& dataNode.get(code).getNodeType() != JsonNodeType.ARRAY) {

    787. 

  787. 				ArrayNode arrNode = mapper.createArrayNode();

    788. 

  788. 				// PE-7795 Array was giving arrayName["null"] wrong array.

    789. 

  789. 				// Below changes will give arraName[null] requires correct array.

    790. 

  790. 				if( !JsonUtils.isNullNode(dataNode.get(code))) {

    791. 

  791. 					String arr1[] =   dataNode.get(code).asText().split(",");

    792. 

  792. 					if (arr1 != null && arr1.length > 0) {

    793. 

  793. 						for (int i = 0; i < arr1.length; i++) {

    794. 

  794. 							arrNode.add(arr1[i]);

    795. 

  795. 						}

    796. 

  796. 					}

    797. 

  797. 				}

    798. 

  798. 				((ObjectNode) (dataNode)).set(code, arrNode);

    799. 

  799. 				

    800. 

  800. 			} else {

    801. 

  801. 				Iterator<Map.Entry<String, JsonNode>> it = dataNode.get(code).fields();

    802. 

  802. 				Map.Entry<String, JsonNode> entry = null;

    803. 

  803. 				while (it != null && it.hasNext()) {

    804. 

  804. 					entry = it.next();

    805. 

  805. 					ArrayNode arrNode = mapper.createArrayNode();

    806. 

  806. 					switch (entry.getValue().getNodeType()) {

    807. 

  807. 					case ARRAY:

    808. 

  808. 						for (final JsonNode objNode : entry.getValue()) {

    809. 

  809. 							arrNode.add(objNode);

    810. 

  810. 						}

    811. 

  811. 						break;

    812. 

  812. 					case STRING:

    813. 

  813. 						String[] arr1 = entry.getValue().asText().split(",");

    814. 

  814. 						if (arr1 != null && arr1.length > 0) {

    815. 

  815. 							for (int i = 0; i < arr1.length; i++) {

    816. 

  816. 								arrNode.add(arr1[i]);

    817. 

  817. 							}

    818. 

  818. 						}

    819. 

  819. 						break;

    820. 

  820. 					}

    821. 

  821. 					((ObjectNode) (dataNode.get(code))).set(entry.getKey(), arrNode);

    822. 

  822. 				}

    823. 

  823. 			}

    824. 

  824. 		}

    825. 

  825. 	}

    826. 

  826. 

    827. 

  827. 	/**

    828. 

  828. 	 * 

    829. 

  829. 	 * @param header

    830. 

  830. 	 * @param entitiesJson

    831. 

  831. 	 * @return

    832. 

  832. 	 * @throws JsonParseException

    833. 

  833. 	 * @throws JsonMappingException

    834. 

  834. 	 * @throws IOException

    835. 

  835. 	 */

    836. 

  836. 	@SuppressWarnings("unchecked")

    837. 

  837. 	public HashMap<String, Object> compareFields(List<HashMap<String, String>> records,List<String> header, String entitiesJson,

    838. 

  838. 			HashMap<String, Object> xlsxMap,Object eeidColFlag) throws Exception {

    839. 

  839. 		ArrayNode entitiesNode = mapper.readValue(entitiesJson, ArrayNode.class);

    840. 

  840. 		JsonNode columnNode = null;

    841. 

  841. 		ArrayNode arr = null;

    842. 

  842. 		int columnNodeSize = 0;

    843. 

  843. 		boolean found = false;

    844. 

  844. 		boolean multiSheetExcel=false;

    845. 

  845. 		ObjectNode resultNode = null;

    846. 

  846. 		HashMap<String, Object> resultMap = new HashMap<String, Object>();

    847. 

  847. 		String entityCode = null;

    848. 

  848. 		JsonNode skip = null;

    849. 

  849. 		String mappedColName = null;

    850. 

  850. 		boolean sheetMatchingFlag = true;

    851. 

  851. 		String sheetName = "";

    852. 

  852. 		JsonNode dataNode = null;

    853. 

  853. 		if (entitiesNode != null && xlsxMap != null && xlsxMap.get("xlsxHeaderMap") != null) {

    854. 

  854. 			if((((HashMap<String, List<String>>) xlsxMap.get("xlsxHeaderMap")).size()) > 1 )

    855. 

  855. 				multiSheetExcel=true;

    856. 

  856. 			if (entitiesNode.size() < ((HashMap<String, List<String>>) xlsxMap.get("xlsxHeaderMap")).size()) {

    857. 

  857. 				sheetMatchingFlag = false;

    858. 

  858. 			} else {

    859. 

  859. 				for (int i = 0; i < entitiesNode.size(); i++) {

    860. 

  860. 					sheetName = entitiesNode.get(i).get(Constants.CONTEXTDATAKEY).get("companyName").asText() + "_"

    861. 

  861. 							+ entitiesNode.get(i).get(Constants.CONTEXTDATAKEY).get("ctryCode").asText();

    862. 

  862. 					if (((HashMap<String, List<String>>) xlsxMap.get("xlsxHeaderMap")).get(sheetName) == null) {

    863. 

  863. 						sheetMatchingFlag = false;

    864. 

  864. 					}

    865. 

  865. 					break;

    866. 

  866. 				}

    867. 

  867. 

    868. 

  868. 			}

    869. 

  869. 			//logger.info(String.format("nodetype...%s", entitiesNode.size()));

    870. 

  870. 		}

    871. 

  871. 		

    872. 

  872. 		//if((!multiSheetExcel && entitiesNode.size()> 1 ) || (records !=null && entitiesNode.size()> 1))

    873. 

  873. 		if(entitiesNode.size()> 1  && (records !=null || !multiSheetExcel))

    874. 

  874. 		{

    875. 

  875. 			HashMap<String, Object> map = new HashMap<String, Object>();

    876. 

  876. 			if(records !=null)

    877. 

  877. 			{

    878. 

  878. 				map.put("data", records);

    879. 

  879. 				map.put("columns",header );

    880. 

  880. 			}

    881. 

  881. 			else

    882. 

  882. 			{

    883. 

  883. 				map.put("data", ((HashMap<String, List<HashMap<String, String>>>)xlsxMap.get("xlsxDataMap")).get(xlsxMap.get("FirstSheetName")));

    884. 

  884. 				map.put("columns",((HashMap<String, List<String>>) xlsxMap.get("xlsxHeaderMap")).get(xlsxMap.get("FirstSheetName")) );

    885. 

  885. 			}

    886. 

  886. 			dataNode = mapper.readValue(mapper.writeValueAsString(map), JsonNode.class);

    887. 

  887. 			resultMap.put("resultNode", dataNode);

    888. 

  888. 			return resultMap;

    889. 

  889. 		}

    890. 

  890. 

    891. 

  891. 		for (int i = 0; i < entitiesNode.size(); i++) {

    892. 

  892. 

    893. 

  893. 			dataNode = mapper.createObjectNode();

    894. 

  894. 			columnNode = entitiesNode.get(i).get(Constants.SECTION_STRUCTURE).get(Constants.COLUMNS);

    895. 

  895. 			if (entitiesNode.get(i).get(Constants.CONTEXTDATAKEY).get("companyName") != null

    896. 

  896. 					&& entitiesNode.get(i).get(Constants.CONTEXTDATAKEY).get("ctryCode") != null) {

    897. 

  897. 				sheetName = entitiesNode.get(i).get(Constants.CONTEXTDATAKEY).get("companyName").asText() + "_"

    898. 

  898. 						+ entitiesNode.get(i).get(Constants.CONTEXTDATAKEY).get("ctryCode").asText();

    899. 

  899. 			}

    900. 

  900. 			columnNodeSize = (columnNode).size();

    901. 

  901. 			if (xlsxMap != null && xlsxMap.get("xlsxHeaderMap") != null) {

    902. 

  902. 				if (!sheetMatchingFlag) {

    903. 

  903. 					header = ((HashMap<String, List<String>>) xlsxMap.get("xlsxHeaderMap"))

    904. 

  904. 							.get(xlsxMap.get("FirstSheetName"));

    905. 

  905. 				} else {

    906. 

  906. 					header = ((HashMap<String, List<String>>) xlsxMap.get("xlsxHeaderMap")).get(sheetName);

    907. 

  907. 				}

    908. 

  908. 			}

    909. 

  909. 			resultNode = mapper.createObjectNode();

    910. 

  910. 			if (header != null) {

    911. 

  911. 				for (int j = 0; j < header.size(); j++) {

    912. 

  912. 					found = false;

    913. 

  913. 					for (int k = 0; k < columnNodeSize; k++) {

    914. 

  914. 						skip = columnNode.get(k).get(Constants.SKIP);

    915. 

  915. 						if (null != columnNode.get(k).get("code")) {

    916. 

  916. 							entityCode = columnNode.get(k).get("code").asText();

    917. 

  917. 						}

    918. 

  918. 						if (null != columnNode.get(k).get("mappedColumnName")) {

    919. 

  919. 							mappedColName = columnNode.get(k).get("mappedColumnName").asText();

    920. 

  920. 						}

    921. 

  921. 						//Code modified to skip mapping in case of skip=true in request PE : 6858

    922. 

  922. 						if(skip!=null && skip.asText().equals("true"))

    923. 

  923. 						{

    924. 

  924. 							if(header.get(j).equals(entityCode) || header.get(j).equals(mappedColName))

    925. 

  925. 							{	

    926. 

  926. 							found = true;

    927. 

  927. 							break;

    928. 

  928. 							}

    929. 

  929. 							else

    930. 

  930. 							{

    931. 

  931. 							continue;

    932. 

  932. 							}

    933. 

  933. 							

    934. 

  934. 						}

    935. 

  935. 						if ((!StringUtils.isEmpty(entityCode)|| !StringUtils.isEmpty(mappedColName)) && skip==null) {

    936. 

  936. 							if (header.get(j).equals(entityCode) || header.get(j).equals(mappedColName)) {

    937. 

  937. 								found = true;

    938. 

  938. 								break;

    939. 

  939. 							}

    940. 

  940. 						}

    941. 

  941. 					}

    942. 

  942. 					if (!found) {

    943. 

  943. 						break;

    944. 

  944. 					}

    945. 

  945. 				}

    946. 

  946. 			}

    947. 

  947. 			if (!found) {

    948. 

  948. 				break;

    949. 

  949. 			}

    950. 

  950. 

    951. 

  951. 		}

    952. 

  952. 		if (!found ) {

    953. 

  953. 			if(!multiSheetExcel)

    954. 

  954. 			{

    955. 

  955. 			HashMap<String, Object> map = new HashMap<String, Object>();

    956. 

  956. 			if(xlsxMap!=null)

    957. 

  957. 			{

    958. 

  958. 			if(!sheetMatchingFlag)

    959. 

  959. 			{

    960. 

  960. 				map.put("data", ((HashMap<String, List<HashMap<String, String>>>)xlsxMap.get("xlsxDataMap")).get(xlsxMap.get("FirstSheetName")));

    961. 

  961. 			}

    962. 

  962. 			else{

    963. 

  963. 				map.put("data", ((HashMap<String, List<HashMap<String, String>>>)xlsxMap.get("xlsxDataMap")).get(sheetName));

    964. 

  964. 			}

    965. 

  965. 			

    966. 

  966. 			}

    967. 

  967. 			else if(records!=null)

    968. 

  968. 			{

    969. 

  969. 				map.put("data", records);

    970. 

  970. 			}

    971. 

  971. 			if((boolean)eeidColFlag)

    972. 

  972. 			{

    973. 

  973. 			map.put("columns",header );

    974. 

  974. 			}

    975. 

  975. 			else

    976. 

  976. 			{

    977. 

  977. 				header.remove(header.size() - 1);

    978. 

  978. 				map.put("columns",header);

    979. 

  979. 			}

    980. 

  980. 			dataNode = mapper.readValue(mapper.writeValueAsString(map), JsonNode.class);

    981. 

  981. 			resultMap.put("resultNode", dataNode);

    982. 

  982. 			}

    983. 

  983. 			else

    984. 

  984. 			{

    985. 

  985. 				resultMap.put("resultNode", ErrorCacheConstant.ERR_055);

    986. 

  986. 			}

    987. 

  987. 		} else {

    988. 

  988. 			resultMap.put("resultNode", null);

    989. 

  989. 			if (sheetMatchingFlag == false) {

    990. 

  990. 				resultMap.put("sheetMatchingFlag",

    991. 

  991. 						null != xlsxMap.get("FirstSheetName") ? xlsxMap.get("FirstSheetName") : "");

    992. 

  992. 			}

    993. 

  993. 			return resultMap;

    994. 

  994. 		}

    995. 

  995. 		if (sheetMatchingFlag == false) {

    996. 

  996. 			resultMap.put("sheetMatchingFlag",

    997. 

  997. 					null != xlsxMap.get("FirstSheetName") ? xlsxMap.get("FirstSheetName") : "");

    998. 

  998. 		}

    999. 

  999. 		return resultMap;

    1000. 

  1000. 	}

    1001. 

  1001. 

    1002. 

  1002. 	@SuppressWarnings("unchecked")

    1003. 

  1003. 	public HashMap<String, Object> convertXlsxToMap(Map<String, Object> workBookMap,String empIdColumn) throws Exception {

    1004. 

  1004. 		//logger.info(String.format("%s %s", Constants.INTIATE ,Constants.LOG_CONVERXLSXTOMAP));

    1005. 

  1005. 		HashMap<String, Object> map = null;

    1006. 

  1006. 		List<String> headerList = null;

    1007. 

  1007. 		List<ArrayList<String>> dataList = null;

    1008. 

  1008. 		HashMap<String, List<HashMap<String, String>>> xlsxDataMap = null;

    1009. 

  1009. 		HashMap<String, List<String>> xlsxHeaderMap = null;

    1010. 

  1010. 		HashMap<String, Object> xlsxMap = null;

    1011. 

  1011. 		xlsxDataMap = new HashMap<>();

    1012. 

  1012. 		xlsxHeaderMap = new HashMap<>();

    1013. 

  1013. 		Set<Object> eeidSet = null;

    1014. 

  1014. 		List<HashMap<String, String>> allRecords = null;

    1015. 

  1015. 		HashMap<String, String> record = null;

    1016. 

  1016. 		boolean eeidFlag = true;

    1017. 

  1017. 		//PE-8933

    1018. 

  1018. 		boolean eeidMissingFlag = false;

    1019. 

  1019. 				

    1020. 

  1020. 		

    1021. 

  1021. 		String tempDataListRecord ;

    1022. 

  1022. 		String tempHeaderListRecord;

    1023. 

  1023. 		try {

    1024. 

  1024. 		if (workBookMap != null && workBookMap.size() > 0) {

    1025. 

  1025. 			xlsxMap = new HashMap<>();

    1026. 

  1026. 			//Iterate through each xlsx tab.

    1027. 

  1027. 			for (Entry<String, Object> entry : workBookMap.entrySet()) {

    1028. 

  1028. 				eeidSet = new HashSet<>();

    1029. 

  1029. 				if (entry.getKey().equals("FirstSheetName")) {

    1030. 

  1030. 					xlsxMap.put("FirstSheetName", entry.getValue());

    1031. 

  1031. 					continue;

    1032. 

  1032. 				}

    1033. 

  1033. 				allRecords = new ArrayList<>();

    1034. 

  1034. 				map = (HashMap<String, Object>) entry.getValue();

    1035. 

  1035. 				headerList = (List<String>) map.get("header");

    1036. 

  1036. 				dataList = (List<ArrayList<String>>) map.get("data");

    1037. 

  1037. 				

    1038. 

  1038. 				//Iterate through data records from each xlsx tab.

    1039. 

  1039. 				for (int i = 0; i < dataList.size(); i++) {

    1040. 

  1040. 					 record = new HashMap<>();

    1041. 

  1041. 					 

    1042. 

  1042. 					//Iterate through each header from each tab.

    1043. 

  1043. 					for (int j = 0; j < headerList.size(); j++) {

    1044. 

  1044. 						

    1045. 

  1045. 						tempDataListRecord = dataList.get(i).get(j);

    1046. 

  1046. 						tempHeaderListRecord = headerList.get(j);

    1047. 

  1047. 						if (tempHeaderListRecord.equalsIgnoreCase(Constants.EMPLOYEE_EEID) || (empIdColumn!=null 

    1048. 

  1048. 								&& !empIdColumn.equals("") && tempHeaderListRecord.equals(empIdColumn))) {

    1049. 

  1049. 							try {

    1050. 

  1050. 								if (tempDataListRecord != null && !tempDataListRecord.equals(""))

    1051. 

  1051. 									eeidFlag = eeidSet.add(tempDataListRecord);

    1052. 

  1052. 								else {

    1053. 

  1053. 									// PE-8933

    1054. 

  1054. 									eeidMissingFlag = true;

    1055. 

  1055. 								}

    1056. 

  1056. 							} catch (IndexOutOfBoundsException e) {

    1057. 

  1057. 								eeidFlag = true;

    1058. 

  1058. 							}

    1059. 

  1059. 						}

    1060. 

  1060. 						if (eeidFlag) {

    1061. 

  1061. 								try {

    1062. 

  1062. 									boolean isNotBlankEEID = !StringUtils.isEmpty(tempDataListRecord);

    1063. 

  1063. 									record.put(tempHeaderListRecord,

    1064. 

  1064. 											(isNotBlankEEID ? tempDataListRecord : Constants.BLANK));

    1065. 

  1065. 								} catch (IndexOutOfBoundsException e) {

    1066. 

  1066. 								record.put(tempHeaderListRecord, Constants.BLANK);

    1067. 

  1067. 							}

    1068. 

  1068. 						} else {

    1069. 

  1069. 							xlsxMap.put("isEeidDuplicate", "true");

    1070. 

  1070. 							eeidSet = null;

    1071. 

  1071. 							//PE-8933

    1072. 

  1072. 							if(eeidMissingFlag)

    1073. 

  1073. 								xlsxMap.put(Constants.MISSING_EEID, true);

    1074. 

  1074. 							else

    1075. 

  1075. 								xlsxMap.put(Constants.MISSING_EEID, false);

    1076. 

  1076. 							

    1077. 

  1077. 							return xlsxMap;

    1078. 

  1078. 						}

    1079. 

  1079. 					}

    1080. 

  1080. 					allRecords.add(record);

    1081. 

  1081. 					

    1082. 

  1082. 					//Clean up block

    1083. 

  1083. 					record = null;

    1084. 

  1084. 				}

    1085. 

  1085. 				xlsxDataMap.put(entry.getKey(), allRecords);

    1086. 

  1086. 				xlsxHeaderMap.put(entry.getKey(), headerList);

    1087. 

  1087. 				xlsxMap.put("xlsxHeaderMap", xlsxHeaderMap);

    1088. 

  1088. 				xlsxMap.put("xlsxDataMap", xlsxDataMap);

    1089. 

  1089. 

    1090. 

  1090. 				//PE-8933

    1091. 

  1091. 				if(eeidMissingFlag)

    1092. 

  1092. 					xlsxMap.put(Constants.MISSING_EEID, true);

    1093. 

  1093. 				else

    1094. 

  1094. 					xlsxMap.put(Constants.MISSING_EEID, false);

    1095. 

  1095. 				

    1096. 

  1096. 				//Clean up records

    1097. 

  1097. 				allRecords = null;

    1098. 

  1098. 			}

    1099. 

  1099. 		  }

    1100. 

  1100. 		}finally {

    1101. 

  1101. 			

    1102. 

  1102. 		}

    1103. 

  1103. 		eeidSet = null;

    1104. 

  1104. 		//logger.info(String.format("%s %s", Constants.EXIT ,Constants.LOG_CONVERXLSXTOMAP));

    1105. 

  1105. 		return xlsxMap;

    1106. 

  1106. 	}

    1107. 

  1107. 

    1108. 

  1108. 	@SuppressWarnings("unchecked")

    1109. 

  1109. 	public LinkedHashMap<String, String> prepareJsonString(HashMap<String, Object> xslsMap) throws Exception{

    1110. 

  1110. 

    1111. 

  1111. 		HashMap<String, Object> map = new HashMap<String, Object>();

    1112. 

  1112. 		HashMap<String, List<HashMap<String, String>>> xlsxDataMap = null;

    1113. 

  1113. 		String csvJsonString = "";

    1114. 

  1114. 		LinkedHashMap<String, String> xslJsonMap = new LinkedHashMap<String, String>();

    1115. 

  1115. 		if (xslsMap != null && xslsMap.size() > 0) {

    1116. 

  1116. 			xlsxDataMap = (HashMap<String, List<HashMap<String, String>>>) xslsMap.get("xlsxDataMap");

    1117. 

  1117. 			for (Entry<String, List<HashMap<String, String>>> entry : xlsxDataMap.entrySet()) {

    1118. 

  1118. 				map.put("data", entry.getValue());

    1119. 

  1119. 				ObjectMapper mapper = new ObjectMapper();

    1120. 

  1120. 					csvJsonString = mapper.writeValueAsString(map);

    1121. 

  1121. 					xslJsonMap.put(entry.getKey(), csvJsonString);

    1122. 

  1122. 

    1123. 

  1123. 			}

    1124. 

  1124. 		}

    1125. 

  1125. 		return xslJsonMap;

    1126. 

  1126. 	}

    1127. 

  1127. 

    1128. 

  1128. 	// PE : 2449 to check duplication of EEID start in case of entity data in

    1129. 

  1129. 	// request body

    1130. 

  1130. 	public HashMap<String,String> checkUniqueNessForEEID(String enetityJson) throws Exception{

    1131. 

  1131. 		//logger.info(String.format("%s %s", Constants.INTIATE ,Constants.LOG_CHECKUNIQUENESSFOREEID));

    1132. 

  1132. 		@SuppressWarnings("unchecked")

    1133. 

  1133. 		HashMap<String,String> empIdMap= new HashMap<String,String>();

    1134. 

  1134. 		empIdMap.put("isUnique", "true");

    1135. 

  1135. 		JsonNode entityNode = null;

    1136. 

  1136. 		boolean flag = false;

    1137. 

  1137. 		String code = "";

    1138. 

  1138. 		JsonNode sectionStructureNode = null;

    1139. 

  1139. 		String empIdColumn="";

    1140. 

  1140. 		ArrayList<JsonNode> columnNodeList = null;

    1141. 

  1141. 			columnNodeList = new ArrayList<JsonNode>();

    1142. 

  1142. 			JsonNode entittiesNode = mapper.readValue(enetityJson, JsonNode.class);

    1143. 

  1143. 			HashSet<String> eeidSet = null;

    1144. 

  1144. 			if (entittiesNode != null) {

    1145. 

  1145. 				for (int i = 0; i < entittiesNode.size(); i++) {

    1146. 

  1146. 					eeidSet = new HashSet<String>();

    1147. 

  1147. 					entityNode = entittiesNode.get(i);

    1148. 

  1148. 					sectionStructureNode = entityNode.get(Constants.SECTION_STRUCTURE);

    1149. 

  1149. 					

    1150. 

  1150. 					for (int j = 0; j < sectionStructureNode.get(Constants.COLUMNS).size(); j++) {

    1151. 

  1151. 						columnNodeList.add(sectionStructureNode.get(Constants.COLUMNS).get(j));

    1152. 

  1152. 

    1153. 

  1153. 					}

    1154. 

  1154. 					if (columnNodeList != null && columnNodeList.size() > 0) {

    1155. 

  1155. 

    1156. 

  1156. 						for (JsonNode node : columnNodeList) {

    1157. 

  1157. 							if (node.get(Constants.CODE) != null)

    1158. 

  1158. 								code = node.get(Constants.CODE).asText();

    1159. 

  1159. 							if (code.equals(Constants.EMPLOYEE_EEID))

    1160. 

  1160. 							{

    1161. 

  1161. 								flag = true;

    1162. 

  1162. 								if(node.get(Constants.MAPPED_COLUMN_NAME)!=null && !node.get(Constants.MAPPED_COLUMN_NAME).equals(""))

    1163. 

  1163. 								{

    1164. 

  1164. 									empIdColumn = node.get(Constants.MAPPED_COLUMN_NAME).asText();

    1165. 

  1165. 									empIdMap.put("empIdColumn", empIdColumn);

    1166. 

  1166. 								}

    1167. 

  1167. 							}

    1168. 

  1168. 								

    1169. 

  1169. 						}

    1170. 

  1170. 					}

    1171. 

  1171. 

    1172. 

  1172. 					if (flag) {

    1173. 

  1173. 						JsonNode dataNode = entittiesNode.get(i).get(Constants.DATA);

    1174. 

  1174. 						if (dataNode != null) {

    1175. 

  1175. 							for (int k = 0; k < dataNode.size(); k++) {

    1176. 

  1176. 

    1177. 

  1177. 								if (dataNode.get(k).get(Constants.EMPLOYEE_EEID) != null

    1178. 

  1178. 										&& !dataNode.get(k).get(Constants.EMPLOYEE_EEID).asText().equals("")) {

    1179. 

  1179. 									String eeId = dataNode.get(k).get(Constants.EMPLOYEE_EEID).asText();

    1180. 

  1180. 									if (!eeidSet.add(eeId)) {

    1181. 

  1181. 										eeidSet = null;  

    1182. 

  1182. 										empIdMap.put("isUnique",Constants.DUPLICATE);

    1183. 

  1183. 										return empIdMap;

    1184. 

  1184. 									}

    1185. 

  1185. 								} else {

    1186. 

  1186. 									 empIdMap.put("isUnique",Constants.MISSING);

    1187. 

  1187. 									 return empIdMap;

    1188. 

  1188. 								}

    1189. 

  1189. 							}

    1190. 

  1190. 						}

    1191. 

  1191. 					}

    1192. 

  1192. 				}

    1193. 

  1193. 			}

    1194. 

  1194. 		//logger.info(String.format("%s %s", Constants.EXIT ,Constants.LOG_CHECKUNIQUENESSFOREEID));

    1195. 

  1195. 		return empIdMap;

    1196. 

  1196. 

    1197. 

  1197. 	}

    1198. 

  1198. 

    1199. 

  1199. 	// PE : 2449 to prepare auto-correct validation object in case of missing EEID..

    1200. 

  1200. 	public ObjectNode prepareEeidAutoCorrectObject(String code, HashMap<String, JsonNode> dataMap, JsonNode dataNode,

    1201. 

  1201. 			 HashMap<String, String> columnMappingMap) throws Exception {

    1202. 

  1202. 		//logger.info(String.format("%s %s", Constants.INTIATE ,Constants.LOG_PREPAREEEIDAUTOCORRECTOBJECT));

    1203. 

  1203. 		ObjectNode obj = null;  

    1204. 

  1204. 		

    1205. 

  1205. 		if (dataMap != null && ((!JsonUtils.isNullOrBlankOrNullNode(dataMap.get(Constants.EMPLOYEE_EEID))

    1206. 

  1206. 				&& !JsonUtils.isBlankTextNode(dataMap.get(Constants.EMPLOYEE_EEID)) ) 

    1207. 

  1207. 				|| (!JsonUtils.isNullOrBlankOrNullNode(dataMap.get(columnMappingMap.get(code)))

    1208. 

  1208. 						&& !JsonUtils.isBlankTextNode(dataMap.get(columnMappingMap.get(code))) )))

    1209. 

  1209. 				 {

    1210. 

  1210. 			return obj;

    1211. 

  1211. 		} else {

    1212. 

  1212. 			String eeId = generateUniqueEeid();

    1213. 

  1213. 			//logger.info(String.format("eeid generated..%s", eeId));

    1214. 

  1214. 			APIExpressionEvaluator apiExpressionEvaluator = new APIExpressionEvaluator();

    1215. 

  1215. 				obj = apiExpressionEvaluator.prepareOutputJson(null, null, eeId, ValidationTypes.eeIdAutoCorrect, code,

    1216. 

  1216. 						null, null, null);

    1217. 

  1217. 				((ObjectNode) (dataNode)).put(code, eeId);

    1218. 

  1218. 		}

    1219. 

  1219. 		//logger.info(String.format("%s %s", Constants.EXIT ,Constants.LOG_PREPAREEEIDAUTOCORRECTOBJECT));

    1220. 

  1220. 		return obj;

    1221. 

  1221. 	}

    1222. 

  1222. 

    1223. 

  1223. 	public static synchronized String generateUniqueEeid() throws Exception {

    1224. 

  1224. 		//logger.info(String.format("%s %s", Constants.INTIATE ,Constants.LOG_GENERATEUNIQUEEID));

    1225. 

  1225. 		Date d1 = new Date();

    1226. 

  1226. 		SimpleDateFormat sdf = new SimpleDateFormat(Constants.EEID_FORMAT2);

    1227. 

  1227. 		//logger.info(String.format("%s %s", Constants.EXIT ,Constants.LOG_GENERATEUNIQUEEID));

    1228. 

  1228. 		String tmpNanoTime = String.valueOf(System.nanoTime());		// Duplicate EEID occurred at millisec-level. Found in PE-8616.

    1229. 

  1229. 		return sdf.format(d1)+ tmpNanoTime.substring(tmpNanoTime.length()-5, tmpNanoTime.length());

    1230. 

  1230. 

    1231. 

  1231. 	}

    1232. 

  1232. 	

    1233. 

  1233. 	public static ArrayNode removeMlNode(JsonNode jsonNode) throws Exception {

    1234. 

  1234. 		JsonNode mlNode = null;

    1235. 

  1235. 		JsonNode entityNode = null;

    1236. 

  1236. 		Iterator<Entry<String, JsonNode>> mlItr = null;

    1237. 

  1237. 		ArrayNode mlJsonDataArray = (ArrayNode) jsonNode.get("entities");

    1238. 

  1238. 		Map.Entry<String, JsonNode> entry = null;

    1239. 

  1239. 

    1240. 

  1240. 		for (int i = 0; i < mlJsonDataArray.size(); i++) {

    1241. 

  1241. 

    1242. 

  1242. 			entityNode = mlJsonDataArray.get(i);

    1243. 

  1243. 			mlNode = entityNode.get(Constants.DATA);

    1244. 

  1244. 

    1245. 

  1245. 			for (int k = 0; k < mlNode.size(); k++) {

    1246. 

  1246. 

    1247. 

  1247. 				mlItr = mlNode.get(k).fields();

    1248. 

  1248. 				while (mlItr.hasNext()) {

    1249. 

  1249. 					entry = mlItr.next();

    1250. 

  1250. 					if (entry.getKey().contains("_Replace") || entry.getKey().contains("_ACflag")) {

    1251. 

  1251. 						((ObjectNode) mlNode.get(k)).remove(entry.getKey());

    1252. 

  1252. 					}

    1253. 

  1253. 				}

    1254. 

  1254. 			}

    1255. 

  1255. 		}

    1256. 

  1256. 		return mlJsonDataArray;

    1257. 

  1257. 	}

    1258. 

  1258. 	public void performL0Validation(String entitiesJson, String csvJsonString, boolean isAggregateRequest,

    1259. 

  1259. 			HashMap<String, String> xslJsonMap, String FirstSheetName) throws Exception

    1260. 

  1260. 	{

    1261. 

  1261. 		//logger.info(String.format("%s %s", Constants.INTIATE ,Constants.LOG_PERFORML0VALIDATION));

    1262. 

  1262. 			JsonNode sectionStructureNode = null;

    1263. 

  1263. 			JsonNode contextDataNode = null;

    1264. 

  1264. 			JsonNode csvNode = null;

    1265. 

  1265. 			JsonNode entityNode = null;

    1266. 

  1266. 			long startTime=0;

    1267. 

  1267. 			long stopTime=0;

    1268. 

  1268. 			Set<String> xslJsonSheets = null;

    1269. 

  1269. 			String code = "";

    1270. 

  1270. 			JsonNode validationNode = null;

    1271. 

  1271. 			String returnValue="";

    1272. 

  1272. 			Pattern pattern = Pattern.compile(Constants.EXP_PATTERN);

    1273. 

  1273. 			boolean columnMissflag = true;

    1274. 

  1274. 		

    1275. 

  1275. 		

    1276. 

  1276. 			Map<String,String> mappedColumnMap = new HashMap<String,String>();

    1277. 

  1277. 			// 8395 JP

    1278. 

  1278. 			String field=null;

    1279. 

  1279. 			Map<String,String> metaDataColumnMap = new HashMap<String,String>();

    1280. 

  1280. 			ArrayNode entitiesNode = mapper.readValue(entitiesJson, ArrayNode.class);

    1281. 

  1281. 			if (xslJsonMap != null) {

    1282. 

  1282. 				xslJsonSheets = new HashSet<String>(xslJsonMap.keySet());

    1283. 

  1283. 			}

    1284. 

  1284. 			for (int i = 0; i < entitiesNode.size(); i++) {

    1285. 

  1285. 				entityNode = entitiesNode.get(i);

    1286. 

  1286. 				if(entitiesNode.get(i).get(Constants.DATA)!=null && entitiesNode.get(i).get(Constants.DATA).size()>0)

    1287. 

  1287. 				{

    1288. 

  1288. 				break;	

    1289. 

  1289. 				}

    1290. 

  1290. 				sectionStructureNode = entityNode.get(Constants.SECTION_STRUCTURE);

    1291. 

  1291. 				contextDataNode = entityNode.get(Constants.CONTEXTDATAKEY);

    1292. 

  1292. 				if (csvJsonString != null && !csvJsonString.equals("")) {

    1293. 

  1293. 					csvNode = mapper.readValue(csvJsonString, JsonNode.class);

    1294. 

  1294. 				} else if (xslJsonMap != null && xslJsonMap.size() > 0) {

    1295. 

  1295. 					String coName_CtryCode = contextDataNode.get("companyName").asText() + "_"

    1296. 

  1296. 							+ contextDataNode.get("ctryCode").asText();

    1297. 

  1297. 					if (FirstSheetName != null) {

    1298. 

  1298. 						csvNode = mapper.readValue(xslJsonMap.get(FirstSheetName), JsonNode.class);

    1299. 

  1299. 					} else if (xslJsonMap.get(coName_CtryCode) != null) {

    1300. 

  1300. 						if (xslJsonSheets.contains(coName_CtryCode)) {

    1301. 

  1301. 							csvNode = mapper.readValue(xslJsonMap.get(coName_CtryCode), JsonNode.class);

    1302. 

  1302. 						}

    1303. 

  1303. 					} else if (xslJsonMap.get(coName_CtryCode) == null) {

    1304. 

  1304. 						/*throw new CustomStatusException(Constants.HTTPSTATUS_400,

    1305. 

  1305. 								String.format(Constants.ERROR_SHEET_NOT_FOUND, coName_CtryCode));*/

    1306. 

  1306. 						paramValueList =  new ArrayList<String>();

    1307. 

  1307. 						paramValueList.add(""+coName_CtryCode);

    1308. 

  1308. 						throw new CustomStatusException(Constants.HTTPSTATUS_400,Cache.getPropertyFromError(ErrorCacheConstant.ERR_035),

    1309. 

  1309. 								Cache.getPropertyFromError(ErrorCacheConstant.ERR_035+Constants.PARAMS),paramValueList);

    1310. 

  1310. 					}

    1311. 

  1311. 				}

    1312. 

  1312. 				if (!JsonUtils.isNullOrBlankOrNullNode(csvNode) 

    1313. 

  1313. 						&& csvNode.get(Constants.DATA).size() > 0 ) {

    1314. 

  1314. 					sectionStructureNode = entityNode.get(Constants.SECTION_STRUCTURE);

    1315. 

  1315. 					ArrayList<JsonNode> columnNodeList = new ArrayList<JsonNode>();

    1316. 

  1316. 					for (int j = 0; j < sectionStructureNode.get(Constants.COLUMNS).size(); j++) {

    1317. 

  1317. 						columnNodeList.add(sectionStructureNode.get(Constants.COLUMNS).get(j));

    1318. 

  1318. 						//Code added for 8395

    1319. 

  1319. 						/*if(null != columnNodeList.get(j).get(Constants.CODE) && null != columnNodeList.get(j).get(Constants.MAPPED_COLUMN_NAME)){

    1320. 

  1320. 							mappedColumnMap.put(columnNodeList.get(j).get(Constants.CODE).asText(), columnNodeList.get(j).get(Constants.MAPPED_COLUMN_NAME).asText());

    1321. 

  1321. 						}

    1322. 

  1322. 						if(null != columnNodeList.get(j).get(Constants.CODE)) {

    1323. 

  1323. 							metaDataColumnsSet.add(columnNodeList.get(j).get(Constants.CODE).asText());

    1324. 

  1324. 						}*/

    1325. 

  1325. 						//8395 JP

    1326. 

  1326. 						if (null != columnNodeList.get(j).get(Constants.CODE)) {

    1327. 

  1327. 							mappedColumnMap.put(columnNodeList.get(j).get(Constants.CODE).asText(),columnNodeList.get(j).get(Constants.CODE).asText());

    1328. 

  1328. 							if (null != columnNodeList.get(j).get(Constants.MAPPED_COLUMN_NAME)) {

    1329. 

  1329. 								mappedColumnMap.put(columnNodeList.get(j).get(Constants.CODE).asText(),

    1330. 

  1330. 										columnNodeList.get(j).get(Constants.MAPPED_COLUMN_NAME).asText());

    1331. 

  1331. 							}

    1332. 

  1332. 						}

    1333. 

  1333. 						

    1334. 

  1334. 					}

    1335. 

  1335. 						if (columnNodeList != null && columnNodeList.size() > 0) {

    1336. 

  1336. 

    1337. 

  1337. 							for (JsonNode node : columnNodeList) {

    1338. 

  1338. 								if (node.get(Constants.CODE) != null)

    1339. 

  1339. 									code = node.get(Constants.CODE).asText();

    1340. 

  1340. 								if (node.get(Constants.VALIDATIONS) != null

    1341. 

  1341. 										&& node.get(Constants.VALIDATIONS).size() > 0) {

    1342. 

  1342. 									for (int k = 0; k < node.get(Constants.VALIDATIONS).size(); k++) {

    1343. 

  1343. 										validationNode = node.get(Constants.VALIDATIONS).get(k);

    1344. 

  1344. 										columnMissflag = true;

    1345. 

  1345. 										if (validationNode != null && validationNode.get("category") != null

    1346. 

  1346. 												&& validationNode.get("category").asText().equalsIgnoreCase("file_acceptance")) {

    1347. 

  1347. 											

    1348. 

  1348. 											if (validationNode.get(Constants.EXPRESSION) != null && validationNode

    1349. 

  1349. 													.get(Constants.EXPRESSION).asText().contains("ISBLANK")) {

    1350. 

  1350. 												Matcher matcher = pattern.matcher(validationNode.get(Constants.EXPRESSION).asText()

    1351. 

  1351. 																.replaceAll(Constants.CURLY_BRACES, ""));

    1352. 

  1352. 												List<String> fields = new ArrayList<String>();

    1353. 

  1353. 												while (matcher.find()) {

    1354. 

  1354. 													// 8395 JP

    1355. 

  1355. 													field=matcher.group().replace("this.", "").trim();

    1356. 

  1356. 													if(mappedColumnMap.containsKey(field)) {

    1357. 

  1357. 														fields.add(field);

    1358. 

  1358. 													}

    1359. 

  1359. 												}

    1360. 

  1360. 										for (int fieldSize = 0; fieldSize < fields.size(); fieldSize++) {

    1361. 

  1361. 											// if(csvNode.get(Constants.DATA).get(0).has(fields.get(fieldSize))){

    1362. 

  1362. 											if (csvNode.get(Constants.DATA).get(0)

    1363. 

  1363. 													.has(mappedColumnMap.get(fields.get(fieldSize)))) {

    1364. 

  1364. 												// if (csvNode.get(Constants.DATA).get(0).get(fields.get(fieldSize)) !=

    1365. 

  1365. 												// null) {

    1366. 

  1366. 												columnMissflag = false;

    1367. 

  1367. 												break;

    1368. 

  1368. 											}

    1369. 

  1369. 										}

    1370. 

  1370. 												if (!columnMissflag) {

    1371. 

  1371. 													 startTime = System.currentTimeMillis();

    1372. 

  1372. 													//Code added for 8395

    1373. 

  1373. 													columnMissflag = checkforBlank(fields, csvNode,mappedColumnMap);

    1374. 

  1374. 													 stopTime = System.currentTimeMillis();

    1375. 

  1375. 													 //logger.info(String.format("Time taken for checkforBlank() in FormValidator..%d", (stopTime-startTime)));

    1376. 

  1376. 												}

    1377. 

  1377. 											if (columnMissflag) {

    1378. 

  1378. 												

    1379. 

  1379. 												paramValueList = new ArrayList<String>();

    1380. 

  1380. 												paramValueList.add(validationNode.get("_id").asText());

    1381. 

  1381. 												paramValueList.add(code);

    1382. 

  1382. 												throw new CustomStatusException(Constants.HTTPSTATUS_400,

    1383. 

  1383. 														Cache.getPropertyFromError(ErrorCacheConstant.ERR_060),

    1384. 

  1384. 														Cache.getPropertyFromError(ErrorCacheConstant.ERR_060 + Constants.PARAMS),

    1385. 

  1385. 														paramValueList);

    1386. 

  1386. 												//return validationNode.get(Constants.MESSAGE).asText();

    1387. 

  1387. 											}

    1388. 

  1388. 											}

    1389. 

  1389. 

    1390. 

  1390. 										}

    1391. 

  1391. 

    1392. 

  1392. 									}

    1393. 

  1393. 								}

    1394. 

  1394. 							}

    1395. 

  1395. 						}

    1396. 

  1396. 

    1397. 

  1397. 					}

    1398. 

  1398. 				}

    1399. 

  1399. 		//return returnValue;

    1400. 

  1400. 	}

    1401. 

  1401. 	public boolean checkforBlank(List<String> fields,JsonNode csvNode,Map<String,String> mappedColumn)throws Exception

    1402. 

  1402. 	

    1403. 

  1403. 	{

    1404. 

  1404. 		boolean returnValue = true;

    1405. 

  1405. 		JsonNode dataNode = csvNode.get(Constants.DATA);

    1406. 

  1406. 		for (String field : fields) {

    1407. 

  1407. 			if (returnValue == false)

    1408. 

  1408. 				break;

    1409. 

  1409. 				JsonNode dataNodeValue = null;

    1410. 

  1410. 				for (int i = 0; i < dataNode.size(); i++) {

    1411. 

  1411. 					dataNodeValue = dataNode.get(i);

    1412. 

  1412. 					//Code added for 8395

    1413. 

  1413. 					if ((dataNodeValue != null && !JsonUtils.isNullOrBlankOrNullNode(dataNodeValue.get(field))

    1414. 

  1414. 					&& dataNodeValue.get(field).asText() != null && !dataNodeValue.get(field).asText().trim().equals("")) ||

    1415. 

  1415. 							((dataNodeValue != null && !JsonUtils.isNullOrBlankOrNullNode(dataNodeValue.get(mappedColumn.get(field)))

    1416. 

  1416. 					&& dataNodeValue.get(mappedColumn.get(field)).asText() != null && !dataNodeValue.get(mappedColumn.get(field)).asText().trim().equals("")))

    1417. 

  1417. 					/*(mappedColumn.get(dataNode.get(i)) != null)*/) {

    1418. 

  1418. 						returnValue = false;

    1419. 

  1419. 						break;

    1420. 

  1420. 					}

    1421. 

  1421. 				}

    1422. 

  1422. 		}

    1423. 

  1423. 		return returnValue;

    1424. 

  1424. 	}

    1425. 

  1425. 

    1426. 

  1426. 	// PE-7241 Changes

    1427. 

  1427. 	public static ArrayList<ObjectNode> validatePredefinedValidation(JsonNode dataNode, JsonNode columnNode,

    1428. 

  1428. 			JsonNode validationNode, HashMap<String, JsonNode> dataMap, String mappedColumnName, String errorType)

    1429. 

  1429. 			throws Exception {

    1430. 

  1430. 		ArrayList<ObjectNode> emailObjList = new ArrayList<ObjectNode>();	

    1431. 

  1431. 		// Get Regex depending upon error Type

    1432. 

  1432. 		Pattern COMMON_REGEX_PATTERN = null;

    1433. 

  1433. 		switch (errorType) {

    1434. 

  1434. 		case Constants.EMAIL:

    1435. 

  1435. 			COMMON_REGEX_PATTERN = VALID_EMAIL_ADDRESS_REGEX;

    1436. 

  1436. 			break;

    1437. 

  1437. 		case Constants.PHONE:

    1438. 

  1438. 			COMMON_REGEX_PATTERN = VALID_PHONE_NUMBER_REGEX;

    1439. 

  1439. 			break;

    1440. 

  1440. 		case Constants.REQUIRED:

    1441. 

  1441. 			break;

    1442. 

  1442. 		}

    1443. 

  1443. 		boolean checkCode = false;

    1444. 

  1444.  		// Mapped Columns matching

    1445. 

  1445. 		if(columnNode.has(Constants.CODE) && !JsonUtils.isNullOrBlankOrNullNode(columnNode.get(Constants.CODE))){

    1446. 

  1446. 			checkCode = true;

    1447. 

  1447. 		} 

    1448. 

  1448. 		

    1449. 

  1449. 		// Dimensions

    1450. 

  1450. 		if (columnNode.has(Constants.DIMENSIONS) && !JsonUtils.isNullNode(columnNode.get(Constants.DIMENSIONS))) {

    1451. 

  1451. 			JsonNode dimensionNode = dataNode.get(checkCode ? columnNode.get(Constants.CODE).asText() : mappedColumnName);

    1452. 

  1452. 			// PE-8463 NULL Handling

    1453. 

  1453. 			if (!JsonUtils.isNullOrBlankOrNullNode(dimensionNode)) {

    1454. 

  1454. 				dimensionNode = dimensionNode.deepCopy();

    1455. 

  1455. 			}

    1456. 

  1456. 			else {

    1457. 

  1457. 				// PE-8814 - No data for dimension

    1458. 

  1458. 				dimensionNode = createNullNodesForDimension(columnNode.get(Constants.CODE).asText(),

    1459. 

  1459. 						columnNode.get(Constants.DIMENSIONS));

    1460. 

  1460. 				//PE-8814 

    1461. 

  1461. 			}

    1462. 

  1462. 			if(!JsonUtils.isNullOrBlankOrNullNode(dimensionNode)){

    1463. 

  1463. 			// PE-8463 NULL Handling

    1464. 

  1464. 			for (JsonNode dimensionAttribute : columnNode.get(Constants.DIMENSIONS)) {

    1465. 

  1465. 				if (dimensionNode.has(dimensionAttribute.asText())) {

    1466. 

  1466. 					switch (dimensionNode.get(dimensionAttribute.asText()).getNodeType()) {

    1467. 

  1467. 					case OBJECT:

    1468. 

  1468. 						// No object Expected

    1469. 

  1469. 						return emailObjList;

    1470. 

  1470. 					// For Checkbox Array

    1471. 

  1471. 					case ARRAY:

    1472. 

  1472. 						for (final JsonNode checkBoxObj : dimensionNode.get(dimensionAttribute.asText())) {

    1473. 

  1473. 							String inputValue = checkInputNodeType(checkBoxObj);

    1474. 

  1474. 							ObjectNode objNode = buildValidationObjectForPredefinedValidation(COMMON_REGEX_PATTERN,

    1475. 

  1475. 									inputValue, dimensionAttribute, columnNode, validationNode, dataMap,checkCode,

    1476. 

  1476. 									errorType);

    1477. 

  1477. 							if (objNode.size() > 0) {

    1478. 

  1478. 								emailObjList.add(objNode);

    1479. 

  1479. 							}

    1480. 

  1480. 						}

    1481. 

  1481. 						break;

    1482. 

  1482. 					case STRING:

    1483. 

  1483. 					case BINARY:

    1484. 

  1484. 					case BOOLEAN:

    1485. 

  1485. 					case MISSING:

    1486. 

  1486. 					case NULL:

    1487. 

  1487. 					case NUMBER:

    1488. 

  1488. 					case POJO:

    1489. 

  1489. 						// For Normal Values / CheckBox String

    1490. 

  1490. 						if (!JsonUtils.isNullOrBlankOrNullNode(dimensionNode.get(dimensionAttribute.asText()))) {

    1491. 

  1491. 							String[] splitValues = dimensionNode.get(dimensionAttribute.asText()).asText().split(",");

    1492. 

  1492. 							for (String splitValue : splitValues) {

    1493. 

  1493. 								/*emailObjList.add(new APIExpressionEvaluator().prepareOutputJson(validationNode, columnNode,

    1494. 

  1494. 								null, ValidationTypes.expression, null, null, null, null));*/

    1495. 

  1495. 								ObjectNode objNode = buildValidationObjectForPredefinedValidation(COMMON_REGEX_PATTERN,

    1496. 

  1496. 										splitValue, dimensionAttribute, columnNode, validationNode, dataMap,checkCode, errorType);

    1497. 

  1497. 								if (objNode.size() > 0) {

    1498. 

  1498. 									emailObjList.add(objNode);

    1499. 

  1499. 								}

    1500. 

  1500. 							}

    1501. 

  1501. 							break;

    1502. 

  1502. 						}else{

    1503. 

  1503. 							ObjectNode objNode = buildValidationObjectForPredefinedValidation(COMMON_REGEX_PATTERN,

    1504. 

  1504. 									null, dimensionAttribute, columnNode, validationNode, dataMap,checkCode, errorType);

    1505. 

  1505. 							if (objNode.size() > 0) {

    1506. 

  1506. 								emailObjList.add(objNode);

    1507. 

  1507. 							}

    1508. 

  1508. 						}

    1509. 

  1509. 					}

    1510. 

  1510. 				}

    1511. 

  1511. 				// Dimension not found and Validation is required

    1512. 

  1512. 				else if (errorType.equals(Constants.REQUIRED)) {

    1513. 

  1513. 					ObjectNode objNode = new APIExpressionEvaluator().prepareOutputJson(validationNode, dimensionAttribute, null,

    1514. 

  1514. 							ValidationTypes.predefinedValidations,

    1515. 

  1515. 							checkCode ? columnNode.get(Constants.CODE).asText() : mappedColumnName, null, null, null);

    1516. 

  1516. 					if (objNode.size() > 0) {

    1517. 

  1517. 						emailObjList.add(objNode);

    1518. 

  1518. 					}

    1519. 

  1519. 				}

    1520. 

  1520. 				

    1521. 

  1521. 			}

    1522. 

  1522. 		}

    1523. 

  1523. 		} else if ((columnNode.has(Constants.QUESTION_TYPE)

    1524. 

  1524. 				&& (!JsonUtils.isNullNode(columnNode.get(Constants.QUESTION_TYPE))

    1525. 

  1525. 						&& columnNode.get(Constants.QUESTION_TYPE).asText().equals(Constants.CHECKBOXES)))

    1526. 

  1526. 				&& (!JsonUtils.isNullNode(

    1527. 

  1527. 						dataNode.get(checkCode ? 

    1528. 

  1528. 								columnNode.get(Constants.CODE).asText() :

    1529. 

  1529. 									mappedColumnName)))) {

    1530. 

  1530. 			JsonNode checkBoxData = dataNode.get(checkCode ? columnNode.get(Constants.CODE).asText() : mappedColumnName);

    1531. 

  1531. 			if (!JsonUtils.isNullOrBlankOrNullNode(checkBoxData)) {

    1532. 

  1532. 				switch (checkBoxData.getNodeType()) {

    1533. 

  1533. 				case ARRAY:

    1534. 

  1534. 					if(checkBoxData.size()==0) {

    1535. 

  1535. 						ObjectNode objNode = buildValidationObjectForPredefinedValidation(COMMON_REGEX_PATTERN,

    1536. 

  1536. 								null, null, columnNode, validationNode, dataMap, checkCode, errorType);

    1537. 

  1537. 						if (objNode.size() > 0) {

    1538. 

  1538. 							emailObjList.add(objNode);

    1539. 

  1539. 						}

    1540. 

  1540. 						

    1541. 

  1541. 					}else {

    1542. 

  1542. 						for (final JsonNode checkBoxObj : checkBoxData) {

    1543. 

  1543. 							String inputValue = checkInputNodeType(checkBoxObj);

    1544. 

  1544. 							ObjectNode objNode = buildValidationObjectForPredefinedValidation(COMMON_REGEX_PATTERN,

    1545. 

  1545. 									inputValue, null, columnNode, validationNode, dataMap, checkCode, errorType);

    1546. 

  1546. 							if (objNode.size() > 0) {

    1547. 

  1547. 								emailObjList.add(objNode);

    1548. 

  1548. 							}

    1549. 

  1549. 						}

    1550. 

  1550. 					}

    1551. 

  1551. 					break;

    1552. 

  1552. 				case STRING:

    1553. 

  1553. 				case BINARY:

    1554. 

  1554. 				case BOOLEAN:

    1555. 

  1555. 				case MISSING:

    1556. 

  1556. 				case NULL:

    1557. 

  1557. 				case NUMBER:

    1558. 

  1558. 				case POJO:

    1559. 

  1559. 					// String Value (Comma Separated)

    1560. 

  1560. 					if (!JsonUtils.isNullOrBlankOrNullNode(

    1561. 

  1561. 							dataNode.get(checkCode ? columnNode.get(Constants.CODE).asText() : mappedColumnName))) {

    1562. 

  1562. 						String[] splitValues = dataNode

    1563. 

  1563. 								.get(checkCode ? columnNode.get(Constants.CODE).asText() : mappedColumnName).asText()

    1564. 

  1564. 								.split(",");

    1565. 

  1565. 						for (String splitValue : splitValues) {

    1566. 

  1566. 

    1567. 

  1567. 							/*emailObjList.add(new APIExpressionEvaluator().prepareOutputJson(validationNode, columnNode,

    1568. 

  1568. 									null, ValidationTypes.expression, null, null, null, null));*/

    1569. 

  1569. 

    1570. 

  1570. 							ObjectNode objNode = buildValidationObjectForPredefinedValidation(COMMON_REGEX_PATTERN,

    1571. 

  1571. 									splitValue, null, columnNode, validationNode, dataMap, checkCode, errorType);

    1572. 

  1572. 							if (objNode.size() > 0) {

    1573. 

  1573. 								emailObjList.add(objNode);

    1574. 

  1574. 							}

    1575. 

  1575. 						}

    1576. 

  1576. 					} else {

    1577. 

  1577. 						ObjectNode objNode = buildValidationObjectForPredefinedValidation(COMMON_REGEX_PATTERN, dataNode

    1578. 

  1578. 								.get(checkCode ? columnNode.get(Constants.CODE).asText() : mappedColumnName).asText(),

    1579. 

  1579. 								null, columnNode, validationNode, dataMap, checkCode, errorType);

    1580. 

  1580. 						if (objNode.size() > 0) {

    1581. 

  1581. 							emailObjList.add(objNode);

    1582. 

  1582. 						}

    1583. 

  1583. 					}

    1584. 

  1584. 					break;

    1585. 

  1585. 				}

    1586. 

  1586. 			}

    1587. 

  1587. 		} else {

    1588. 

  1588. 			/*emailObjList.add(new APIExpressionEvaluator().prepareOutputJson(validationNode, columnNode,

    1589. 

  1589. 						null, ValidationTypes.expression, null, null, null, null));*/

    1590. 

  1590. 			ObjectNode objNode = buildValidationObjectForPredefinedValidation(COMMON_REGEX_PATTERN,

    1591. 

  1591. 					(!JsonUtils.isNullOrBlankOrNullNode(dataNode.get(checkCode ? columnNode.get(Constants.CODE).asText() : mappedColumnName)) ? dataNode.get(checkCode ? columnNode.get(Constants.CODE).asText() : mappedColumnName).asText() : null), null,

    1592. 

  1592. 					columnNode, validationNode, dataMap, checkCode, errorType);

    1593. 

  1593. 			if (objNode.size() > 0) {

    1594. 

  1594. 				emailObjList.add(objNode);

    1595. 

  1595. 			}

    1596. 

  1596. 		}

    1597. 

  1597. 		return emailObjList; 

    1598. 

  1598. 	}

    1599. 

  1599.  

    1600. 

  1600. 	private static JsonNode createNullNodesForDimension(String code, JsonNode dimensions) {

    1601. 

  1601. 		ObjectNode dimensionsObject = mapper.createObjectNode();

    1602. 

  1602. 		for (JsonNode dimensionNode : dimensions) {

    1603. 

  1603. 			dimensionsObject.set(dimensionNode.asText(),NullNode.getInstance());

    1604. 

  1604. 		}

    1605. 

  1605. 		return mapper.createObjectNode().set(code, dimensionsObject);

    1606. 

  1606. 	}

    1607. 

  1607. 

    1608. 

  1608. 	static String checkInputNodeType(JsonNode node) {

    1609. 

  1609. 		String inputValue = node.asText();

    1610. 

  1610. 		switch (node.getNodeType()) {

    1611. 

  1611. 		case STRING:

    1612. 

  1612. 		case BINARY:

    1613. 

  1613. 		case BOOLEAN:

    1614. 

  1614. 			break;

    1615. 

  1615. 		case MISSING:

    1616. 

  1616. 		case NULL:

    1617. 

  1617. 			inputValue = null;

    1618. 

  1618. 			break;

    1619. 

  1619. 		case NUMBER:

    1620. 

  1620. 		case POJO:

    1621. 

  1621. 			break;

    1622. 

  1622. 		}

    1623. 

  1623. 		return inputValue;

    1624. 

  1624. 	}

    1625. 

  1625. 	

    1626. 

  1626. 	static ObjectNode buildValidationObjectForPredefinedValidation(Pattern COMMON_REGEX_PATTERN, String inputValue,

    1627. 

  1627. 			JsonNode dimensionAttribute, JsonNode columnNode, JsonNode validationNode, HashMap<String, JsonNode> dataMap, boolean checkCode, String errorType)

    1628. 

  1628. 			throws Exception {

    1629. 

  1629. 		ObjectNode errorObjNode = mapper.createObjectNode();		

    1630. 

  1630. 		switch (errorType) {

    1631. 

  1631. 		case Constants.EMAIL:

    1632. 

  1632. 		case Constants.PHONE:

    1633. 

  1633. 			// (null == inputValue) 

    1634. 

  1634. 			if (!StringUtils.isBlank(inputValue) && (null != COMMON_REGEX_PATTERN)

    1635. 

  1635. 					&& !COMMON_REGEX_PATTERN.matcher(inputValue).find()) {

    1636. 

  1636. 				if ((null != dimensionAttribute) && !JsonUtils.isNullNode(dimensionAttribute)) {

    1637. 

  1637. 					((ObjectNode) validationNode).put("dimension", dimensionAttribute.asText());

    1638. 

  1638. 				}

    1639. 

  1639. 				switch (validationNode.get(Constants.ERROR_TYPE).asText()) {

    1640. 

  1640. 				case Constants.ENHANCEMENT:

    1641. 

  1641. 				case Constants.ALERT:

    1642. 

  1642. 				case Constants.ERROR:

    1643. 

  1643. 					errorObjNode = new APIExpressionEvaluator().prepareOutputJson(validationNode,

    1644. 

  1644. 							columnNode, null, ValidationTypes.expression, null, null, null, null);

    1645. 

  1645. 					break;

    1646. 

  1646. 				case Constants.AUTOCORRECT:

    1647. 

  1647. 					/*((ObjectNode) validationNode).set("OriginalValue", dimensionNode.get(jsonNode.asText()));

    1648. 

  1648. 					((ObjectNode) (dimensionNode)).put(jsonNode.asText(), result);

    1649. 

  1649. 					((ObjectNode) validationNode).put("dimension", jsonNode.asText());

    1650. 

  1650. 					emailObjList.add(prepareOutputJson(validationNode, columnNode, result, ValidationTypes.expression, null,

    1651. 

  1651. 							null, null, null));*/

    1652. 

  1652. 					break;

    1653. 

  1653. 				}

    1654. 

  1654. 			}

    1655. 

  1655. 			break;

    1656. 

  1656. 		case Constants.REQUIRED:

    1657. 

  1657. 			/*ObjectNode requiredObjNode = new APIExpressionEvaluator().checkMandatoryFields(dataMap, code,

    1658. 

  1658. 					columnNode.get(Constants.DATA_TYPE).asText(), mappedColumnName);*/

    1659. 

  1659. 			//return new APIExpressionEvaluator().checkRequiredField(inputValue, code, columnNode.get(Constants.DATA_TYPE).asText());

    1660. 

  1660.  

    1661. 

  1661. 			if (StringUtils.isBlank(inputValue)) {

    1662. 

  1662. 				String code = null;

    1663. 

  1663. 				if (checkCode) {

    1664. 

  1664. 					code = columnNode.get(Constants.CODE).asText();

    1665. 

  1665. 				} else {

    1666. 

  1666. 					code = columnNode.get(Constants.MAPPED_COLUMN_NAME).asText();

    1667. 

  1667. 				}

    1668. 

  1668. 				errorObjNode = new APIExpressionEvaluator().prepareOutputJson(validationNode, dimensionAttribute, null,

    1669. 

  1669. 						ValidationTypes.predefinedValidations, code, inputValue, null, null);

    1670. 

  1670. 			}

    1671. 

  1671. 		}

    1672. 

  1672. 	return errorObjNode;

    1673. 

  1673. 	}

    1674. 

  1674. 	

    1675. 

  1675. 	public JsonNode preparyCompanyWiseData(JsonNode dataNode,JsonNode contextDataNode)throws Exception

    1676. 

  1676. 	{

    1677. 

  1677. 		String comppany_Column=null;

    1678. 

  1678. 		String country_Column=null;

    1679. 

  1679. 		JsonNode mappedCompany=null;

    1680. 

  1680. 		JsonNode node=null;

    1681. 

  1681. 		JsonNode companyDataNode = mapper.createObjectNode();;

    1682. 

  1682. 		boolean found=false;

    1683. 

  1683. 		ArrayNode arr = mapper.createArrayNode();

    1684. 

  1684. 		HashMap<String,String> nodeMap=null;

    1685. 

  1685. 		List<HashMap<String,String>> companyList= new ArrayList<HashMap<String,String>>();

    1686. 

  1686. 		if(!JsonUtils.isNullOrBlankOrNullNode(contextDataNode))

    1687. 

  1687. 		{

    1688. 

  1688. 			if (!JsonUtils.isNullOrBlankOrNullNode(contextDataNode.get(Constants.ENTITY_NAME_COLUMN_CODE)) 

    1689. 

  1689. 					&& JsonUtils.isStringExist(contextDataNode.get(Constants.ENTITY_NAME_COLUMN_CODE).asText())) {

    1690. 

  1690. 				comppany_Column=contextDataNode.get(Constants.ENTITY_NAME_COLUMN_CODE).asText();

    1691. 

  1691. 				

    1692. 

  1692. 				if (!JsonUtils.isNullOrBlankOrNullNode(contextDataNode.get(Constants.MAPPED_COMPANY))) {

    1693. 

  1693. 					mappedCompany=contextDataNode.get(Constants.MAPPED_COMPANY);

    1694. 

  1694. 					Iterator<JsonNode> it=mappedCompany.iterator();

    1695. 

  1695. 					while(it.hasNext())

    1696. 

  1696. 					{

    1697. 

  1697. 						node=(JsonNode)it.next();

    1698. 

  1698. 						nodeMap=new HashMap<String,String>();

    1699. 

  1699. 						nodeMap.put("name",(!JsonUtils.isNullOrBlankOrNullNode(node.get("name"))? node.get("name").asText():""));

    1700. 

  1700. 						nodeMap.put("country",(!JsonUtils.isNullOrBlankOrNullNode(node.get("country"))? node.get("country").asText():"")); // check null poiter here

    1701. 

  1701. 						companyList.add(nodeMap);

    1702. 

  1702. 					}

    1703. 

  1703. 					

    1704. 

  1704. 				}

    1705. 

  1705. 				

    1706. 

  1706. 				

    1707. 

  1707. 			}

    1708. 

  1708. 			if (!JsonUtils.isNullOrBlankOrNullNode(contextDataNode.get(Constants.ENTITY_COUNTRY_COLUMN_CODE)) 

    1709. 

  1709. 					&& JsonUtils.isStringExist(contextDataNode.get(Constants.ENTITY_COUNTRY_COLUMN_CODE).asText())) {

    1710. 

  1710. 				country_Column=contextDataNode.get(Constants.ENTITY_COUNTRY_COLUMN_CODE).asText();

    1711. 

  1711. 			}

    1712. 

  1712. 		}

    1713. 

  1713. 		if(!JsonUtils.isNullOrBlankOrNullNode(dataNode) && JsonUtils.isStringExist(comppany_Column) && !JsonUtils.isNullOrBlankOrNullNode(mappedCompany))

    1714. 

  1714. 		{

    1715. 

  1715. 			for(JsonNode data:dataNode)

    1716. 

  1716. 			{

    1717. 

  1717. 				found=false;

    1718. 

  1718. 				if(!JsonUtils.isNullOrBlankOrNullNode(data.get(comppany_Column)))

    1719. 

  1719. 					{

    1720. 

  1720. 					for(HashMap<String,String> map:companyList)

    1721. 

  1721. 					{

    1722. 

  1722. 						if(!map.get("country").equals(""))

    1723. 

  1723. 						{

    1724. 

  1724. 							if(data.get(country_Column).asText().equals(map.get("country")) && data.get(comppany_Column).asText().equals(map.get("name")))

    1725. 

  1725. 							{

    1726. 

  1726. 								found=true;

    1727. 

  1727. 								break;

    1728. 

  1728. 							}

    1729. 

  1729. 						}

    1730. 

  1730. 						else if(data.get(comppany_Column).asText().equals(map.get("name")))

    1731. 

  1731. 						{

    1732. 

  1732. 							found=true;

    1733. 

  1733. 							break;

    1734. 

  1734. 						}

    1735. 

  1735. 					}

    1736. 

  1736. 					if(found)

    1737. 

  1737. 					{

    1738. 

  1738. 						arr.add(data);

    1739. 

  1739. 					}

    1740. 

  1740. 					}

    1741. 

  1741. 			}

    1742. 

  1742. 			((ObjectNode) (companyDataNode)).set(Constants.DATA, arr);

    1743. 

  1743. 		}

    1744. 

  1744. 		else

    1745. 

  1745. 		{

    1746. 

  1746. 			return ((ObjectNode) (companyDataNode)).set(Constants.DATA, dataNode);

    1747. 

  1747. 		}

    1748. 

  1748. 		return companyDataNode;

    1749. 

  1749. 	}

    1750. 

  1750. 	

    1751. 

  1751. 	public HashMap<String, JsonNode> updateDataMapWithEmptyDimension(HashMap<String, JsonNode> dataMap ,HashMap<String, JsonNode> dimMap)

    1752. 

  1752. 	{

    1753. 

  1753. 		JsonNode value=null;

    1754. 

  1754. 		String code="";

    1755. 

  1755. 		String key="";

    1756. 

  1756. 		if(dimMap!=null && dimMap.size()>0)

    1757. 

  1757. 		{

    1758. 

  1758. 			for (Map.Entry<String, JsonNode> entry : dimMap.entrySet())

    1759. 

  1759. 	        {

    1760. 

  1760. 	           code = entry.getKey();

    1761. 

  1761. 	           value = entry.getValue();

    1762. 

  1762. 	            for(JsonNode dim : value)

    1763. 

  1763. 	            {

    1764. 

  1764. 	            key=code+"."+dim.asText();

    1765. 

  1765. 	            if(JsonUtils.isNullOrBlankOrNullNode(dataMap.get(key)))

    1766. 

  1766. 	            {

    1767. 

  1767. 	            	dataMap.put(key, JsonNodeFactory.instance.nullNode());

    1768. 

  1768. 	            }

    1769. 

  1769. 	            }

    1770. 

  1770. 	            //use key and value

    1771. 

  1771. 	        }

    1772. 

  1772. 		}

    1773. 

  1773. 		return dataMap;

    1774. 

  1774. 	}

    1775. 

  1775. 

    1776. 

  1776. 	/**

    1777. 

  1777. 	 * 

    1778. 

  1778. 	 * @param entitiesJson

    1779. 

  1779. 	 * @param csvJsonString

    1780. 

  1780. 	 * @param isAggregateRequest

    1781. 

  1781. 	 * @param xslJsonMap

    1782. 

  1782. 	 * @param firstSheetName

    1783. 

  1783. 	 * @param isMultiPartRequest

    1784. 

  1784. 	 * @param isEEIDMissingInAsyncL0

    1785. 

  1785. 	 * @return

    1786. 

  1786. 	 * @throws Exception

    1787. 

  1787. 	 */

    1788. 

  1788. 	public JsonNode preparingL1Input(String entitiesJson, String csvJsonString, boolean isAggregateRequest,

    1789. 

  1789. 			HashMap<String, String> xslJsonMap, String firstSheetName, boolean isMultiPartRequest,Object isEEIDMissingInAsyncL0) throws Exception {

    1790. 

  1790. 		JsonNode resultNode = null;

    1791. 

  1791. 		ArrayNode entityArr = null;

    1792. 

  1792.  		Set<String> xslJsonSheets = null;

    1793. 

  1793. 		JsonNode resultEntiryNode = null;

    1794. 

  1794.  		JsonNode sectionStructureNode = null;

    1795. 

  1795. 		JsonNode dataNode = null;

    1796. 

  1796. 		JsonNode otherSecDataNode = null;

    1797. 

  1797. 		JsonNode contextDataNode = null;

    1798. 

  1798. 		JsonNode csvNode = null;

    1799. 

  1799. 		String uniqueIdColumnCode = "";

    1800. 

  1800. 		JsonNode entityNode = null;

    1801. 

  1801. 		resultNode = mapper.createObjectNode();

    1802. 

  1802.  		entityArr = mapper.createArrayNode();

    1803. 

  1803.  		Iterator<String> fieldIter=null;

    1804. 

  1804. 		ArrayNode entitiesNode = mapper.readValue(entitiesJson, ArrayNode.class);

    1805. 

  1805.  		StringBuffer coName_CtryCode = new StringBuffer();

    1806. 

  1806. 		String countryCode = null;

    1807. 

  1807. 		ArrayList<String> fieldList=new ArrayList<>();

    1808. 

  1808. 		JsonNode companyDataNode = null;

    1809. 

  1809. 		ArrayNode objNode=null;

    1810. 

  1810. 		String fieldName=null;

    1811. 

  1811. 		String code="";

    1812. 

  1812. 		String mappedCode="";

    1813. 

  1813. 		// For .xlsx data

    1814. 

  1814. 		if (xslJsonMap != null) {

    1815. 

  1815. 			xslJsonSheets = new HashSet<String>(xslJsonMap.keySet());

    1816. 

  1816. 		}

    1817. 

  1817. 		JsonNode colNode = null;

    1818. 

  1818. 		HashMap<String,String> metaDataCodes=new HashMap<>();

    1819. 

  1819. 		for (int i = 0; i < entitiesNode.size(); i++) {

    1820. 

  1820. 			countryCode = "";

    1821. 

  1821.  			entityNode = entitiesNode.get(i);

    1822. 

  1822. 			resultEntiryNode = mapper.createObjectNode();

    1823. 

  1823. 			sectionStructureNode = entityNode.get(Constants.SECTION_STRUCTURE);

    1824. 

  1824. 			dataNode = entityNode.get(Constants.DATA);

    1825. 

  1825. 			otherSecDataNode = entityNode.get(Constants.OTHERSECTIONDATAKEY);

    1826. 

  1826. 			contextDataNode = entityNode.get(Constants.CONTEXTDATAKEY);

    1827. 

  1827. 			colNode = sectionStructureNode.get(Constants.COLUMNS);

    1828. 

  1828. 			// PE: 8976 Start

    1829. 

  1829. 			for (JsonNode col : colNode) {

    1830. 

  1830. 				if (!JsonUtils.isNullOrBlankOrNullNode(col.get("mappedColumnName"))) {

    1831. 

  1831. 					mappedCode = col.get("mappedColumnName").asText();

    1832. 

  1832. 				}

    1833. 

  1833. 				if (!JsonUtils.isNullOrBlankOrNullNode(col.get("code"))) {

    1834. 

  1834. 					code = col.get("code").asText();

    1835. 

  1835. 				}

    1836. 

  1836. 				if(mappedCode.length() > 0 )

    1837. 

  1837. 				{

    1838. 

  1838. 					if (!JsonUtils.isNullOrBlankOrNullNode(col.get("skip"))) {

    1839. 

  1839. 						metaDataCodes.put(mappedCode, "skipEnabled");

    1840. 

  1840. 					} else if (code.length() > 0) {

    1841. 

  1841. 						metaDataCodes.put(mappedCode, code);

    1842. 

  1842. 					}

    1843. 

  1843. 				}

    1844. 

  1844. 

    1845. 

  1845. 				

    1846. 

  1846. 

    1847. 

  1847. 			}

    1848. 

  1848. 			// PE: 8976 End

    1849. 

  1849. 			// Added uniqueIdColumnCode for PE: 8315 . Following line is

    1850. 

  1850. 			// assigned for merging.

    1851. 

  1851. 			uniqueIdColumnCode = contextDataNode.get("uniqueIdColumnCode").asText();

    1852. 

  1852. 

    1853. 

  1853. 			if (!contextDataNode.isNull() && contextDataNode.has("ctryCode")) {

    1854. 

  1854. 				countryCode = contextDataNode.get("ctryCode").asText();

    1855. 

  1855. 			}

    1856. 

  1856. 			if (csvJsonString != null && !csvJsonString.equals("")) {

    1857. 

  1857. 				csvNode = mapper.readValue(csvJsonString, JsonNode.class);

    1858. 

  1858. 			} else if (xslJsonMap != null && xslJsonMap.size() > 0) {

    1859. 

  1859. 				coName_CtryCode.delete(0, coName_CtryCode.length());

    1860. 

  1860. 				coName_CtryCode.append(contextDataNode.get("companyName").asText());

    1861. 

  1861. 				coName_CtryCode.append("_");

    1862. 

  1862. 				coName_CtryCode.append(countryCode);

    1863. 

  1863. 

    1864. 

  1864. 				// Default condition - Need to check usage of FirstSheetName !!

    1865. 

  1865. 				if (firstSheetName != null) {

    1866. 

  1866. 					csvNode = mapper.readValue(xslJsonMap.get(firstSheetName), JsonNode.class);

    1867. 

  1867. 

    1868. 

  1868. 					// If sheet is found

    1869. 

  1869. 				} else if (xslJsonMap.get(coName_CtryCode.toString()) != null) {

    1870. 

  1870. 

    1871. 

  1871. 					// If sheet not previously used

    1872. 

  1872. 					if (xslJsonSheets.contains(coName_CtryCode.toString())) {

    1873. 

  1873. 						csvNode = mapper.readValue(xslJsonMap.get(coName_CtryCode.toString()), JsonNode.class);

    1874. 

  1874. 						xslJsonSheets.remove(coName_CtryCode.toString());

    1875. 

  1875. 

    1876. 

  1876. 						// If sheet previously used

    1877. 

  1877. 					} else {

    1878. 

  1878. 						paramValueList = new ArrayList<String>();

    1879. 

  1879. 						paramValueList.add("" + contextDataNode.get("companyName").asText());

    1880. 

  1880. 						paramValueList.add("" + countryCode );

    1881. 

  1881. 						throw new CustomStatusException(Constants.HTTPSTATUS_400,

    1882. 

  1882. 								Cache.getPropertyFromError(ErrorCacheConstant.ERR_034),

    1883. 

  1883. 								Cache.getPropertyFromError(ErrorCacheConstant.ERR_034 + Constants.PARAMS),

    1884. 

  1884. 								paramValueList);

    1885. 

  1885. 					}

    1886. 

  1886. 

    1887. 

  1887. 					// If sheet not found

    1888. 

  1888. 				} else if (xslJsonMap.get(coName_CtryCode.toString()) == null) {

    1889. 

  1889. 

    1890. 

  1890. 					paramValueList = new ArrayList<String>();

    1891. 

  1891. 					paramValueList.add("" + coName_CtryCode.toString());

    1892. 

  1892. 					throw new CustomStatusException(Constants.HTTPSTATUS_400,

    1893. 

  1893. 							Cache.getPropertyFromError(ErrorCacheConstant.ERR_035),

    1894. 

  1894. 							Cache.getPropertyFromError(ErrorCacheConstant.ERR_035 + Constants.PARAMS), paramValueList);

    1895. 

  1895. 				}

    1896. 

  1896. 			}

    1897. 

  1897. 			if (csvNode != null) {

    1898. 

  1898. 				companyDataNode = preparyCompanyWiseData(csvNode.get("data"), contextDataNode);

    1899. 

  1899. 				dataNode = findAndMerge(dataNode, (ArrayNode) companyDataNode.get("data"), uniqueIdColumnCode);

    1900. 

  1900. 			}

    1901. 

  1901. 

    1902. 

  1902. 			// L0 Validations Ends Here

    1903. 

  1903. 

    1904. 

  1904. 			// Returning Input Json for L1 Validation

    1905. 

  1905. 			// PE 8976 Start : To send column code in the L0response 

    1906. 

  1906. 			if (metaDataCodes.size() > 0) {

    1907. 

  1907. 				fieldIter = dataNode.get(0).fieldNames();

    1908. 

  1908. 				while (fieldIter != null && fieldIter.hasNext()) {

    1909. 

  1909. 					fieldName = fieldIter.next();

    1910. 

  1910. 					if (null != metaDataCodes.get(fieldName) && !metaDataCodes.get(fieldName).equals("skipEnabled")) {

    1911. 

  1911. 						fieldList.add(fieldName);

    1912. 

  1912. 					}

    1913. 

  1913. 				}

    1914. 

  1914. 				if (metaDataCodes.keySet().containsAll(fieldList)) {

    1915. 

  1915. 					objNode = mapper.createArrayNode();

    1916. 

  1916. 					JsonNode node = null;

    1917. 

  1917. 					for (JsonNode data : dataNode) {

    1918. 

  1918. 						node = mapper.createObjectNode();

    1919. 

  1919. 						for (String field : fieldList) {

    1920. 

  1920. 							if (metaDataCodes.get(field) != null) {

    1921. 

  1921. 								((ObjectNode) node).set(metaDataCodes.get(field), data.get(field));

    1922. 

  1922. 							}

    1923. 

  1923. 						}

    1924. 

  1924. 						objNode.add(node);

    1925. 

  1925. 					}

    1926. 

  1926. 				}

    1927. 

  1927. 			}

    1928. 

  1928. 			// PE 8976 End

    1929. 

  1929. 			

    1930. 

  1930. 			//PE-8933 - Starts

    1931. 

  1931. 			if (null != isEEIDMissingInAsyncL0) {

    1932. 

  1932. 				if ((boolean) isEEIDMissingInAsyncL0) {

    1933. 

  1933. 					((ObjectNode) (contextDataNode)).put(Constants.MISSING_EEID, true);

    1934. 

  1934. 				} else {

    1935. 

  1935. 					((ObjectNode) (contextDataNode)).put(Constants.MISSING_EEID, false);

    1936. 

  1936. 				}

    1937. 

  1937. 				((ObjectNode) (entityNode)).set(Constants.CONTEXTDATAKEY, contextDataNode);

    1938. 

  1938. 			}

    1939. 

  1939. 			//PE-8933 - Ends

    1940. 

  1940. 			

    1941. 

  1941. 			resultEntiryNode = entityNode;

    1942. 

  1942. 			if(null!=objNode && objNode.size()>0)

    1943. 

  1943. 			{

    1944. 

  1944. 				((ObjectNode) (resultEntiryNode)).set(Constants.DATA, objNode);	

    1945. 

  1945. 			}

    1946. 

  1946. 			else  

    1947. 

  1947. 			{

    1948. 

  1948. 				((ObjectNode) (resultEntiryNode)).set(Constants.DATA, dataNode);	

    1949. 

  1949. 			}

    1950. 

  1950. 			

    1951. 

  1951. 			entityArr.add(resultEntiryNode);

    1952. 

  1952. 			metaDataCodes.clear();

    1953. 

  1953. 		}

    1954. 

  1954. 		resultNode = mapper.createObjectNode().set(Constants.ENTITIES, entityArr);

    1955. 

  1955. 		return resultNode;

    1956. 

  1956. 	}

    1957. 

  1957. 	

    1958. 

  1958. 	public JsonNode perform_L1_L2Validations(JsonNode entitiesNodeResponse, boolean isAggregateRequest,

    1959. 

  1959. 			boolean isMultiPartRequest) throws Exception {

    1960. 

  1960. 

    1961. 

  1961. 		JsonNode dataNode = null;

    1962. 

  1962. 		HashMap<String, String> columnMappingMap = null;

    1963. 

  1963. 		JsonNode sectionStructureNode = null;

    1964. 

  1964. 		HashMap<String, JsonNode> dimMap = new HashMap<String, JsonNode>();

    1965. 

  1965. 		String countryCode = null;

    1966. 

  1966. 		JsonNode otherSecDataNode = null;

    1967. 

  1967. 		JsonNode contextDataNode = null;

    1968. 

  1968. 		JsonNode resultNode = null;

    1969. 

  1969. 		JsonNode mlNode = null;

    1970. 

  1970. 		ArrayNode entityArr = null;

    1971. 

  1971. 		ArrayNode arr = null;

    1972. 

  1972. 		JsonNode entityNode = null;

    1973. 

  1973. 		JsonNode resultEntiryNode = null;

    1974. 

  1974. 		Map.Entry<String, JsonNode> entry = null;

    1975. 

  1975. 		Map.Entry<String, JsonNode> entry1 = null;

    1976. 

  1976. 		List<String> otherAndContextKeys = new ArrayList<>();

    1977. 

  1977. 		String tempArrayName = null;

    1978. 

  1978. 		entityArr = mapper.createArrayNode();

    1979. 

  1979. 		ArrayNode entitiesNode = (ArrayNode) entitiesNodeResponse.get(Constants.ENTITIES);

    1980. 

  1980. 		

    1981. 

  1981. 		boolean mlAutoCoorect=false;

    1982. 

  1982. 		JsonNode mLdataNode = null;

    1983. 

  1983. 		

    1984. 

  1984. 		// Making csv out of JSON single level

    1985. 

  1985. 		for (int i = 0; i < entitiesNode.size(); i++) {

    1986. 

  1986. 			countryCode = "";

    1987. 

  1987. 			arr = mapper.createArrayNode();

    1988. 

  1988. 			entityNode = entitiesNode.get(i);

    1989. 

  1989. 			resultEntiryNode = mapper.createObjectNode();

    1990. 

  1990. 			sectionStructureNode = entityNode.get(Constants.SECTION_STRUCTURE);

    1991. 

  1991. 			dataNode = entityNode.get(Constants.DATA);

    1992. 

  1992. 			otherSecDataNode = entityNode.get(Constants.OTHERSECTIONDATAKEY);

    1993. 

  1993. 			contextDataNode = entityNode.get(Constants.CONTEXTDATAKEY);

    1994. 

  1994. 			

    1995. 

  1995. 			// Before L1 for File upload ML Auto-correction API call will be executed.

    1996. 

  1996. 			// PE-6254 ML Integration works only for File upload case.

    1997. 

  1997. 			// Check flag from config file located in API_HOME 

    1998. 

  1998. 			if ( isMultiPartRequest  

    1999. 

  1999. 					&& "Y".equalsIgnoreCase(Cache.getMLProperty(CacheConstats.IS_AUTOCORRECTION).trim()) ) {

    2000. 

  2000. 				mlNode =  MachineLearningRestClient.callMLRestAPI(entityNode);

    2001. 

  2001. 				if( null != mlNode) {

    2002. 

  2002. 					dataNode = mlNode;

    2003. 

  2003. 					mlAutoCoorect=true;

    2004. 

  2004. 				}

    2005. 

  2005. 			}

    2006. 

  2006. 			//PE-6254 ML End.

    2007. 

  2007. 			if (null != contextDataNode && contextDataNode.has("ctryCode")) {

    2008. 

  2008. 				countryCode = contextDataNode.get("ctryCode").asText();

    2009. 

  2009. 			}

    2010. 

  2010. 			

    2011. 

  2011. 			HashMap<String, JsonNode> dataMap = new HashMap<String, JsonNode>();

    2012. 

  2012. 

    2013. 

  2013. 			contextAndOtherSectionDataToMap(dataMap, otherSecDataNode, contextDataNode, otherAndContextKeys, entry,

    2014. 

  2014. 					entry1, tempArrayName, isMultiPartRequest);

    2015. 

  2015. 					//PE-8552

    2016. 

  2016. 			HashMap<String, JsonNode> contextDataAndOtherDataMap = new HashMap<String, JsonNode>(dataMap);

    2017. 

  2017. 

    2018. 

  2018. 			ArrayList<JsonNode> columnNodeList = new ArrayList<JsonNode>();

    2019. 

  2019. 			columnMappingMap = new HashMap<String, String>();

    2020. 

  2020. 			APIExpressionEvaluator apiExpressionEvaluator = new APIExpressionEvaluator();

    2021. 

  2021. 

    2022. 

  2022. 			String uuid = setColumnMappingAndDataForAggregation(apiExpressionEvaluator, columnNodeList,

    2023. 

  2023. 					otherAndContextKeys, columnMappingMap, sectionStructureNode, dataMap, dimMap, dataNode,

    2024. 

  2024. 					countryCode);

    2025. 

  2025. 

    2026. 

  2026. 			// Added by Nikhil

    2027. 

  2027. 			// Start PE-7056 Expression should not executed if columns are not

    2028. 

  2028. 			// present in MetaData.

    2029. 

  2029. 			List<String> metaDataColumnsOnly = null;

    2030. 

  2030. 			metaDataColumnsOnly = DataUtility.extractColumnsFromMetaData(apiExpressionEvaluator);

    2031. 

  2031. 			if (!otherAndContextKeys.isEmpty()) {

    2032. 

  2032. 				metaDataColumnsOnly.addAll(otherAndContextKeys);

    2033. 

  2033. 			}

    2034. 

  2034. 			// End PE-7056

    2035. 

  2035. 

    2036. 

  2036. 			Iterator<Map.Entry<String, JsonNode>> iterator = null;

    2037. 

  2037. 			for (int k = 0; k < dataNode.size(); k++) {

    2038. 

  2038. 				if(mlAutoCoorect)

    2039. 

  2039. 				{

    2040. 

  2040. 				mLdataNode = dataNode.get(k);

    2041. 

  2041. 				}

    2042. 

  2042. 				iterator = dataNode.get(k).fields();

    2043. 

  2043. 				while (iterator.hasNext()) {

    2044. 

  2044. 					entry = iterator.next();

    2045. 

  2045. 					//8552

    2046. 

  2046.  					JsonNode value = JsonUtils.isNullNode(entry.getValue()) ? null : entry.getValue();

    2047. 

  2047. 					if (entry.getValue().getNodeType() != JsonNodeType.OBJECT) {

    2048. 

  2048. 						// PE-6254 ML Integration works start

    2049. 

  2049. 						if(mlAutoCoorect)

    2050. 

  2050. 						{

    2051. 

  2051. 							if(entry.getKey().trim().contains("_ACflag") || entry.getKey().trim().contains("_Replace"))

    2052. 

  2052. 							{

    2053. 

  2053. 								continue;

    2054. 

  2054. 							}

    2055. 

  2055. 							else

    2056. 

  2056. 							{	

    2057. 

  2057. 								if(mLdataNode.get(entry.getKey()+"_ACflag").asText().equalsIgnoreCase("R"))

    2058. 

  2058. 								{

    2059. 

  2059. 									dataMap.put(entry.getKey().trim(), mLdataNode.get(entry.getKey()+"_Replace"));

    2060. 

  2060. 								}

    2061. 

  2061. 								else

    2062. 

  2062. 								{

    2063. 

  2063. 									dataMap.put(entry.getKey().trim(), value);	

    2064. 

  2064. 								}

    2065. 

  2065. 							}

    2066. 

  2066. 						}

    2067. 

  2067. 						// PE-6254 ML Integration works end

    2068. 

  2068. 						else

    2069. 

  2069. 						{

    2070. 

  2070. 							dataMap.put(entry.getKey().trim(), value);	

    2071. 

  2071. 						}

    2072. 

  2072. 					} else {

    2073. 

  2073. 						dataMap = parseJsonObjectMap(entry.getKey(), value, dataMap, null,

    2074. 

  2074. 								mapper.valueToTree(columnNodeList), null); // PE-7605 (2)

    2075. 

  2075. 					}

    2076. 

  2076. 				}

    2077. 

  2077. 				dataMap = updateDataMapWithEmptyDimension(dataMap, dimMap);

    2078. 

  2078. 				// logger.debug(String.format("dataMap..%s", dataMap));

    2079. 

  2079. 				resultNode = validate(dataMap, columnNodeList, dataNode.get(k), apiExpressionEvaluator, false,

    2080. 

  2080. 						columnMappingMap, dimMap, metaDataColumnsOnly,mlAutoCoorect);

    2081. 

  2081. 				arr.add(resultNode);

    2082. 

  2082. 				// logger.debug(String.format("resultNode..%s", resultNode));

    2083. 

  2083.  				//tempMetaDataColumn.removeAll(dataNodeColumnsOnly);

    2084. 

  2084. 				/*if (tempMetaDataColumn != null && tempMetaDataColumn.size() > 0) {

    2085. 

  2085. 					for (String key : tempMetaDataColumn) {

    2086. 

  2086. 						dataMap.remove(key);

    2087. 

  2087. 					}

    2088. 

  2088. 				}*/

    2089. 

  2089. 				dataMap = new HashMap<String, JsonNode>(contextDataAndOtherDataMap);

    2090. 

  2090.  			}

    2091. 

  2091. 

    2092. 

  2092. 			((ObjectNode) (resultEntiryNode)).set(Constants.DATA, arr);

    2093. 

  2093. 

    2094. 

  2094. 			if (null != contextDataNode)

    2095. 

  2095. 				((ObjectNode) (resultEntiryNode)).set(Constants.CONTEXTDATAKEY, contextDataNode);

    2096. 

  2096. 			entityArr.add(resultEntiryNode);

    2097. 

  2097. 

    2098. 

  2098. 			// removing csv from expression evaluator

    2099. 

  2099. 			// added by Nikhil

    2100. 

  2100. 			apiExpressionEvaluator.getExpressionEvaluatorDriver().removeCsvData(uuid);

    2101. 

  2101. 		}

    2102. 

  2102. 		resultNode = mapper.createObjectNode().set("entities", entityArr);

    2103. 

  2103. 		// logger.info(String.format("%s %s", Constants.EXIT ,Constants.LOG_PARSEANDVALIDATE));

    2104. 

  2104. 		return resultNode;

    2105. 

  2105. 	}

    2106. 

  2106. 	

    2107. 

  2107. 	private String setColumnMappingAndDataForAggregation(APIExpressionEvaluator apiExpressionEvaluator, ArrayList<JsonNode> columnNodeList,

    2108. 

  2108. 			List<String> otherAndContextKeys, HashMap<String, String> columnMappingMap, JsonNode sectionStructureNode,

    2109. 

  2109. 			HashMap<String, JsonNode> dataMap, HashMap<String, JsonNode> dimMap, JsonNode dataNode,

    2110. 

  2110. 			String countryCode) throws UnsupportedEncodingException, JSONException {

    2111. 

  2111. 		

    2112. 

  2112. 		if (sectionStructureNode.has(Constants.COLUMNS)) {

    2113. 

  2113. 			for (int j = 0; j < sectionStructureNode.get(Constants.COLUMNS).size(); j++) {

    2114. 

  2114. 				columnNodeList.add(sectionStructureNode.get(Constants.COLUMNS).get(j));

    2115. 

  2115. 				if (!JsonUtils.isNullOrBlankOrNullNode(

    2116. 

  2116. 						sectionStructureNode.get(Constants.COLUMNS).get(j).get("mappedColumnName"))

    2117. 

  2117. 						&& !sectionStructureNode.get(Constants.COLUMNS).get(j).get("mappedColumnName").equals(""))

    2118. 

  2118. 					if (!JsonUtils

    2119. 

  2119. 							.isNullOrBlankOrNullNode(sectionStructureNode.get(Constants.COLUMNS).get(j).get("code")))

    2120. 

  2120. 						columnMappingMap.put(sectionStructureNode.get(Constants.COLUMNS).get(j).get("code").asText(),

    2121. 

  2121. 								sectionStructureNode.get(Constants.COLUMNS).get(j).get("mappedColumnName").asText());

    2122. 

  2122. 			}

    2123. 

  2123. 		}

    2124. 

  2124. 

    2125. 

  2125. 		if (!JsonUtils.isNullOrBlankOrNullNode(dataNode)) {

    2126. 

  2126. 			JSONArray myArr = new JSONArray(dataNode.toString());

    2127. 

  2127. 			Set<String> keyList = new HashSet<>();

    2128. 

  2128. 			for (int j = 0; j < myArr.length(); j++) {

    2129. 

  2129. 				JSONObject json = myArr.getJSONObject(j);

    2130. 

  2130. 				Iterator<String> keys = json.keys();

    2131. 

  2131. 				while (keys.hasNext()) {

    2132. 

  2132. 					keyList.add(keys.next());

    2133. 

  2133. 				}

    2134. 

  2134. 			}

    2135. 

  2135. 			logger.info("FormValidator >> setColumnMappingAndDataForAggregation() >> CSVParser.parseFile : start");

    2136. 

  2136. 			long startTImeForCSVParseFile = System.currentTimeMillis();

    2137. 

  2137. 			CSVParser.parseFile(new ByteArrayInputStream(

    2138. 

  2138. 					(JsonUtils.rowToString(new JSONArray(keyList)) + JsonUtils.toString(new JSONArray(keyList), myArr))

    2139. 

  2139. 							.toString().getBytes("UTF-8")));

    2140. 

  2140. 			logger.info("FormValidator >> setColumnMappingAndDataForAggregation() >> CSVParser.parseFile : end. Took : "

    2141. 

  2141. 					+ (System.currentTimeMillis() - startTImeForCSVParseFile) + " msec");

    2142. 

  2142. 		}

    2143. 

  2143. 

    2144. 

  2144. 		// Set Column - data type mapping - PE

    2145. 

  2145. 		apiExpressionEvaluator.setColumnDataTypeMapping(new HashMap<String, String>());

    2146. 

  2146. 		APIExpressionEvaluator.df.setMaximumFractionDigits(16);

    2147. 

  2147. 		APIExpressionEvaluator.df.setMinimumFractionDigits(1);

    2148. 

  2148. 

    2149. 

  2149. 		/**

    2150. 

  2150. 		 * @author Vivek Kasadwar

    2151. 

  2151. 		 */

    2152. 

  2152. 		for (JsonNode columnNode : columnNodeList) {

    2153. 

  2153. 			if ((!JsonUtils.isNullOrBlankOrNullNode(columnNode.get(Constants.CODE))

    2154. 

  2154. 					&& !StringUtils.isBlank(columnNode.get(Constants.CODE).asText()))

    2155. 

  2155. 					&& (null != columnNode.get(Constants.DATA_TYPE))) {

    2156. 

  2156. 				apiExpressionEvaluator.getColumnDataTypeMapping().put(columnNode.get(Constants.CODE).asText(),

    2157. 

  2157. 						columnNode.get(Constants.DATA_TYPE).asText());

    2158. 

  2158. 				/**

    2159. 

  2159. 				 * @author Akhileshwar

    2160. 

  2160. 				 * @throws Exception

    2161. 

  2161. 				 *             PE-7045

    2162. 

  2162. 				 */

    2163. 

  2163. 				if (!JsonUtils.isNullOrBlankOrNullNode(columnNode.get(Constants.DIMENSIONS))) {

    2164. 

  2164. 					for (JsonNode dimensioNode : columnNode.get(Constants.DIMENSIONS)) {

    2165. 

  2165. 						apiExpressionEvaluator.getColumnDataTypeMapping().put(

    2166. 

  2166. 								columnNode.get(Constants.CODE).asText() + Constants.DOT + dimensioNode.asText(),

    2167. 

  2167. 								columnNode.get(Constants.DATA_TYPE).asText());

    2168. 

  2168. 					}

    2169. 

  2169. 					dimMap.put(columnNode.get(Constants.CODE).asText(), columnNode.get(Constants.DIMENSIONS));

    2170. 

  2170. 				}

    2171. 

  2171. 			}

    2172. 

  2172. 		}

    2173. 

  2173. 

    2174. 

  2174. 		HashMap<String, Object> otherParams = null;

    2175. 

  2175. 		if (!StringUtils.isEmpty(countryCode)) {

    2176. 

  2176. 			otherParams = new HashMap<String, Object>();

    2177. 

  2177. 			otherParams.put("countryCode", countryCode);

    2178. 

  2178. 		}

    2179. 

  2179. 		String uuid = apiExpressionEvaluator.getExpressionEvaluatorDriver().setCsvData(CSVParser.dataForAggregation, otherParams);

    2180. 

  2180. 		return uuid;

    2181. 

  2181. 	}

    2182. 

  2182. 

    2183. 

  2183. 	void contextAndOtherSectionDataToMap(HashMap<String, JsonNode> dataMap, JsonNode otherSecDataNode,

    2184. 

  2184. 			JsonNode contextDataNode, List<String> otherAndContextKeys, Entry<String, JsonNode> entry,

    2185. 

  2185. 			Entry<String, JsonNode> entry1, String tempArrayName, boolean isMultiPartRequest) throws Exception {

    2186. 

  2186. 

    2187. 

  2187. 		// Other Section data iterator

    2188. 

  2188. 		if (!JsonUtils.isNullOrBlankOrNullNode(otherSecDataNode) && !otherSecDataNode.toString().equals("")) {

    2189. 

  2189. 			Iterator<Map.Entry<String, JsonNode>> osdIt = otherSecDataNode.fields();

    2190. 

  2190. 			while (osdIt.hasNext()) {

    2191. 

  2191. 				entry = osdIt.next();

    2192. 

  2192. 				if (entry.getValue().getNodeType() != JsonNodeType.OBJECT) {

    2193. 

  2193. 					dataMap.put(Constants.OTHERSECTIONDATAKEY + "." + entry.getKey().trim(), entry.getValue());

    2194. 

  2194. 					// PE-7056

    2195. 

  2195. 					otherAndContextKeys.add(Constants.OTHERSECTIONDATAKEY + "." + entry.getKey().trim());

    2196. 

  2196. 				} else {

    2197. 

  2197. 					dataMap = parseJsonObjectMap(entry.getKey().trim(), entry.getValue(), dataMap,

    2198. 

  2198. 							Constants.OTHERSECTIONDATAKEY, null, otherAndContextKeys);

    2199. 

  2199. 				}

    2200. 

  2200. 			}

    2201. 

  2201. 			entry = null;

    2202. 

  2202. 		}

    2203. 

  2203. 

    2204. 

  2204. 		// Context data node iterator

    2205. 

  2205. 		// Populate dataMap with values from "contextDataNode"

    2206. 

  2206. 		if (!JsonUtils.isNullOrBlankOrNullNode(contextDataNode) && !contextDataNode.toString().equals("")) {

    2207. 

  2207. 			Iterator<Map.Entry<String, JsonNode>> contextIt = contextDataNode.fields();

    2208. 

  2208. 			while (contextIt.hasNext()) {

    2209. 

  2209. 				entry = contextIt.next();

    2210. 

  2210. 				if (entry.getValue().getNodeType() != JsonNodeType.OBJECT

    2211. 

  2211. 						&& entry.getValue().getNodeType() != JsonNodeType.ARRAY) {

    2212. 

  2212. 					dataMap.put(Constants.CONTEXTDATAKEY + "." + entry.getKey().trim(), entry.getValue());

    2213. 

  2213. 					// PE-7056

    2214. 

  2214. 					otherAndContextKeys.add(Constants.CONTEXTDATAKEY + "." + entry.getKey().trim());

    2215. 

  2215. 

    2216. 

  2216. 				} else if (entry.getValue().getNodeType() == JsonNodeType.ARRAY && (entry.getValue().size() > 0)) {

    2217. 

  2217. 					Iterator<Map.Entry<String, JsonNode>> arrIt = contextDataNode.fields();

    2218. 

  2218. 					tempArrayName = entry.getKey();

    2219. 

  2219. 					// PE - 7257

    2220. 

  2220. 					if (entry.getValue().getNodeType() == JsonNodeType.ARRAY && isMultiPartRequest) {

    2221. 

  2221. 						dataMap.put(Constants.CONTEXTDATAKEY + "." + entry.getKey().trim(), entry.getValue());

    2222. 

  2222. 						// PE-7056

    2223. 

  2223. 						otherAndContextKeys.add(Constants.CONTEXTDATAKEY + "." + entry.getKey().trim());

    2224. 

  2224. 					} else {

    2225. 

  2225. 						if (entry.getValue().size() > 0) {

    2226. 

  2226. 							arrIt = entry.getValue().get(0).fields();

    2227. 

  2227. 							while (arrIt.hasNext()) {

    2228. 

  2228. 								entry1 = arrIt.next();

    2229. 

  2229. 								dataMap.put(

    2230. 

  2230. 										Constants.CONTEXTDATAKEY + "." + tempArrayName + "." + entry1.getKey().trim(),

    2231. 

  2231. 										entry1.getValue());

    2232. 

  2232. 								// PE-7056

    2233. 

  2233. 								otherAndContextKeys.add(

    2234. 

  2234. 										Constants.CONTEXTDATAKEY + "." + tempArrayName + "." + entry1.getKey().trim());

    2235. 

  2235. 							}

    2236. 

  2236. 						}

    2237. 

  2237. 					}

    2238. 

  2238. 

    2239. 

  2239. 				} else {

    2240. 

  2240. 					dataMap = parseJsonObjectMap(entry.getKey(), entry.getValue(), dataMap, Constants.CONTEXTDATAKEY,

    2241. 

  2241. 							null, otherAndContextKeys);

    2242. 

  2242. 

    2243. 

  2243. 				}

    2244. 

  2244. 			}

    2245. 

  2245. 			entry = null;

    2246. 

  2246. 		}

    2247. 

  2247. 	}

    2248. 

  2248. 		

    2249. 

  2249. 	public JsonNode performValidateAggregateRequest(JsonNode entitiesNodeResponse, boolean isAggregateRequest, boolean isMultiPartRequest) throws Exception {

    2250. 

  2250. 

    2251. 

  2251. 		JsonNode dataNode = null;

    2252. 

  2252. 		HashMap<String, String> columnMappingMap = null;

    2253. 

  2253. 		JsonNode sectionStructureNode = null;

    2254. 

  2254. 		HashMap<String, JsonNode> dimMap = new HashMap<String, JsonNode>();

    2255. 

  2255. 		String countryCode = null;

    2256. 

  2256. 		JsonNode otherSecDataNode = null;

    2257. 

  2257. 		JsonNode contextDataNode = null;

    2258. 

  2258. 		JsonNode resultNode = null;

    2259. 

  2259. 		ArrayNode entityArr = null;

    2260. 

  2260.  		JsonNode entityNode = null;

    2261. 

  2261. 		JsonNode resultEntiryNode = null;

    2262. 

  2262. 		Map.Entry<String, JsonNode> entry = null;

    2263. 

  2263. 		Map.Entry<String, JsonNode> entry1 = null;

    2264. 

  2264. 		List<String> otherAndContextKeys = new ArrayList<>();

    2265. 

  2265. 		String tempArrayName = null;

    2266. 

  2266. 		entityArr = mapper.createArrayNode();

    2267. 

  2267. 

    2268. 

  2268. 		ArrayNode entitiesNode = (ArrayNode) entitiesNodeResponse.get(Constants.ENTITIES);

    2269. 

  2269. 

    2270. 

  2270. 		// Making csv out of JSON single level

    2271. 

  2271. 		for (int i = 0; i < entitiesNode.size(); i++) {

    2272. 

  2272. 			countryCode = "";

    2273. 

  2273.  			entityNode = entitiesNode.get(i);

    2274. 

  2274. 			resultEntiryNode = mapper.createObjectNode();

    2275. 

  2275. 			

    2276. 

  2276. 			if (entityNode.has(Constants.SECTION_STRUCTURE)) {

    2277. 

  2277. 				sectionStructureNode = entityNode.get(Constants.SECTION_STRUCTURE);

    2278. 

  2278. 			}

    2279. 

  2279. 			if (entityNode.has(Constants.DATA)) {

    2280. 

  2280. 				dataNode = entityNode.get(Constants.DATA);

    2281. 

  2281. 			}

    2282. 

  2282. 			if (entityNode.has(Constants.OTHERSECTIONDATAKEY)) {

    2283. 

  2283. 				otherSecDataNode = entityNode.get(Constants.OTHERSECTIONDATAKEY);

    2284. 

  2284. 			}

    2285. 

  2285. 			if (entityNode.has(Constants.CONTEXTDATAKEY)) {

    2286. 

  2286. 				contextDataNode = entityNode.get(Constants.CONTEXTDATAKEY);

    2287. 

  2287. 			}

    2288. 

  2288. 

    2289. 

  2289. 			if (null != contextDataNode && contextDataNode.has("ctryCode")) {

    2290. 

  2290. 				countryCode = contextDataNode.get("ctryCode").asText();

    2291. 

  2291. 			}

    2292. 

  2292. 			

    2293. 

  2293. 			HashMap<String, JsonNode> dataMap = new HashMap<String, JsonNode>();

    2294. 

  2294. 

    2295. 

  2295. 			contextAndOtherSectionDataToMap(dataMap, otherSecDataNode, contextDataNode, otherAndContextKeys, entry,

    2296. 

  2296. 					entry1, tempArrayName, isMultiPartRequest);

    2297. 

  2297. 

    2298. 

  2298. 			ArrayList<JsonNode> columnNodeList = new ArrayList<JsonNode>();

    2299. 

  2299. 			columnMappingMap = new HashMap<String, String>();

    2300. 

  2300. 			APIExpressionEvaluator apiExpressionEvaluator = new APIExpressionEvaluator();

    2301. 

  2301. 

    2302. 

  2302. 			String uuid = setColumnMappingAndDataForAggregation(apiExpressionEvaluator, columnNodeList,

    2303. 

  2303. 					otherAndContextKeys, columnMappingMap, sectionStructureNode, dataMap, dimMap, dataNode,

    2304. 

  2304. 					countryCode);

    2305. 

  2305. 

    2306. 

  2306. 			// Added by Nikhil

    2307. 

  2307. 			// Start PE-7056 Expression should not executed if columns are not

    2308. 

  2308. 			// present in MetaData.

    2309. 

  2309. 			List<String> metaDataColumnsOnly = null;

    2310. 

  2310. 			metaDataColumnsOnly = DataUtility.extractColumnsFromMetaData(apiExpressionEvaluator);

    2311. 

  2311. 			if (!otherAndContextKeys.isEmpty()) {

    2312. 

  2312. 				metaDataColumnsOnly.addAll(otherAndContextKeys);

    2313. 

  2313. 			}

    2314. 

  2314. 			// End PE-7056

    2315. 

  2315. 

    2316. 

  2316. 			// PE : 2449 to update datamap with entity data which was

    2317. 

  2317. 			// missing in case of aggregate

    2318. 

  2318. 

    2319. 

  2319. 			Iterator<Map.Entry<String, JsonNode>> iterator = null;

    2320. 

  2320. 			

    2321. 

  2321. 			if(dataNode.isArray() && dataNode.size()!=0) {	// Remove NullPointer when there is no object in data-node.

    2322. 

  2322. 				iterator = dataNode.get(0).fields();

    2323. 

  2323. 				while (iterator.hasNext()) {

    2324. 

  2324. 					entry = iterator.next();

    2325. 

  2325. 					JsonNode value = JsonUtils.isNullNode(entry.getValue()) ? null : entry.getValue();

    2326. 

  2326. 					if (entry.getValue().getNodeType() != JsonNodeType.OBJECT) {

    2327. 

  2327. 						dataMap.put(entry.getKey().trim(), value);

    2328. 

  2328. 					} else {

    2329. 

  2329. 						dataMap = parseJsonObjectMap(entry.getKey(), value, dataMap, null, null, null);

    2330. 

  2330. 					}

    2331. 

  2331. 				}

    2332. 

  2332. 			}

    2333. 

  2333. 			resultNode = validate(dataMap, columnNodeList, dataNode.get(0), apiExpressionEvaluator, true,

    2334. 

  2334. 					columnMappingMap, dimMap, metaDataColumnsOnly,false);

    2335. 

  2335. 

    2336. 

  2336. 			((ObjectNode) (resultEntiryNode)).set(Constants.VALIDATION_RESULTS, resultNode);

    2337. 

  2337. 			if (null != contextDataNode)

    2338. 

  2338. 				((ObjectNode) (resultEntiryNode)).set(Constants.CONTEXTDATAKEY, contextDataNode);

    2339. 

  2339. 			entityArr.add(resultEntiryNode);

    2340. 

  2340. 			apiExpressionEvaluator.getExpressionEvaluatorDriver().removeCsvData(uuid);

    2341. 

  2341. 

    2342. 

  2342. 		}

    2343. 

  2343. 		

    2344. 

  2344. 		resultNode = mapper.createObjectNode().set("entities", entityArr);

    2345. 

  2345. 		// logger.info(String.format("%s %s", Constants.EXIT ,Constants.LOG_PARSEANDVALIDATE));

    2346. 

  2346. 		return resultNode;

    2347. 

  2347. 	}

    2348. 

  2348. 	// PE-6254 ML Integration works start

    2349. 

  2349. 	public ObjectNode prepareMLAutocorrectObject(String field,String validationType,JsonNode originalvalue)

    2350. 

  2350. 	{

    2351. 

  2351. 		ObjectNode validation = mapper.createObjectNode();

    2352. 

  2352. 		validation.put(Constants.FIELD, field);

    2353. 

  2353. 		validation.put(Constants.ERROR_TYPE, Constants.AUTOCORRECT);

    2354. 

  2354. 		// validation.put(Constants.MESSAGE, result);

    2355. 

  2355. 		validation.put(Constants.MESSAGE_KEY,

    2356. 

  2356. 				in.lnt.utility.general.Cache.getPropertyFromError(ErrorCacheConstant.ERR_059));

    2357. 

  2357. 		if(!JsonUtils.isNullOrBlankOrNullNode((originalvalue)))

    2358. 

  2358. 		validation.put(Constants.ORIGINAL_VALUE,originalvalue.asText());

    2359. 

  2359. 		else

    2360. 

  2360. 		validation.put(Constants.ORIGINAL_VALUE,"");

    2361. 

  2361. 		return validation;

    2362. 

  2362. 	}

    2363. 

  2363. 	public void removeDataNodeACFields(JsonNode dataNode)

    2364. 

  2364. 	{

    2365. 

  2365. 		Iterator<Map.Entry<String, JsonNode>> iterator = null;

    2366. 

  2366. 		iterator = dataNode.fields();

    2367. 

  2367. 		//dataNode.

    2368. 

  2368. 		List<String> fieldsToDelete=new ArrayList<String>();

    2369. 

  2369. 		Map.Entry<String, JsonNode> entry = null;

    2370. 

  2370. 		while (iterator.hasNext()) {

    2371. 

  2371. 			entry = iterator.next();

    2372. 

  2372. 			if(entry.getKey().trim().contains("_ACflag") || entry.getKey().trim().contains("_Replace"))

    2373. 

  2373. 			{}

    2374. 

  2374. 			else{

    2375. 

  2375. 				fieldsToDelete.add(entry.getKey());

    2376. 

  2376. 			}

    2377. 

  2377. 		}

    2378. 

  2378. 		((ObjectNode)dataNode).retain(fieldsToDelete);

    2379. 

  2379. 	}

    2380. 

  2380. 	// PE-6254 ML Integration works end

    2381. 

  2381. }

    2382. 

  2382.