docs: public PromotionReportView getPromotionReport(final String moduleId) {
          if (LOG.isDebugEnabled()) {
              LOG.debug(String.format(":: Starting promo report [%s]", moduleId));
          }
  
          final PromotionReportView fromCache = cache.get(moduleId);
          if (null != fromCache) {
              return fromCache;
          }
  
          final DependencyHandler depHandler = new DependencyHandler(repositoryHandler);
          final ModelMapper modelMapper = new ModelMapper(repositoryHandler);
          final DbModule module = getModule(moduleId);
          final DbOrganization organization = getOrganization(module);
  
  
          final PromotionReportView report = new PromotionReportView();
          report.setRootModule(DataModelFactory.createModule(module.getName(), module.getVersion()));
  
  //        if (!report.isSnapshot()) {
              // filters initialization
              final FiltersHolder filters = new FiltersHolder();
              filters.addFilter(new PromotedFilter(false));
              filters.addFilter(new CorporateFilter(organization));
  
              // Checks if each dependency module has been promoted
              final List<Dependency> deps = depHandler.getModuleDependencies(moduleId, filters);
              removeDuplicates(deps);
  
              for (final Dependency dependency : deps) {
                  final DbModule depModule = repositoryHandler.getRootModuleOf(dependency.getTarget().getGavc());
                  if (depModule != null && !depModule.getId().equals(moduleId) && !depModule.isPromoted()) {
                      report.addUnPromotedDependency(dependency.getTarget().getGavc());
                      report.addDependencyPromotionReport(depModule.getId(), getPromotionReport(depModule.getId()));
                  }
              }
  
              // Checks if the module has dependencies that shouldn't be used
              final List<String> treatedArtifacts = new ArrayList<>();
              for (final DbDependency dependency : DataUtils.getAllDbDependencies(module)) {
                  if(dependency.getScope().equals(Scope.TEST)) {
                      continue;
                  }
  
                  final DbArtifact artifactDep = repositoryHandler.getArtifact(dependency.getTarget());
  
                  if (artifactDep == null) {
                      // handle the case of a corporate artifact which is not available in the repository
                      continue;
                  }
  
                  if (artifactDep.getDoNotUse() && !treatedArtifacts.contains(artifactDep.getGavc())) {
                      DbComment dbComment = repositoryHandler.getLatestComment(artifactDep.getGavc(), artifactDep.getClass().getSimpleName());
                      report.addDoNotUseArtifact(modelMapper.getArtifact(artifactDep), dbComment == null ? null : modelMapper.getComment(dbComment));
                      treatedArtifacts.add(artifactDep.getGavc());
                  }
  
                  // Checks if the module has third party dependency license missing
                  // filter the corporate dependencies and check the third party
                  List<String> artifactLicenses = artifactDep.getLicenses();
                  if (!filters.getCorporateFilter().filter(dependency)) {
                      if (artifactLicenses.isEmpty()) {
                          if(LOG.isWarnEnabled()) {
                              LOG.warn(String.format("Missing license on artifact [%s]", artifactDep.getGavc()));
                          }
                          report.addMissingThirdPartyDependencyLicenses(modelMapper.getArtifact(artifactDep));
                      } else {
                          // Check if the existing license name exists in the database
                          for (String licenseName : artifactLicenses) {
                              if (null == licenseName) {
                                  continue;
                              }
                              // DbLicense currentLicense = repositoryHandler.getLicense(licenseName);
                              final Set<DbLicense> matchingLicenses = licenseMatcher.getMatchingLicenses(licenseName);
                              if (matchingLicenses.isEmpty()) {
                                  if(LOG.isWarnEnabled()) {
                                      LOG.warn(String.format("Artifact license string [%s] unknown to Grapes", licenseName));
                                  }
                                  report.addMissingThirdPartyDependencyLicenses(modelMapper.getArtifact(artifactDep));
                              } else {
                                  matchingLicenses.forEach(lic -> {
                                      //
                                      // Check if the third party license is approved. If approved == null it is still valid license
                                      // add to a not approved list
                                      //
                                      if (lic.isApproved() != null && !lic.isApproved()) {
                                          report.addUnacceptedLicenseEntry(modelMapper.getArtifact(artifactDep).getGavc(), lic.getName());
  
                                          if (LOG.isWarnEnabled()) {
                                              LOG.warn(String.format("License [%s] is used by [%s], but is not accepted ", lic.getName(), artifactDep.getGavc()));
                                          }
                                      }
                                  });
                              }
                          }
                      }
                  }
              }
  //      }
  
          report.compute();
          if (LOG.isDebugEnabled()) {
              LOG.debug(String.format(":: Done promo report %s", moduleId));
          }
  
          cache.put(moduleId, report);
          return report;
      }