ui/src/main/java/org/akraino/validation/ui/service/DbResultAdapter.java

   1 package org.akraino.validation.ui.service;
   2
   3 import java.io.IOException;
   4 import java.util.ArrayList;
   5 import java.util.HashSet;
   6 import java.util.List;
   7
   8 import javax.annotation.Nonnull;
   9
  10 import org.akraino.validation.ui.client.nexus.resources.RobotTestResult;
  11 import org.akraino.validation.ui.client.nexus.resources.ValidationNexusTestResult;
  12 import org.akraino.validation.ui.client.nexus.resources.WRobotNexusTestResult;
  13 import org.akraino.validation.ui.dao.ValidationTestResultDAO;
  14 import org.akraino.validation.ui.dao.WRobotTestResultDAO;
  15 import org.akraino.validation.ui.data.BlueprintLayer;
  16 import org.akraino.validation.ui.data.JnksJobNotify;
  17 import org.akraino.validation.ui.data.Lab;
  18 import org.akraino.validation.ui.data.SubmissionData;
  19 import org.akraino.validation.ui.entity.LabInfo;
  20 import org.akraino.validation.ui.entity.LabSilo;
  21 import org.akraino.validation.ui.entity.Submission;
  22 import org.akraino.validation.ui.entity.ValidationDbTestResult;
  23 import org.akraino.validation.ui.entity.WRobotDbTestResult;
  24 import org.onap.portalsdk.core.logging.logic.EELFLoggerDelegate;
  25 import org.onap.portalsdk.core.web.support.UserUtils;
  26 import org.springframework.beans.factory.annotation.Autowired;
  27 import org.springframework.stereotype.Service;
  28 import org.springframework.transaction.annotation.Transactional;
  29
  30 import com.fasterxml.jackson.core.JsonParseException;
  31 import com.fasterxml.jackson.core.JsonProcessingException;
  32 import com.fasterxml.jackson.core.type.TypeReference;
  33 import com.fasterxml.jackson.databind.JsonMappingException;
  34 import com.fasterxml.jackson.databind.ObjectMapper;
  35
  36 @Service
  37 @Transactional
  38 public class DbResultAdapter {
  39
  40     private static final EELFLoggerDelegate LOGGER = EELFLoggerDelegate.getLogger(DbResultAdapter.class);
  41     private static final Object LOCK = new Object();
  42
  43     @Autowired
  44     LabService labService;
  45
  46     @Autowired
  47     private ValidationTestResultDAO vTestResultDAO;
  48
  49     @Autowired
  50     private WRobotTestResultDAO wRobotDAO;
  51
  52     @Autowired
  53     private SiloService siloService;
  54
  55     @Autowired
  56     DbSubmissionAdapter subService;
  57
  58     public void associateSubmissionWithValidationResult(SubmissionData submissionData)
  59             throws JsonParseException, JsonMappingException, IOException {
  60         synchronized (LOCK) {
  61             ValidationDbTestResult vDbTestResult = this
  62                     .convertValidationNexusToDb(submissionData.getValidationNexusTestResult());
  63             Submission submission = new Submission();
  64             submission.setSubmissionId(submissionData.getSubmissionId());
  65             vDbTestResult.setSubmission(submission);
  66             vTestResultDAO.saveOrUpdate(vDbTestResult);
  67             List<WRobotDbTestResult> vRobotDbResults = this.convertWRobotNexusResultsToDb(
  68                     submissionData.getValidationNexusTestResult().getwRobotNexusTestResults());
  69             if (vRobotDbResults != null) {
  70                 for (WRobotDbTestResult vRobotDbResult : vRobotDbResults) {
  71                     vRobotDbResult.setValidationTestResult(vDbTestResult);
  72                     wRobotDAO.saveOrUpdate(vRobotDbResult);
  73                 }
  74             }
  75         }
  76     }
  77
  78     public void storeResultInDb(List<ValidationNexusTestResult> vNexusResults) {
  79         synchronized (LOCK) {
  80             if (vNexusResults == null || vNexusResults.size() < 1) {
  81                 return;
  82             }
  83             for (ValidationNexusTestResult vNexusResult : vNexusResults) {
  84                 if (!checkValidityOfValidationNexusTestResult(vNexusResult)) {
  85                     continue;
  86                 }
  87                 LabInfo labInfo = null;
  88                 for (LabSilo silo : siloService.getSilos()) {
  89                     if (silo.getSilo().equals(vNexusResult.getSilo())) {
  90                         labInfo = silo.getLab();
  91                     }
  92                 }
  93                 ValidationDbTestResult vDbResult = vTestResultDAO.getValidationTestResult(labInfo,
  94                         vNexusResult.getTimestamp());
  95                 if (vDbResult == null) {
  96                     vDbResult = new ValidationDbTestResult();
  97                     vDbResult.setLab(labInfo);
  98                     vDbResult.setTimestamp(vNexusResult.getTimestamp());
  99                     vDbResult.setBlueprintName(vNexusResult.getBlueprintName());
 100                     vDbResult.setVersion(vNexusResult.getVersion());
 101                     vDbResult.setAllLayers(vNexusResult.getAllLayers());
 102                     vDbResult.setOptional(vNexusResult.getOptional());
 103                 }
 104                 vDbResult.setResult(vNexusResult.getResult());
 105                 vDbResult.setDateStorage(vNexusResult.getDateOfStorage());
 106                 LOGGER.debug(EELFLoggerDelegate.debugLogger,
 107                         "Storing validation test result with keys: blueprint name: " + vNexusResult.getBlueprintName()
 108                         + ", version: " + vNexusResult.getVersion() + ", lab: " + vNexusResult.getSilo()
 109                         + ", timestamp: " + vNexusResult.getTimestamp());
 110                 vTestResultDAO.saveOrUpdate(vDbResult);
 111                 List<org.akraino.validation.ui.entity.WRobotDbTestResult> wRobotDbResults = wRobotDAO
 112                         .getWRobotTestResult(vDbResult);
 113                 if (wRobotDbResults == null) {
 114                     // Store the new wrapper robot rest results in db
 115                     for (WRobotNexusTestResult wNexusResult : vNexusResult.getwRobotNexusTestResults()) {
 116                         WRobotDbTestResult wRobotDbResult = new WRobotDbTestResult();
 117                         wRobotDbResult.setLayer(wNexusResult.getBlueprintLayer().name());
 118                         wRobotDbResult.setValidationTestResult(vDbResult);
 119                         ObjectMapper mapper = new ObjectMapper();
 120                         try {
 121                             wRobotDbResult
 122                             .setRobotTestResults(mapper.writeValueAsString(wNexusResult.getRobotTestResults()));
 123                         } catch (JsonProcessingException e) {
 124                             LOGGER.error(EELFLoggerDelegate.errorLogger,
 125                                     "Error while converting POJO to string. " + UserUtils.getStackTrace(e));
 126                             continue;
 127                         }
 128                         wRobotDAO.saveOrUpdate(wRobotDbResult);
 129                     }
 130                 } else if (vDbResult.getSubmission() != null) {
 131                     // update validation result related to submission
 132                     for (WRobotNexusTestResult wNexusResult : vNexusResult.getwRobotNexusTestResults()) {
 133                         WRobotDbTestResult wRobotDbResult = wRobotDAO
 134                                 .getWRobotTestResult(wNexusResult.getBlueprintLayer().name(), vDbResult);
 135                         ObjectMapper mapper = new ObjectMapper();
 136                         try {
 137                             wRobotDbResult
 138                             .setRobotTestResults(mapper.writeValueAsString(wNexusResult.getRobotTestResults()));
 139                         } catch (JsonProcessingException e) {
 140                             LOGGER.error(EELFLoggerDelegate.errorLogger,
 141                                     "Error while converting POJO to string. " + UserUtils.getStackTrace(e));
 142                             continue;
 143                         }
 144                         wRobotDAO.saveOrUpdate(wRobotDbResult);
 145                     }
 146                 }
 147             }
 148         }
 149     }
 150
 151     public void updateTimestamp(JnksJobNotify jnksJobNotify) {
 152         synchronized (LOCK) {
 153             if (!checkValidityOfJenkinsNotification(jnksJobNotify)) {
 154                 return;
 155             }
 156             ValidationDbTestResult vDbSubmission = vTestResultDAO
 157                     .getValidationTestResult(subService.getSubmission(String.valueOf(jnksJobNotify.getSubmissionId())));
 158             ValidationDbTestResult vDbTimestamp = vTestResultDAO.getValidationTestResult(vDbSubmission.getLab(),
 159                     jnksJobNotify.getTimestamp());
 160             if (vDbTimestamp == null) {
 161                 vDbSubmission.setTimestamp(jnksJobNotify.getTimestamp());
 162                 vTestResultDAO.saveOrUpdate(vDbSubmission);
 163                 return;
 164             }
 165             // Delete the wrobot results associated with submission validation result
 166             List<WRobotDbTestResult> wRobotResults = wRobotDAO.getWRobotTestResult(vDbSubmission);
 167             if (wRobotResults != null && wRobotResults.size() > 0) {
 168                 for (WRobotDbTestResult wRobotResult : wRobotResults) {
 169                     wRobotDAO.deleteWRobotTestResult(wRobotResult.getWRobotResultId());
 170                 }
 171             }
 172             // Change the timestamp wrobot results to point to submission validation result
 173             wRobotResults = wRobotDAO.getWRobotTestResult(vDbTimestamp);
 174             if (wRobotResults != null && wRobotResults.size() > 0) {
 175                 for (WRobotDbTestResult wRobotResult : wRobotResults) {
 176                     wRobotResult.setValidationTestResult(vDbSubmission);
 177                     wRobotDAO.saveOrUpdate(wRobotResult);
 178                 }
 179             }
 180             vTestResultDAO.deleteValidationTestResult(vDbTimestamp);
 181             // Now vDbSubmission can be updated
 182             vDbSubmission.setDateStorage(vDbTimestamp.getDateStorage());
 183             vDbSubmission.setResult(vDbTimestamp.getResult());
 184             vDbSubmission.setTimestamp(vDbTimestamp.getTimestamp());
 185             vTestResultDAO.saveOrUpdate(vDbSubmission);
 186         }
 187     }
 188
 189     public List<ValidationNexusTestResult> readResultFromDb(String blueprintName, String version, Lab lab,
 190             List<BlueprintLayer> layers, Boolean allLayers, Boolean optional, Boolean outcome)
 191                     throws JsonParseException, JsonMappingException, IOException {
 192         synchronized (LOCK) {
 193             LabInfo actualLabInfo = labService.getLab(lab);
 194             List<ValidationDbTestResult> vDbResults = vTestResultDAO.getValidationTestResults(blueprintName, version,
 195                     actualLabInfo, allLayers, optional, outcome);
 196             if (vDbResults == null || vDbResults.size() < 1) {
 197                 return null;
 198             }
 199             List<ValidationNexusTestResult> vNexusResults = new ArrayList<ValidationNexusTestResult>();
 200             for (ValidationDbTestResult vDbResult : vDbResults) {
 201                 if (layers != null && layers.size() > 0) {
 202                     List<BlueprintLayer> storedLayers = new ArrayList<BlueprintLayer>();
 203                     List<WRobotDbTestResult> wDbResults = wRobotDAO.getWRobotTestResult(vDbResult);
 204                     if (wDbResults == null || wDbResults.size() < 1) {
 205                         continue;
 206                     }
 207                     for (WRobotDbTestResult wRobot : wDbResults) {
 208                         storedLayers.add(BlueprintLayer.valueOf(wRobot.getLayer()));
 209                     }
 210                     if (!new HashSet<>(storedLayers).equals(new HashSet<>(layers))) {
 211                         continue;
 212                     }
 213                 }
 214                 vNexusResults.add(convertValidationDbToNexus(vDbResult));
 215             }
 216             return vNexusResults;
 217         }
 218     }
 219
 220     public ValidationNexusTestResult readResultFromDb(@Nonnull Lab lab, @Nonnull String timestamp)
 221             throws JsonParseException, JsonMappingException, IOException {
 222         synchronized (LOCK) {
 223             LabInfo actualLabInfo = labService.getLab(lab);
 224             ValidationDbTestResult vDbResult = vTestResultDAO.getValidationTestResult(actualLabInfo, timestamp);
 225             if (vDbResult == null) {
 226                 return null;
 227             }
 228             return convertValidationDbToNexus(vDbResult);
 229         }
 230     }
 231
 232     public ValidationNexusTestResult readResultFromDb(@Nonnull String submissionId)
 233             throws JsonParseException, JsonMappingException, IOException {
 234         synchronized (LOCK) {
 235             ValidationDbTestResult vDbResult = vTestResultDAO
 236                     .getValidationTestResult(subService.getSubmission(submissionId));
 237             if (vDbResult == null) {
 238                 return null;
 239             }
 240             return convertValidationDbToNexus(vDbResult);
 241         }
 242     }
 243
 244     public void deleteUnreferencedEntries(List<ValidationNexusTestResult> vNexusResults) {
 245         synchronized (LOCK) {
 246             if (vNexusResults == null || vNexusResults.size() < 1) {
 247                 return;
 248             }
 249             LabInfo labInfo = null;
 250             for (LabSilo silo : siloService.getSilos()) {
 251                 if (silo.getSilo().equals(vNexusResults.get(0).getSilo())) {
 252                     labInfo = silo.getLab();
 253                 }
 254             }
 255             if (labInfo == null) {
 256                 return;
 257             }
 258             List<ValidationDbTestResult> vDbResults = vTestResultDAO.getValidationTestResults(
 259                     vNexusResults.get(0).getBlueprintName(), vNexusResults.get(0).getVersion(), labInfo, null, null,
 260                     null);
 261             if (vDbResults == null || vDbResults.size() < 1) {
 262                 return;
 263             }
 264             for (ValidationDbTestResult vDbResult : vDbResults) {
 265                 if (vDbResult.getSubmission() != null) {
 266                     continue;
 267                 }
 268                 boolean deletion = true;
 269                 String dbTimestamp = vDbResult.getTimestamp();
 270                 LabInfo dbLabInfo = vDbResult.getLab();
 271                 for (ValidationNexusTestResult vNexusResult : vNexusResults) {
 272                     LabInfo nexusLabInfo = null;
 273                     for (LabSilo silo : siloService.getSilos()) {
 274                         if (silo.getSilo().equals(vNexusResult.getSilo())) {
 275                             nexusLabInfo = silo.getLab();
 276                         }
 277                     }
 278                     if (nexusLabInfo == null) {
 279                         continue;
 280                     }
 281                     if (vNexusResult.getTimestamp().equals(dbTimestamp) && nexusLabInfo.equals(dbLabInfo)) {
 282                         deletion = false;
 283                         break;
 284                     }
 285                 }
 286                 if (deletion) {
 287                     LOGGER.debug(EELFLoggerDelegate.debugLogger,
 288                             "Deleting unreferenced validation result with id: " + vDbResult.getResultId());
 289                     // Delete old associated wrapper robot rest results from db
 290                     for (WRobotDbTestResult wRobotDbResult : wRobotDAO.getWRobotTestResult(vDbResult)) {
 291                         wRobotDAO.deleteWRobotTestResult(wRobotDbResult.getWRobotResultId());
 292                     }
 293                     vTestResultDAO.deleteValidationTestResult(vDbResult);
 294                 }
 295             }
 296
 297         }
 298     }
 299
 300     public List<ValidationDbTestResult> getValidationTestResults() {
 301         synchronized (LOCK) {
 302             return vTestResultDAO.getValidationTestResults();
 303         }
 304     }
 305
 306     public ValidationDbTestResult getValidationTestResult(Integer resultId) {
 307         synchronized (LOCK) {
 308             return vTestResultDAO.getValidationTestResult(resultId);
 309         }
 310     }
 311
 312     public List<ValidationDbTestResult> getValidationTestResults(String blueprintName, String version, LabInfo labInfo,
 313             Boolean allLayers, Boolean optional, Boolean outcome) {
 314         synchronized (LOCK) {
 315             return vTestResultDAO.getValidationTestResults(blueprintName, version, labInfo, allLayers, optional,
 316                     outcome);
 317         }
 318     }
 319
 320     public ValidationDbTestResult getValidationTestResult(LabInfo labInfo, String timestamp) {
 321         synchronized (LOCK) {
 322             return vTestResultDAO.getValidationTestResult(labInfo, timestamp);
 323         }
 324     }
 325
 326     public ValidationDbTestResult getValidationTestResult(@Nonnull Submission submission) {
 327         synchronized (LOCK) {
 328             return vTestResultDAO.getValidationTestResult(submission);
 329         }
 330     }
 331
 332     public List<WRobotDbTestResult> getWRobotTestResults() {
 333         synchronized (LOCK) {
 334             return wRobotDAO.getWRobotTestResults();
 335         }
 336     }
 337
 338     public WRobotDbTestResult getWRobotTestResult(Integer wRobotResultId) {
 339         synchronized (LOCK) {
 340             return wRobotDAO.getWRobotTestResult(wRobotResultId);
 341         }
 342     }
 343
 344     public List<WRobotDbTestResult> getWRobotTestResult(ValidationDbTestResult vResult) {
 345         synchronized (LOCK) {
 346             return wRobotDAO.getWRobotTestResult(vResult);
 347         }
 348     }
 349
 350     private ValidationNexusTestResult convertValidationDbToNexus(ValidationDbTestResult vDbResult)
 351             throws JsonParseException, JsonMappingException, IOException {
 352         ValidationNexusTestResult vNexusResult = new ValidationNexusTestResult();
 353         vNexusResult.setResultId(vDbResult.getResultId());
 354         vNexusResult.setBlueprintName(vDbResult.getBlueprintName());
 355         vNexusResult.setVersion(vDbResult.getVersion());
 356         vNexusResult.setAllLayers(vDbResult.getAllLayers());
 357         vNexusResult.setDateOfStorage(vDbResult.getDateStorage());
 358         vNexusResult.setOptional(vDbResult.getOptional());
 359         vNexusResult.setResult(vDbResult.getResult());
 360         String siloText = null;
 361         for (LabSilo silo : siloService.getSilos()) {
 362             if (silo.getLab().getLab().equals(vDbResult.getLab().getLab())) {
 363                 siloText = silo.getSilo();
 364             }
 365         }
 366         if (siloText == null) {
 367             throw new IllegalArgumentException("Lab does not exist: " + vDbResult.getLab().toString());
 368         }
 369         vNexusResult.setSilo(siloText);
 370         vNexusResult.setTimestamp(vDbResult.getTimestamp());
 371         if (vDbResult.getSubmission() != null) {
 372             vNexusResult.setSubmissionId(String.valueOf(vDbResult.getSubmission().getSubmissionId()));
 373         }
 374         List<WRobotNexusTestResult> wNexusResults = new ArrayList<WRobotNexusTestResult>();
 375         List<WRobotDbTestResult> wDbResults = wRobotDAO.getWRobotTestResult(vDbResult);
 376         if (wDbResults != null && wDbResults.size() > 0) {
 377             for (WRobotDbTestResult wRobot : wDbResults) {
 378                 WRobotNexusTestResult wNexusResult = new WRobotNexusTestResult();
 379                 wNexusResult.setBlueprintLayer(BlueprintLayer.valueOf(wRobot.getLayer()));
 380                 if (wRobot.getRobotTestResults() != null) {
 381                     ObjectMapper mapper = new ObjectMapper();
 382                     wNexusResult.setRobotTestResults(
 383                             mapper.readValue(wRobot.getRobotTestResults(), new TypeReference<List<RobotTestResult>>() {
 384                             }));
 385                 }
 386                 wNexusResults.add(wNexusResult);
 387             }
 388             vNexusResult.setwRobotNexusTestResults(wNexusResults);
 389         }
 390         return vNexusResult;
 391     }
 392
 393     private ValidationDbTestResult convertValidationNexusToDb(ValidationNexusTestResult vNexusResult)
 394             throws JsonParseException, JsonMappingException, IOException {
 395         LabInfo labInfo = null;
 396         for (LabSilo silo : siloService.getSilos()) {
 397             if (silo.getSilo().equals(vNexusResult.getSilo())) {
 398                 labInfo = silo.getLab();
 399             }
 400         }
 401         if (labInfo == null) {
 402             return null;
 403         }
 404         ValidationDbTestResult vDbResult = new ValidationDbTestResult();
 405         vDbResult.setBlueprintName(vNexusResult.getBlueprintName());
 406         vDbResult.setVersion(vNexusResult.getVersion());
 407         vDbResult.setLab(labInfo);
 408         vDbResult.setOptional(vNexusResult.getOptional());
 409         vDbResult.setAllLayers(vNexusResult.getAllLayers());
 410         vDbResult.setDateStorage(vNexusResult.getDateOfStorage());
 411         vDbResult.setResult(vNexusResult.getResult());
 412         vDbResult.setTimestamp(vNexusResult.getTimestamp());
 413         return vDbResult;
 414     }
 415
 416     private List<WRobotDbTestResult> convertWRobotNexusResultsToDb(List<WRobotNexusTestResult> wRobotNexusResults) {
 417         if (wRobotNexusResults == null || wRobotNexusResults.size() < 1) {
 418             return null;
 419         }
 420         List<WRobotDbTestResult> wDbResults = new ArrayList<WRobotDbTestResult>();
 421         for (WRobotNexusTestResult wRobotNexusResult : wRobotNexusResults) {
 422             WRobotDbTestResult wDbResult = new WRobotDbTestResult();
 423             if (wRobotNexusResult.getBlueprintLayer() != null) {
 424                 wDbResult.setLayer(wRobotNexusResult.getBlueprintLayer().toString());
 425             }
 426             ObjectMapper mapper = new ObjectMapper();
 427             if (wRobotNexusResult.getRobotTestResults() != null && wRobotNexusResult.getRobotTestResults().size() > 0) {
 428                 try {
 429                     wDbResult.setRobotTestResults(mapper.writeValueAsString(wRobotNexusResult.getRobotTestResults()));
 430                 } catch (JsonProcessingException e) {
 431                     LOGGER.error(EELFLoggerDelegate.errorLogger,
 432                             "Error while converting POJO to string. " + UserUtils.getStackTrace(e));
 433                     continue;
 434                 }
 435             }
 436             wDbResults.add(wDbResult);
 437         }
 438         return wDbResults;
 439     }
 440
 441     private boolean checkValidityOfValidationNexusTestResult(ValidationNexusTestResult vNexusResult) {
 442         LabInfo labInfo = null;
 443         for (LabSilo silo : siloService.getSilos()) {
 444             if (silo.getSilo().equals(vNexusResult.getSilo())) {
 445                 labInfo = silo.getLab();
 446             }
 447         }
 448         if (labInfo == null) {
 449             LOGGER.error(EELFLoggerDelegate.errorLogger, "No lab Info found for silo. " + vNexusResult.getSilo());
 450             return false;
 451         }
 452         ValidationDbTestResult vDbResult = vTestResultDAO.getValidationTestResult(labInfo, vNexusResult.getTimestamp());
 453         if (vDbResult != null) {
 454             // Be elastic for allLayers and optional
 455             if (!vDbResult.getBlueprintName().equals(vNexusResult.getBlueprintName())
 456                     || !vDbResult.getVersion().equals(vNexusResult.getVersion()) || !vDbResult.getLab().equals(labInfo)
 457                     || !vDbResult.getTimestamp().equals(vNexusResult.getTimestamp())) {
 458                 LOGGER.error(EELFLoggerDelegate.errorLogger,
 459                         "Nexus has different data for blueprint : " + vDbResult.getBlueprintName() + ", version: "
 460                                 + vDbResult.getVersion() + " and lab: " + vDbResult.getLab().getLab().name());
 461                 return false;
 462             }
 463         }
 464         List<org.akraino.validation.ui.entity.WRobotDbTestResult> wRobotDbResults = wRobotDAO
 465                 .getWRobotTestResult(vDbResult);
 466         if (wRobotDbResults != null) {
 467             if (vDbResult.getSubmission() != null) {
 468                 for (WRobotNexusTestResult wNexusResult : vNexusResult.getwRobotNexusTestResults()) {
 469                     WRobotDbTestResult wRobotDbResult = wRobotDAO
 470                             .getWRobotTestResult(wNexusResult.getBlueprintLayer().name(), vDbResult);
 471                     if (wRobotDbResult == null) {
 472                         LOGGER.error(EELFLoggerDelegate.errorLogger,
 473                                 "Nexus has different layer results for submission id: "
 474                                         + vDbResult.getSubmission().getSubmissionId());
 475                         return false;
 476                     }
 477                 }
 478             }
 479         }
 480         return true;
 481     }
 482
 483     private boolean checkValidityOfJenkinsNotification(JnksJobNotify jnksJobNotify) {
 484         ValidationDbTestResult vDbSubmission = vTestResultDAO
 485                 .getValidationTestResult(subService.getSubmission(String.valueOf(jnksJobNotify.getSubmissionId())));
 486         if (vDbSubmission == null) {
 487             return false;
 488         }
 489         ValidationDbTestResult vDbTimestamp = vTestResultDAO.getValidationTestResult(vDbSubmission.getLab(),
 490                 jnksJobNotify.getTimestamp());
 491         if (vDbTimestamp == null) {
 492             return true;
 493         }
 494         if (vDbTimestamp.equals(vDbSubmission) || (vDbTimestamp.getSubmission() != null
 495                 && !jnksJobNotify.getSubmissionId().equals(vDbTimestamp.getSubmission().getSubmissionId()))) {
 496             LOGGER.error(EELFLoggerDelegate.errorLogger, "Received same timestamp: " + jnksJobNotify.getTimestamp()
 497             + " from nexus for submission id: " + jnksJobNotify.getSubmissionId());
 498             return false;
 499         }
 500         // Be elastic for allLayers and optional
 501         if (!vDbSubmission.getBlueprintName().equals(vDbTimestamp.getBlueprintName())
 502                 || !vDbSubmission.getVersion().equals(vDbTimestamp.getVersion())
 503                 || !vDbSubmission.getLab().equals(vDbTimestamp.getLab())) {
 504             LOGGER.error(EELFLoggerDelegate.errorLogger, "No consistency exists in database records.");
 505             return false;
 506         }
 507         return true;
 508     }
 509
 510 }