How to use

getName

method

in

org.datacleaner.repository.RepositoryFile

@Override
public String getName() {
  final int extensionLength = CustomJobEngine.EXTENSION.length();
  final String filename = _file.getName();
  return filename.substring(0, filename.length() - extensionLength);
}

  @Override
  public Boolean eval(RepositoryFile file) {
    // check that the remainding part of the file is ONLY a
    // timestamp - or else it might be a name conflict
    // between similarly named jobs.
    String timestampPart = file.getName();
    timestampPart = timestampPart.substring(prefix.length());
    timestampPart = timestampPart.substring(0, timestampPart.length() - extension.length());
    try {
      Long.parseLong(timestampPart);
      return true;
    } catch (NumberFormatException e) {
      return false;
    }
  }
});

@Override
public JobContext getJob() {
  final String resultFilename = _repositoryFile.getName();
  // we assume a filename pattern like this:
  // {job}-{timestamp}.analysis.result.dat
  final int lastIndexOfDash = resultFilename.lastIndexOf('-');
  assert lastIndexOfDash != -1;
  final String jobName = resultFilename.substring(0, lastIndexOfDash);
  return _tenantContext.getJob(jobName);
}

@Override
public String getName() {
  final int extensionLength = FileFilters.ANALYSIS_XML.getExtension().length();
  final String filename = _file.getName();
  return filename.substring(0, filename.length() - extensionLength);
}

@Override
public String getName() {
  return getRepositoryFile().getName();
}

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);
  }
}

@Override
public ResultContext getResult(TenantIdentifier tenant, RepositoryFile resultFile) {
  if (resultFile == null) {
    return null;
  }
  TenantContext context = _tenantContextFactory.getContext(tenant);
  return context.getResult(resultFile.getName());
}

logger.info("File: " + path + file.getName());
zipOutput.putNextEntry(new ZipEntry(path + file.getName()));
file.readFile(new Action<InputStream>() {
  @Override

@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("status", "Success");
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("status", "Success");
result.put("file_type", configurationFile.getType().toString());
result.put("filename", configurationFile.getName());
result.put("repository_path", configurationFile.getQualifiedPath());

final String extension = existingFile.getName().substring(jobName.length());
response.put("source_job", sourceJob.getName());
response.put("target_job", newJob.getName());
response.put("repository_url", "/" + tenant + "/jobs/" + newJobFile.getName());
logger.debug("Response payload: {}", response);

} else {
  jobFile = existingJob.getJobFile();
  logger.info("Overwriting job from uploaded file: {}", jobFile.getName());
  jobFile.writeFile(writeCallback);
result.put("status", "Success");
result.put("file_type", jobFile.getType().toString());
result.put("filename", jobFile.getName());
result.put("repository_path", jobFile.getQualifiedPath());

@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;
}

final ResultContext resultContext = context.getResult(resultFile.getName());
final AnalysisResult analysisResult;
try {
  logger.error("Failed to read AnalysisResult in file: " + resultFile, e);
  response.sendError(HttpServletResponse.SC_INTERNAL_SERVER_ERROR, "Failed to read result file: "
      + resultFile.getName() + ". See server logs for details.");
  return;

final String oldFilename = existingFile.getName();
response.put("old_result_name", oldFilename);
final String newFilename = newResult.getResultFile().getName();

  @Override
  public MetricValues getMetricValues(List<MetricIdentifier> metricIdentifiers, RepositoryFile resultFile,
      TenantIdentifier tenant, JobIdentifier jobIdentifier) {
    final TenantContext tenantContext = _tenantContextFactory.getContext(tenant);
    final String resultFilename = resultFile.getName();
    final ResultContext resultContext = tenantContext.getResult(resultFilename);

    final String jobName = jobIdentifier.getName();
    final MetricJobContext job = (MetricJobContext) tenantContext.getJob(jobName);
    final MetricJobEngine<? extends MetricJobContext> jobEngine;
    if (job == null) {
      logger.warn("Job {} does not exist. Cannot resolve job engine, so defaulting to DataCleanerJobEngine.",
          jobName);
      jobEngine = _jobEngineManager.getJobEngineOfType(DataCleanerJobEngine.class);
    } else {
      jobEngine = job.getJobEngine();
    }
    return jobEngine.getMetricValues(job, resultContext, metricIdentifiers);
  }
}

@Override
public ResultContext getLatestResult(TenantIdentifier tenantIdentifier, JobIdentifier job) {
  final TenantContext context = _tenantContextFactory.getContext(tenantIdentifier.getId());
  final RepositoryFolder resultsFolder = context.getResultFolder();
  final String jobName = job.getName();
  final RepositoryFile resultFile = resultsFolder.getLatestFile(jobName,
      FileFilters.ANALYSIS_RESULT_SER.getExtension());
  if (resultFile == null) {
    return null;
  }
  return context.getResult(resultFile.getName());
}