How to use

getQualifiedPath

method

in

org.datacleaner.repository.RepositoryFile

/**
 * Constructs a {@link RepositoryFileResource} based on a
 * {@link RepositoryFile}.
 *
 * @param file
 */
public RepositoryFileResource(final RepositoryFile file) {
  _fileRef = new SerializableRef<>(file);
  _qualifiedPath = file.getQualifiedPath();
}

  @Override
  public ExecutionIdentifier eval(final RepositoryFile file) {
    try {
      final ExecutionIdentifier result = file.readFile(
          new Func<InputStream, ExecutionIdentifier>() {
            @Override
            public ExecutionIdentifier eval(InputStream in) {
              return SaxExecutionIdentifierReader.read(in, file.getQualifiedPath());
            }
          });
      return result;
    } catch (Exception e) {
      logger.warn("The file " + file.getQualifiedPath()
          + " could not be read or parsed correctly " + e);
      return new ExecutionIdentifier("Execution failed for " + FilenameUtils.getBaseName(file
          .getQualifiedPath()));
    }
  }
});

private void addTimelines(List<TimelineIdentifier> result, DashboardGroup group, RepositoryFolder repositoryFolder) {
  final String extension = FileFilters.ANALYSIS_TIMELINE_XML.getExtension();
  final List<RepositoryFile> files = repositoryFolder.getFiles(null, extension);
  for (RepositoryFile file : files) {
    final String timelineName = file.getName().substring(0, file.getName().length() - extension.length());
    final TimelineIdentifier timelineIdentifier = new TimelineIdentifier(timelineName, file.getQualifiedPath(),
        group);
    result.add(timelineIdentifier);
  }
}

@RequestMapping(method = RequestMethod.GET, produces = MediaType.APPLICATION_JSON_VALUE)
@ResponseBody
public List<Map<String, String>> resultsFolderJson(@PathVariable("tenant") String tenant) {
  final TenantContext context = _contextFactory.getContext(tenant);
  final List<Map<String, String>> result = new ArrayList<>();
  {
    final List<JobIdentifier> jobs = context.getJobs();
    for (JobIdentifier job : jobs) {
      final JobContext jobContext = context.getJob(job);
      final RepositoryFile file = jobContext.getJobFile();
      final Map<String, String> map = new HashMap<>();
      map.put("name", job.getName());
      map.put("filename", file.getName());
      map.put("repository_path", file.getQualifiedPath());
      result.add(map);
    }
  }
  return result;
}

  @RolesAllowed(SecurityRoles.VIEWER)
  @RequestMapping(method = RequestMethod.GET, produces = "application/json")
  @ResponseBody
  public List<Map<String, String>> resultsFolderJson(@PathVariable("tenant") String tenant) {
    final TenantContext context = _tenantContextFactory.getContext(tenant);

    final RepositoryFolder resultsFolder = context.getResultFolder();

    final List<Map<String, String>> result = new ArrayList<Map<String, String>>();

    {
      final List<RepositoryFile> files = resultsFolder.getFiles(null,
          FileFilters.ANALYSIS_RESULT_SER.getExtension());
      for (RepositoryFile file : files) {
        Map<String, String> map = new HashMap<String, String>();
        map.put("filename", file.getName());
        map.put("repository_path", file.getQualifiedPath());
        result.add(map);
      }
    }

    return result;
  }
}

result.put("file_type", resultFile.getType().toString());
result.put("filename", resultFile.getName());
result.put("repository_path", resultFile.getQualifiedPath());

@RolesAllowed(SecurityRoles.JOB_EDITOR)
@RequestMapping(method = RequestMethod.POST, produces = MediaType.APPLICATION_JSON_VALUE, consumes = MediaType.MULTIPART_FORM_DATA_VALUE)
@ResponseBody
public Map<String, String> uploadAnalysisJobToFolderJson(@PathVariable("tenant") final String tenant,
    @RequestParam("file") final MultipartFile file) {
  if (file == null) {
    throw new IllegalArgumentException(
        "No file upload provided. Please provide a multipart file using the 'file' HTTP parameter.");
  }
  final Action<OutputStream> writeCallback = out -> {
    final InputStream in = file.getInputStream();
    try {
      FileHelper.copy(in, out);
    } finally {
      FileHelper.safeClose(in);
    }
  };
  final TenantContext context = _contextFactory.getContext(tenant);
  final RepositoryFile jobFile;
  final RepositoryFolder jobsFolder = context.getJobFolder();
  final String filename = file.getOriginalFilename();
  jobFile = jobsFolder.createFile(filename, writeCallback);
  logger.info("Created new job from uploaded file: {}", filename);
  final Map<String, String> result = new HashMap<>();
  result.put("status", STATUS_SUCCESS);
  result.put("file_type", jobFile.getType().toString());
  result.put("filename", jobFile.getName());
  result.put("repository_path", jobFile.getQualifiedPath());
  return result;
}

