public void validateDoMapping(
final JiraServiceContext jiraServiceContext,
final ProjectImportOptions projectImportOptions,
final BackupProject backupProject,
final BackupSystemInformation backupSystemInformation) {
Null.not("projectImportOptions", projectImportOptions);
Null.not("backupSystemInformation", backupSystemInformation);
validateJiraServiceContext(jiraServiceContext);
final ErrorCollection errorCollection = jiraServiceContext.getErrorCollection();
final I18nHelper i18n = jiraServiceContext.getI18nBean();
// The user must have the system administrator permission to perform a project import
if (!userHasSysAdminPermission(jiraServiceContext.getUser())) {
errorCollection.addErrorMessage(getText(i18n, "admin.errors.project.import.must.be.admin"));
}
// Check the pathToBackupXml is valid
if (StringUtils.isEmpty(projectImportOptions.getPathToBackupXml())) {
errorCollection.addErrorMessage(
getText(i18n, "admin.errors.project.import.provide.backup.path"));
} else if (!pathExists(projectImportOptions.getPathToBackupXml(), true)) {
errorCollection.addErrorMessage(
getText(i18n, "admin.errors.project.import.invalid.backup.path"));
}
// Check that we are being provided a backup project
if (backupProject == null) {
errorCollection.addErrorMessage(
getText(i18n, "admin.errors.project.import.no.backup.project"));
}
}
private MappingResult validateAndAutoMapFields(
final JiraServiceContext jiraServiceContext,
final ProjectImportOptions projectImportOptions,
final ProjectImportData projectImportData,
final BackupProject backupProject,
final BackupSystemInformation backupSystemInformation,
final TaskProgressInterval taskProgressInterval) {
log.info(
"Project Import: Mapping the backed up data to data in the current system, and validating the mappings...");
final MappingResult mappingResult = buildMappingResult();
final I18nHelper i18n = jiraServiceContext.getI18nBean();
// Step 2 Map and validate the Issue Types
projectImportManager.autoMapAndValidateIssueTypes(
projectImportData, mappingResult, backupProject, jiraServiceContext.getI18nBean());
// If there is a problem processing the issue types then we don't want to do any further
// mappings or validation
if ((mappingResult.getIssueTypeMessageSet() != null)
&& !mappingResult.getIssueTypeMessageSet().hasAnyErrors()) {
// Try to map the custom fields
projectImportManager.autoMapAndValidateCustomFields(
projectImportData, mappingResult, backupProject, i18n);
if (!mappingResult.getCustomFieldMessageSet().hasAnyErrors()) {
// Only map the system fields if we can move forward with the custom fields
projectImportManager.autoMapSystemFields(projectImportData, backupProject);
// Only map the project roles if we can move forward with the custom fields
projectImportManager.autoMapProjectRoles(projectImportData);
// Only map the custom field values once we know that the custom fields are good
projectImportManager.autoMapCustomFieldOptions(projectImportData, backupProject);
final boolean importAttachments =
!StringUtils.isEmpty(projectImportOptions.getAttachmentPath());
final int customFieldValuePercentage = (importAttachments) ? 60 : 90;
// if we can successfully map the custom fields then lets validate the custom field values
try {
// Create a TaskProgressProcessor for validateCustomFieldValues
final TaskProgressInterval subInterval =
getSubInterval(taskProgressInterval, 0, customFieldValuePercentage);
EntityCountTaskProgressProcessor taskProgressProcessor = null;
if (taskProgressInterval != null) {
taskProgressProcessor =
new EntityCountTaskProgressProcessor(
subInterval,
i18n.getText(
"admin.message.project.import.manager.do.mapping.validate.custom.field.values"),
projectImportData.getCustomFieldValuesEntityCount(),
i18n);
}
projectImportManager.validateCustomFieldValues(
projectImportData, mappingResult, backupProject, taskProgressProcessor, i18n);
} catch (final IOException e) {
log.error(
"There was a problem accessing the file '"
+ projectImportData.getPathToCustomFieldValuesXml()
+ "' when performing a project import.",
e);
jiraServiceContext
.getErrorCollection()
.addErrorMessage(
getText(
i18n,
"admin.errors.project.import.problem.reading.custom.field.xml",
projectImportData.getPathToCustomFieldValuesXml()));
return null;
} catch (final SAXException e) {
log.error(
"There was a problem accessing the file '"
+ projectImportData.getPathToCustomFieldValuesXml()
+ "' when performing a project import.",
e);
jiraServiceContext
.getErrorCollection()
.addErrorMessage(
getText(
i18n,
"admin.errors.project.import.custom.field.sax.problem",
projectImportData.getPathToCustomFieldValuesXml(),
e.getMessage()));
return null;
}
// Only validate the system field mappings after we have done all the rest
// Create a sub interval of the taskProgressInterval we were given.
TaskProgressInterval sysFieldSubInterval = null;
if (taskProgressInterval != null) {
sysFieldSubInterval =
taskProgressInterval.getSubInterval(
customFieldValuePercentage, customFieldValuePercentage + 10);
}
projectImportManager.validateSystemFields(
projectImportData,
mappingResult,
projectImportOptions,
backupProject,
sysFieldSubInterval,
i18n);
// Validate the attachments if we are importing attachments
if (!importAttachments) {
final MessageSet messageSet = new MessageSetImpl();
messageSet.addWarningMessage(
getText(i18n, "admin.warning.project.import.mapping.no.backup.atttachment.path"));
log.warn(
"File attachments will not be imported because you have not provided a backup attachment path.");
mappingResult.setFileAttachmentMessageSet(messageSet);
} else {
try {
// Create a TaskProgressProcessor for validateFileAttachments
final TaskProgressInterval attachmentSubInterval =
getSubInterval(taskProgressInterval, 70, 100);
EntityCountTaskProgressProcessor taskProgressProcessor = null;
if (taskProgressInterval != null) {
taskProgressProcessor =
new EntityCountTaskProgressProcessor(
attachmentSubInterval,
i18n.getText(
"admin.message.project.import.manager.do.mapping.validate.file.attachment.values"),
projectImportData.getFileAttachmentEntityCount(),
i18n);
}
projectImportManager.validateFileAttachments(
projectImportOptions,
projectImportData,
mappingResult,
backupProject,
backupSystemInformation,
taskProgressProcessor,
i18n);
} catch (final IOException e) {
log.error(
"There was a problem accessing the file '"
+ projectImportData.getPathToFileAttachmentXml()
+ "' when performing a project import.",
e);
jiraServiceContext
.getErrorCollection()
.addErrorMessage(
getText(
i18n,
"admin.errors.project.import.problem.reading.attachment.xml",
projectImportData.getPathToFileAttachmentXml()));
return null;
} catch (final SAXException e) {
log.error(
"There was a problem accessing the file '"
+ projectImportData.getPathToFileAttachmentXml()
+ "' when performing a project import.",
e);
jiraServiceContext
.getErrorCollection()
.addErrorMessage(
getText(
i18n,
"admin.errors.project.import.custom.field.sax.problem",
projectImportData.getPathToFileAttachmentXml(),
e.getMessage()));
return null;
}
}
} else {
// When the required custom fields have not passed validation we still want to show that
// validation has
// not happened for each of the custom field values.
addCustomFieldValuesNotCheckedMessageSets(projectImportData, mappingResult);
}
} else {
// When the required issue types have not passed validation we still want to show that
// validation has
// not happened for each of the custom field values.
addCustomFieldValuesNotCheckedMessageSets(projectImportData, mappingResult);
}
// We want to populate the message list of the results. This puts the message results into order
// and gives
// them i18n header labels
createValidationMessageList(mappingResult, projectImportData, i18n);
if (mappingResult.canImport()) {
log.info("Project Import: No validation errors were found and the import can continue.");
} else {
log.info("Project Import: Validation errors were found. The import cannot continue.");
}
return mappingResult;
}
public ProjectImportData getProjectImportData(
final JiraServiceContext jiraServiceContext,
final ProjectImportOptions projectImportOptions,
final BackupProject backupProject,
final BackupSystemInformation backupSystemInformation,
final TaskProgressInterval taskProgressInterval) {
Null.not("backupProject", backupProject);
Null.not("projectImportOptions", projectImportOptions);
Null.not("backupSystemInformation", backupSystemInformation);
validateJiraServiceContext(jiraServiceContext);
// The user must have the system administrator permission to perform a project import
if (!userHasSysAdminPermission(jiraServiceContext.getUser())) {
jiraServiceContext
.getErrorCollection()
.addErrorMessage(
getText(
jiraServiceContext.getI18nBean(), "admin.errors.project.import.must.be.admin"));
return null;
}
final ErrorCollection errorCollection = jiraServiceContext.getErrorCollection();
final I18nHelper i18n = jiraServiceContext.getI18nBean();
final ProjectImportData projectImportData;
try {
// First step is to go through the import file again, populating our mappers and creating
// partitioned XML files.
// Create the Task Progress Processor for this subtask.
EntityCountTaskProgressProcessor taskProgressProcessor = null;
if (taskProgressInterval != null) {
taskProgressProcessor =
new EntityCountTaskProgressProcessor(
taskProgressInterval,
i18n.getText(
"admin.message.project.import.manager.do.mapping.extracting.project.data"),
backupSystemInformation.getEntityCount(),
i18n);
}
projectImportData =
projectImportManager.getProjectImportData(
projectImportOptions, backupProject, backupSystemInformation, taskProgressProcessor);
} catch (final IOException e) {
log.error(
"There was a problem accessing the file '"
+ projectImportOptions.getPathToBackupXml()
+ "' when performing a project import.",
e);
errorCollection.addErrorMessage(
getText(
i18n,
"admin.errors.project.import.problem.reading.backup",
projectImportOptions.getPathToBackupXml()));
return null;
} catch (final SAXException e) {
log.error(
"There was a problem with the SAX parsing of the file '"
+ projectImportOptions.getPathToBackupXml()
+ "' when performing a project import.");
errorCollection.addErrorMessage(
getText(
i18n,
"admin.errors.project.import.sax.problem",
projectImportOptions.getPathToBackupXml(),
e.getMessage()));
return null;
}
return projectImportData;
}
public BackupOverview getBackupOverview(
final JiraServiceContext jiraServiceContext,
final ProjectImportOptions projectImportOptions,
final TaskProgressSink taskProgressSink) {
Null.not("projectImportOptions", projectImportOptions);
validateJiraServiceContext(jiraServiceContext);
final ErrorCollection errorCollection = jiraServiceContext.getErrorCollection();
final I18nHelper i18n = jiraServiceContext.getI18nBean();
// The user must have the system administrator permission to perform a project import
if (!userHasSysAdminPermission(jiraServiceContext.getUser())) {
errorCollection.addErrorMessage(getText(i18n, "admin.errors.project.import.must.be.admin"));
return null;
}
try {
final String backupPath = projectImportOptions.getPathToBackupXml();
log.info(
"Project Import: Parsing the backup file '"
+ backupPath
+ "' to obtain a Backup Overview.");
final BackupOverview backupOverview =
projectImportManager.getBackupOverview(backupPath, taskProgressSink, i18n);
log.debug("Project count for backup file = " + backupOverview.getProjects().size());
log.debug(
"Entity count for backup file = "
+ backupOverview.getBackupSystemInformation().getEntityCount());
// Now do some further validation
// BuildNumbers must be exactly the same.
if (!getBuildNumber()
.equalsIgnoreCase(backupOverview.getBackupSystemInformation().getBuildNumber())) {
final String errorMessage =
getText(
i18n,
"admin.errors.project.import.wrong.build.number",
getBuildNumber(),
backupOverview.getBackupSystemInformation().getBuildNumber());
errorCollection.addErrorMessage(errorMessage);
log.error(
"This data appears to be from an older version of JIRA. Please upgrade the data and try again. The current version of JIRA is at build number '"
+ getBuildNumber()
+ "', but the supplied backup file was for build number '"
+ backupOverview.getBackupSystemInformation().getBuildNumber()
+ "'.");
}
// Only return the backupOverview if we do not have any errors, otherwise we want to fall
// through and return null
if (!errorCollection.hasAnyErrors()) {
log.info(
"Project Import: Backup Overview was successfully extracted from '"
+ backupPath
+ "'.");
return backupOverview;
}
} catch (final IOException e) {
log.error(
"There was a problem accessing the file '"
+ projectImportOptions.getPathToBackupXml()
+ "' when performing a project import.",
e);
errorCollection.addErrorMessage(
getText(
i18n,
"admin.errors.project.import.problem.reading.backup",
projectImportOptions.getPathToBackupXml()));
} catch (final SAXException e) {
log.error(
"There was a problem with the SAX parsing of the file '"
+ projectImportOptions.getPathToBackupXml()
+ "' when performing a project import.");
errorCollection.addErrorMessage(
getText(
i18n,
"admin.errors.project.import.sax.problem",
projectImportOptions.getPathToBackupXml(),
e.getMessage()));
}
return null;
}
public void validateGetBackupOverview(
final JiraServiceContext jiraServiceContext,
final ProjectImportOptions projectImportOptions) {
Null.not("projectImportOptions", projectImportOptions);
validateJiraServiceContext(jiraServiceContext);
final ErrorCollection errorCollection = jiraServiceContext.getErrorCollection();
final I18nHelper i18n = jiraServiceContext.getI18nBean();
// The user must have the system administrator permission to perform a project import
if (!userHasSysAdminPermission(jiraServiceContext.getUser())) {
errorCollection.addErrorMessage(getText(i18n, "admin.errors.project.import.must.be.admin"));
// Don't care to check any more validity
return;
}
if (StringUtils.isEmpty(projectImportOptions.getPathToBackupXml())) {
errorCollection.addError(
"backupXmlPath", getText(i18n, "admin.errors.project.import.provide.backup.path"));
} else if (!pathExists(projectImportOptions.getPathToBackupXml(), true)) {
errorCollection.addError(
"backupXmlPath", getText(i18n, "admin.errors.project.import.invalid.backup.path"));
}
// Check if the user has supplied an attachment path
if (!StringUtils.isEmpty(projectImportOptions.getAttachmentPath())) {
// Check that attachments are enabled for the current JIRA
if (!attachmentManager.attachmentsEnabled()) {
errorCollection.addError(
"backupAttachmentPath",
getText(i18n, "admin.errors.project.import.attachments.not.enabled"));
}
// Now check if the path exists
else if (pathExists(projectImportOptions.getAttachmentPath(), false)) {
// Path Exists, but it is not allowed to be the current system's Attachment Path.
// Get the configured attachment path for this JIRA instance.
final String attachmentPathString = attachmentPathManager.getAttachmentPath();
// Create a File object with it.
final File attachmentPathFile = new File(attachmentPathString);
// Create a File object with the attachment path
final File backupAttachmentPathFile = new File(projectImportOptions.getAttachmentPath());
// Compare the canonical paths to see if the directories are the same.
try {
if (attachmentPathFile
.getCanonicalPath()
.equals(backupAttachmentPathFile.getCanonicalPath())) {
errorCollection.addError(
"backupAttachmentPath",
getText(i18n, "admin.errors.project.import.attachment.backup.path.same.as.system"));
}
} catch (final IOException e) {
// This would be rather strange, but see the javadoc for getCanonicalFile():
// "If an I/O error occurs, which is possible because the construction of the canonical
// pathname may require filesystem queries"
errorCollection.addErrorMessage(
getText(i18n, "admin.errors.project.import.attachment.ioexception", e.getMessage()));
}
} else {
// Path doesn't exist
errorCollection.addError(
"backupAttachmentPath",
getText(i18n, "admin.errors.project.import.invalid.attachment.backup.path"));
}
}
}
