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")); } }
public void doValidation( String key, Map<String, String> parameters, JiraServiceContext jiraServiceContext) { // JRA-13808: Need to check whether or not the user CF has a searcher set. String customFieldOption = parameters.get(getType()); if (StringUtils.isEmpty(customFieldOption)) { String localisedMessage = jiraServiceContext .getI18nBean() .getText("admin.permissions.errors.please.select.user.customfield"); jiraServiceContext.getErrorCollection().addErrorMessage(localisedMessage); } else { // passed in parameters names a Custom Field - lets investigate. CustomField customField = customFieldManager.getCustomFieldObject(customFieldOption); if (customField != null && customField.getCustomFieldSearcher() == null) { // In order to use a Custom Field it must be indexed in Lucene Index. Currently we only // index custom fields if they have a Searcher. // Message: "Custom field '{0}' is not indexed for searching - please add a searcher to this // Custom Field." String localisedMessage = jiraServiceContext .getI18nBean() .getText("admin.permissions.errors.customfieldnotindexed", customField.getName()); jiraServiceContext.getErrorCollection().addErrorMessage(localisedMessage); } } }
@Override public WhitelistUpdateValidationResult validateUpdateRules( final JiraServiceContext context, final List<String> rules, final boolean disabled) { notNull("context", context); notNull("rules", rules); if (checkInvalidPermissions(context)) { return new WhitelistUpdateValidationResult(context.getErrorCollection()); } for (String rule : rules) { if (rule.startsWith(REGEX_PREFIX)) { try { Pattern.compile(rule.substring(REGEX_PREFIX.length())); } catch (PatternSyntaxException e) { final I18nHelper i18n = beanFactory.getInstance(context.getLoggedInUser()); context .getErrorCollection() .addErrorMessage(i18n.getText("whitelist.admin.errors.bad.pattern", e.getMessage())); } } } return new WhitelistUpdateValidationResult(context.getErrorCollection(), rules, disabled); }
@Override public WhitelistResult getRules(final JiraServiceContext context) { notNull("context", context); if (checkInvalidPermissions(context)) { return new WhitelistResult(context.getErrorCollection()); } return new WhitelistResult(context.getErrorCollection(), whitelistManager.getRules()); }
boolean checkInvalidPermissions(final JiraServiceContext context) { if (!permissionManager.hasPermission(Permissions.SYSTEM_ADMIN, context.getLoggedInUser())) { final I18nHelper i18n = beanFactory.getInstance(context.getLoggedInUser()); context .getErrorCollection() .addErrorMessage(i18n.getText("whitelist.service.permission.error")); return true; } return false; }
private void showPopularTab() { final JiraServiceContext serviceContext = getJiraServiceContext(); final Collection<PortalPage> portalPages = getPortalPageViewHelper().getPopularFilters(serviceContext); if (!serviceContext.getErrorCollection().hasAnyErrors()) { pages = transformToDisplayBeans(portalPages); } view = Tab.POPULAR; }
public MessageSet validateBackupProjectImportableSystemLevel( final JiraServiceContext jiraServiceContext, final BackupProject backupProject, final BackupSystemInformation backupSystemInformation) { validateJiraServiceContext(jiraServiceContext); // No need to check if backupProject has null members, we will never create backup project like // that. Null.not("backupSystemInformation", backupSystemInformation); final MessageSet messageSet = new MessageSetImpl(); final I18nHelper i18n = jiraServiceContext.getI18nBean(); // Need to provide a backupProject if (backupProject == null) { messageSet.addErrorMessage(getText(i18n, "admin.error.project.import.null.project")); jiraServiceContext .getErrorCollection() .addErrorMessage(getText(i18n, "admin.error.project.import.null.project")); return messageSet; } // The user must have the system administrator permission to perform a project import if (!userHasSysAdminPermission(jiraServiceContext.getUser())) { messageSet.addErrorMessage(getText(i18n, "admin.errors.project.import.must.be.admin")); } else { // Verify that if the backup projects custom field plugins exist that they are of the right // version in this JIRA instance // NOTE: warnings, such as the plugin not existing or the custom field being not importable or // out of context // are not checked here, that is handled by the next phase of the import. validateCustomFieldPluginVersions( backupProject, backupSystemInformation.getPluginVersions(), messageSet, i18n); final String projectKey = backupProject.getProject().getKey(); final Project existingProject = projectManager.getProjectObjByKey(projectKey); if (existingProject == null) { // It does not really make sense to warn that we will create a project for them if there are // already errors. if (!messageSet.hasAnyErrors()) { messageSet.addWarningMessage( getText(i18n, "admin.warning.project.import.no.existing.project", projectKey)); } } else { // We need to make sure that the project does not contain issues, versions, components, // etc... validateExistingProjectHasValidStateForImport( backupProject, backupSystemInformation, existingProject, i18n, messageSet); } } // Copy the errors into the service context error collection jiraServiceContext.getErrorCollection().addErrorMessages(messageSet.getErrorMessages()); return messageSet; }
public MappingResult doMapping( final JiraServiceContext jiraServiceContext, final ProjectImportOptions projectImportOptions, final ProjectImportData projectImportData, final BackupProject backupProject, final BackupSystemInformation backupSystemInformation, final TaskProgressInterval taskProgressInterval) { Null.not("backupProject", backupProject); Null.not("projectImportOptions", projectImportOptions); Null.not("backupSystemInformation", backupSystemInformation); Null.not("projectImportData", projectImportData); 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; } // Now that we have the initial mapper we need to auto map all the fields and their values and // validate that our // mappings are correct. final MappingResult mappingResult = validateAndAutoMapFields( jiraServiceContext, projectImportOptions, projectImportData, backupProject, backupSystemInformation, taskProgressInterval); if ((mappingResult != null) && !mappingResult.canImport()) { jiraServiceContext .getErrorCollection() .addErrorMessage( jiraServiceContext .getI18nBean() .getText("admin.errors.project.import.mapping.error")); } // We have log messages in the mapping Result that we didn't write to the log straight away as // you could get ltos of repeat messages. We log these now. writeLogMessages(mappingResult); return mappingResult; }
protected boolean validateSearchParameters( final JiraServiceContext ctx, final SharedEntitySearchParameters searchParameters, final int pageOffset, final int pageWidth) { portalPageService.validateForSearch(ctx, searchParameters); return !ctx.getErrorCollection().hasAnyErrors(); }
private void showSearchTab() { // if they have pressed the 'Search' button then boolean searchPerformed = isSearchRequested(); if (searchPerformed) { final JiraServiceContext ctx = getJiraServiceContext(); searchResults = getPortalPageViewHelper().search(ctx); if (ctx.getErrorCollection().hasAnyErrors()) { searchPerformed = false; } else { pages = transformToDisplayBeans(searchResults.getResults()); } } if (!searchPerformed) { searchEmptyMessageKey = KEY_NO_SEARCH; } view = Tab.SEARCH; }
/** * @see UserPickerSearchService#canShowEmailAddresses(com.atlassian.jira.bc.JiraServiceContext) */ @Override public boolean canShowEmailAddresses(final JiraServiceContext jiraServiceContext) { if (canPerformAjaxSearch(jiraServiceContext)) { final String emailVisibility = applicationProperties.getDefaultBackedString(APKeys.JIRA_OPTION_EMAIL_VISIBLE); if (VISIBILITY_PUBLIC.equals(emailVisibility) || (VISIBILITY_MASKED.equals(emailVisibility)) || (VISIBILITY_USER.equals(emailVisibility) && (jiraServiceContext.getLoggedInUser() != null))) { return true; } } return false; }
@Override public List<User> findUsersAllowEmptyQuery( final JiraServiceContext jiraServiceContext, final String query) { // is it allowed? How did they get here anyway?? if (!canPerformAjaxSearch(jiraServiceContext)) { return Collections.emptyList(); } StopWatch stopWatch = new StopWatch(); final String convertedQuery = (query == null) ? "" : query.toLowerCase().trim(); if (log.isDebugEnabled()) log.debug("Running user-picker search: '" + convertedQuery + "'"); List<User> returnUsers = new ArrayList<User>(); final boolean canShowEmailAddresses = canShowEmailAddresses(jiraServiceContext); final Collection<User> allUsers = userManager.getUsers(); if (log.isDebugEnabled()) log.debug("Found all " + allUsers.size() + " users in " + stopWatch.getIntervalTime() + "ms"); final Predicate<User> userMatcher = new UserMatcherPredicate(convertedQuery, canShowEmailAddresses); for (final User user : allUsers) { if (user.isActive() && userMatcher.apply(user)) { returnUsers.add(user); } } if (log.isDebugEnabled()) log.debug( "Matched " + returnUsers.size() + " users in " + stopWatch.getIntervalTime() + "ms"); Collections.sort( returnUsers, new UserBestNameComparator(jiraServiceContext.getI18nBean().getLocale())); if (log.isDebugEnabled()) { log.debug( "Sorted top " + returnUsers.size() + " users in " + stopWatch.getIntervalTime() + "ms"); log.debug("User-picker search completed in " + stopWatch.getTotalTime() + "ms"); } return returnUsers; }
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")); } } }
@Override public boolean canPerformAjaxSearch(final JiraServiceContext jiraServiceContext) { User loggedInUser = (jiraServiceContext != null) ? jiraServiceContext.getLoggedInUser() : null; return canPerformAjaxSearch(loggedInUser); }
public ProjectImportResults doImport( final JiraServiceContext jiraServiceContext, final ProjectImportOptions projectImportOptions, final BackupProject backupProject, final BackupSystemInformation backupSystemInformation, final ProjectImportData projectImportData, final TaskProgressInterval taskProgressInterval) { Null.not("projectImportOptions", projectImportOptions); Null.not("backupSystemInformation", backupSystemInformation); Null.not("projectImportData", projectImportData); Null.not("backupProject", backupProject); validateJiraServiceContext(jiraServiceContext); final ErrorCollection errorCollection = jiraServiceContext.getErrorCollection(); final I18nHelper i18n = jiraServiceContext.getI18nBean(); // Get the expected number of users that we will create final int usersToCreate = (isExternalUserManagementEnabled()) ? 0 : projectImportData .getProjectImportMapper() .getUserMapper() .getUsersToAutoCreate() .size(); final ProjectImportResults projectImportResults = getInitialImportResults(projectImportData, i18n, usersToCreate); // 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 projectImportResults; } try { log.info( "Starting project import for project '" + backupProject.getProject().getKey() + "'."); if (isExternalUserManagementEnabled()) { log.info("External user management is enabled. No users will be imported."); } else { log.info( "Creating missing users. Attempting to create " + projectImportResults.getExpectedUsersCreatedCount() + " users."); // External User Management is OFF - create missing users that we can. // This will fill in subtask progress from 0% - 10% of the doImport task final TaskProgressInterval subInterval = getSubInterval(taskProgressInterval, 0, 10); projectImportManager.createMissingUsers( projectImportData.getProjectImportMapper().getUserMapper(), projectImportResults, subInterval); log.info( "Finished creating missing users. " + projectImportResults.getUsersCreatedCount() + " users created."); } // Create/Update the project, its details, components, versions, role membership try { // This will fill in subtask progress from 10% - 20% of the doImport task (Allow for // creating lots of Project Role members) final TaskProgressInterval subInterval = getSubInterval(taskProgressInterval, 10, 20); projectImportManager.importProject( projectImportOptions, projectImportData.getProjectImportMapper(), backupProject, projectImportResults, subInterval); } catch (final AbortImportException e) { // Add an error message errorCollection.addErrorMessage( i18n.getText("admin.error.project.import.project.update.error")); throw e; } // Import the issues and all their related values and reIndex the project once it is done try { // This will fill in subtask progress from 20% - 100% of the doImport task (Allow for // creating lots of Project Role members) final TaskProgressInterval subInterval = getSubInterval(taskProgressInterval, 20, 100); projectImportManager.doImport( projectImportOptions, projectImportData, backupProject, backupSystemInformation, projectImportResults, subInterval, i18n, jiraServiceContext.getUser()); // Only set the completed flag once everything has finished projectImportResults.setImportCompleted(true); } catch (final IOException e) { log.error( "There was a problem accessing the partitioned XML files when performing a project import.", e); errorCollection.addErrorMessage( getText( i18n, "admin.errors.project.import.problem.reading.partitioned.xml", e.getMessage())); } catch (final AbortImportException aie) { // Note that AbortImportException extends SAXException, so we need to catch and handle // AbortImportException first. log.error("The import was aborted because there were too many errors."); errorCollection.addErrorMessage(i18n.getText("admin.errors.project.import.import.error")); } catch (final SAXException e) { log.error( "There was a problem accessing the partitioned XML files when performing a project import.", e); errorCollection.addErrorMessage( getText( i18n, "admin.errors.project.import.sax.problem.partitioned.xml", e.getMessage())); } catch (final IndexException e) { log.error("There was a problem reIndexing the newly imported project.", e); errorCollection.addErrorMessage( i18n.getText("admin.errors.project.import.reindex.problem", e.getMessage())); } log.info( "Finished project import for project '" + backupProject.getProject().getKey() + "'."); } catch (final AbortImportException aie) { log.error("The import was aborted because there were too many errors."); errorCollection.addErrorMessage(i18n.getText("admin.errors.project.import.import.error")); } // Clean up the temporary "partitioned" XML files. projectImportData.getTemporaryFiles().deleteTempFiles(); // Always record the end of the import. projectImportResults.setEndTime(System.currentTimeMillis()); logImportResults(projectImportResults); return projectImportResults; }
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; }
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 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; }