result.put("file_type", configurationFile.getType().toString());
result.put("filename", configurationFile.getName());
result.put("repository_path", configurationFile.getQualifiedPath());

result.put("file_type", jobFile.getType().toString());
result.put("filename", jobFile.getName());
result.put("repository_path", jobFile.getQualifiedPath());

jobDetails.put("name", job.getName());
jobDetails.put("filename", file.getName());
jobDetails.put("repository_path", file.getQualifiedPath());
jobDetails.put("metadataProperties", jobMetadataProperties);
final List<Map<String, Object>> descriptors = new ArrayList<>();

@Override
public List<TimelineIdentifier> getTimelines(final TenantIdentifier tenant, final DashboardGroup group) {
  final RepositoryFolder timelinesFolder = _tenantContextFactory.getContext(tenant).getTimelineFolder();
  final List<RepositoryFile> files;
  final String groupName = (group == null ? null : group.getName());
  if (group == null || groupName == null || "".equals(groupName)) {
    files = timelinesFolder.getFiles();
  } else {
    RepositoryFolder groupFolder = timelinesFolder.getFolder(groupName);
    files = groupFolder.getFiles();
  }
  final List<TimelineIdentifier> result = new ArrayList<TimelineIdentifier>();
  for (RepositoryFile file : files) {
    if (file.getType() == Type.TIMELINE_SPEC) {
      String timelineName = file.getName().substring(0,
          file.getName().length() - FileFilters.ANALYSIS_TIMELINE_XML.getExtension().length());
      TimelineIdentifier timeline = new TimelineIdentifier(timelineName, file.getQualifiedPath(), group);
      result.add(timeline);
    }
  }
  return result;
}

@Override
public TimelineIdentifier updateTimeline(TimelineIdentifier identifier, TimelineDefinition definition) {
  final RepositoryFile file = (RepositoryFile) _repository.getRepositoryNode(identifier.getPath());
  file.writeFile(new WriteTimelineAction(definition));
  logger.info("Updated timeline definition in file: {}", file);
  return new TimelineIdentifier(identifier.getName(), file.getQualifiedPath(), identifier.getGroup());
}

protected static List<TimelineDataRow> getTimelineData(TenantIdentifier tenant, TimelineDefinition timeline,
    Iterable<RepositoryFile> resultFiles, MetricValueProducer metricValueProducer) {
  final List<MetricIdentifier> metricIdentifiers = timeline.getMetrics();
  final JobIdentifier jobIdentifier = timeline.getJobIdentifier();
  final HorizontalAxisOption horizontalAxisOption = timeline.getChartOptions().getHorizontalAxisOption();
  final List<TimelineDataRow> rows = new ArrayList<TimelineDataRow>();
  for (RepositoryFile resultFile : resultFiles) {
    final MetricValues metricValues;
    try {
      metricValues = metricValueProducer
          .getMetricValues(metricIdentifiers, resultFile, tenant, jobIdentifier);
    } catch (Exception e) {
      logger.warn("Failed to read result metrics of file: {}", resultFile, e);
      continue;
    }
    final Date date = metricValues.getMetricDate();
    if (isInRange(date, horizontalAxisOption)) {
      final TimelineDataRow row = new TimelineDataRow(date, resultFile.getQualifiedPath());
      final List<Number> metricValuesList = metricValues.getValues();
      row.setMetricValues(metricValuesList);
      rows.add(row);
    }
  }
  // sort rows to ensure correct date order
  Collections.sort(rows);
  return rows;
}

@Override
public TimelineIdentifier createTimelineDefinition(final TenantIdentifier tenant,
    final TimelineIdentifier timelineIdentifier, final TimelineDefinition timelineDefinition) {
  final String name = timelineIdentifier.getName();
  final DashboardGroup group = timelineIdentifier.getGroup();
  final RepositoryFolder timelinesFolder = _tenantContextFactory.getContext(tenant).getTimelineFolder();
  final RepositoryFolder folder;
  if (group == null) {
    folder = timelinesFolder;
  } else {
    folder = timelinesFolder.getFolder(group.getName());
  }
  final String fileName = name + FileFilters.ANALYSIS_TIMELINE_XML.getExtension();
  final RepositoryFile file = folder.createFile(fileName, new WriteTimelineAction(timelineDefinition));
  logger.info("Created timeline definition in file: {}", file);
  return new TimelineIdentifier(timelineIdentifier.getName(), file.getQualifiedPath(), group);
}