private Set<ProjectIssueTypeContext> getContextsForProjects(final Collection<Project> projects) {
CollectionBuilder<ProjectIssueTypeContext> builder = CollectionBuilder.newBuilder();
for (Project project : projects) {
builder.add(
new ProjectIssueTypeContextImpl(
new ProjectContextImpl(project.getId()), AllIssueTypesContext.INSTANCE));
}
return builder.asMutableSet();
}
private void validateExistingProjectHasValidStateForImport(
final BackupProject backupProject,
final BackupSystemInformation backupSystemInformation,
final Project existingProject,
final I18nHelper i18n,
final MessageSet messageSet) {
final String projectKey = backupProject.getProject().getKey();
// Verify that the project has no existing issues
final long issueCount = issueManager.getIssueCountForProject(existingProject.getId());
if (issueCount != 0) {
messageSet.addErrorMessage(
getText(
i18n,
"admin.error.project.import.project.contains.issues",
projectKey,
String.valueOf(issueCount)));
}
// Verify that the project has no existing versions
final long versionCount = versionManager.getVersions(existingProject.getId()).size();
if (versionCount != 0) {
messageSet.addErrorMessage(
getText(
i18n,
"admin.error.project.import.project.contains.versions",
projectKey,
String.valueOf(versionCount)));
}
// Verify that the project has no existing components
final long componentCount =
projectComponentManager.findAllForProject(existingProject.getId()).size();
if (componentCount != 0) {
messageSet.addErrorMessage(
getText(
i18n,
"admin.error.project.import.project.contains.components",
projectKey,
String.valueOf(componentCount)));
}
// Verify that if the project has a default assignee of Unassigned that the current instance of
// JIRA supports unassigned issues
if (projectHasDefaultAssigneeUnassigned(backupProject, backupSystemInformation)) {
// We want this instance of JIRA to allow unassigned issues.
final boolean allowUnassigned =
applicationProperties.getOption(APKeys.JIRA_OPTION_ALLOWUNASSIGNED);
if (!allowUnassigned) {
messageSet.addErrorMessage(
getText(
i18n,
"admin.error.project.import.project.default.assignee.not.allowed",
backupProject.getProject().getName()));
}
}
}
public Map<String, String> getAllProjects() {
Map<String, String> allProjs = new TreeMap<String, String>();
List<Project> projs = prMgr.getProjectObjects();
if (projs != null) {
for (Project proj : projs) {
allProjs.put(proj.getId().toString(), getProjView(proj.getName(), proj.getDescription()));
}
}
return allProjs;
}
protected void doValidation() {
final Project projectObject = getProjectObject();
if (projectObject == null) {
addErrorMessage(getText("admin.deleteproject.error.no.project", pid));
return;
}
final ProjectService.DeleteProjectValidationResult result =
projectService.validateDeleteProject(getRemoteUser(), projectObject.getKey());
if (!result.isValid()) {
addErrorCollection(result.getErrorCollection());
}
}
@Override
public void validateFromParams(
CustomFieldParams cfParams, ErrorCollection errorCollection, FieldConfig fieldConfig) {
@SuppressWarnings("unchecked")
final Collection<String> params = cfParams.getAllValues();
CustomField cf = fieldConfig.getCustomField();
JiraAuthenticationContext authCtx =
ComponentManager.getInstance().getJiraAuthenticationContext();
I18nHelper i18n = authCtx.getI18nHelper();
UserProjectHistoryManager userProjectHistoryManager =
ComponentManager.getComponentInstanceOfType(UserProjectHistoryManager.class);
Project currentProject =
userProjectHistoryManager.getCurrentProject(Permissions.BROWSE, authCtx.getLoggedInUser());
boolean isAutocompleteView;
if (cf.isAllProjects()) {
isAutocompleteView =
qfMgr.isAutocompleteView(cf.getIdAsLong(), Consts.PROJECT_ID_FOR_GLOBAL_CF);
} else {
isAutocompleteView = qfMgr.isAutocompleteView(cf.getIdAsLong(), currentProject.getId());
}
if (isAutocompleteView) {
if ((params == null) || params.isEmpty()) {
boolean addNull;
if (cf.isAllProjects()) {
addNull = qfMgr.getAddNull(cf.getIdAsLong(), Consts.PROJECT_ID_FOR_GLOBAL_CF);
} else {
addNull = qfMgr.getAddNull(cf.getIdAsLong(), currentProject.getId());
}
if (!addNull) {
errorCollection.addError(
fieldConfig.getFieldId(), i18n.getText("queryfields.error.isnotnull"));
}
} else {
if (params.size() > 1) {
errorCollection.addError(
fieldConfig.getFieldId(), i18n.getText("queryfields.error.invalid.params"));
} else {
for (String param : params) {
Issue issue = issueMgr.getIssueObject(param);
if (issue == null) {
errorCollection.addError(
fieldConfig.getFieldId(), i18n.getText("queryfields.error.notissue", param));
}
}
}
}
}
}
public void testGetProjectIdsWithAll() {
expect(ctx.getLoggedInUser()).andReturn(mockUser);
Project project = createNiceMock(Project.class);
expect(project.getId()).andReturn(666L);
expect(prms.getProjectObjects(Permissions.BROWSE, mockUser)).andReturn(Arrays.asList(project));
EasyMock.replay(ctx, prms, proj, project);
ProjectsAndCategoriesHelper helper = new DefaultProjectsAndCategoriesHelper(proj, prms, ctx);
Set<Long> ids = helper.getProjectIds("allprojects");
assertNotNull(ids);
assertEquals(1, ids.size());
}
private boolean checkWorkflow(
final boolean equality,
final Set<String> ids,
final Project project,
final String issueType,
final String workflowName) {
final JiraWorkflow workflow = workflowManager.getWorkflow(workflowName);
if (workflow != null) {
final List<Status> statusObjects = workflow.getLinkedStatusObjects();
for (Status statusObject : statusObjects) {
// JRA-19026 - when we encounter really messed up data the workflow can return null statuses
if (statusObject != null) {
if (equality == ids.contains(statusObject.getId())) {
return true;
}
} else {
final String issueTypeStr = issueType == null ? "default" : issueType;
// Kinda strange, probably means you manually messed with your workflow, lets info log
log.info(
"Workflow: '"
+ workflow.getName()
+ "' associated with project: '"
+ project.getId()
+ "' and issue type: '"
+ issueTypeStr
+ "' contains a null status, you might want to fix that.");
}
}
}
return false;
}
private void logImportResults(final ProjectImportResults projectImportResults) {
log.info(
"The project import took '" + projectImportResults.getImportDuration() + "' ms to run.");
final Project project = projectImportResults.getImportedProject();
if (project != null) {
log.info(
"The project import created '"
+ project.getComponents().size()
+ "' project components.");
log.info(
"The project import created '" + project.getVersions().size() + "' project versions.");
}
log.info(
"The project import created '"
+ projectImportResults.getUsersCreatedCount()
+ "' out of '"
+ projectImportResults.getExpectedUsersCreatedCount()
+ "' users.");
for (final Iterator iterator = projectImportResults.getRoles().iterator();
iterator.hasNext(); ) {
final String projectRoleName = (String) iterator.next();
log.info(
"The project import created "
+ projectImportResults.getUsersCreatedCountForRole(projectRoleName)
+ " users, "
+ projectImportResults.getGroupsCreatedCountForRole(projectRoleName)
+ " groups for project role "
+ projectRoleName
+ ".");
}
log.info(
"The project import created '"
+ projectImportResults.getIssuesCreatedCount()
+ "' out of '"
+ projectImportResults.getExpectedIssuesCreatedCount()
+ "' issues.");
log.info(
"The project import created '"
+ projectImportResults.getAttachmentsCreatedCount()
+ "' out of "
+ projectImportResults.getExpectedAttachmentsCreatedCount()
+ "' attachments.");
}
public void testGetProjectIds() {
expect(ctx.getLoggedInUser()).andReturn(mockUser);
Project project = createNiceMock(Project.class);
expect(project.getId()).andReturn(666L);
Project project2 = createNiceMock(Project.class);
expect(project2.getId()).andReturn(323L);
expect(proj.getProjectObj(666L)).andReturn(project);
expect(proj.getProjectObj(323L)).andReturn(project2);
expect(prms.hasPermission(Permissions.BROWSE, project, mockUser)).andReturn(true);
expect(prms.hasPermission(Permissions.BROWSE, project2, mockUser)).andReturn(true);
expect(proj.getProjectObjectsFromProjectCategory(555L)).andReturn(Arrays.asList(project2));
EasyMock.replay(ctx, prms, proj, project, project2);
ProjectsAndCategoriesHelper helper = new DefaultProjectsAndCategoriesHelper(proj, prms, ctx);
Set<Long> ids = helper.getProjectIds("666|cat555");
assertNotNull(ids);
assertEquals(1, ids.size());
}
private Set<ProjectIssueTypeContext> getContextsForIssueType(
final Project project, final Map<String, String> schemeMap, final String issueType) {
// Null issue type means "default" issues types.
if (issueType == null) {
Set<ProjectIssueTypeContext> contexts = new HashSet<ProjectIssueTypeContext>();
final Collection<IssueType> projectTypes =
issueTypeSchemeManager.getIssueTypesForProject(project);
for (IssueType projectType : projectTypes) {
if (projectType != null && !schemeMap.containsKey(projectType.getId())) {
contexts.add(
new ProjectIssueTypeContextImpl(
new ProjectContextImpl(project.getId()),
new IssueTypeContextImpl(projectType.getId())));
}
}
return contexts;
} else {
return Collections.<ProjectIssueTypeContext>singleton(
new ProjectIssueTypeContextImpl(
new ProjectContextImpl(project.getId()), new IssueTypeContextImpl(issueType)));
}
}
/** Note: this will not compare the time stamps of two events - only everything else. */
@SuppressWarnings({"RedundantIfStatement"})
public boolean equals(Object o) {
if (this == o) {
return true;
}
if (o == null || getClass() != o.getClass()) {
return false;
}
final AbstractProjectEvent event = (AbstractProjectEvent) o;
if (getParams() != null ? !getParams().equals(event.getParams()) : event.getParams() != null) {
return false;
}
if (project != null ? !project.equals(event.project) : event.project != null) {
return false;
}
if (user != null ? !user.equals(event.user) : event.user != null) {
return false;
}
return true;
}
protected FieldMetaBean getFieldMetaBean(
boolean required, OrderableField field, boolean forceRequired) {
Collection<String> operations;
if (field instanceof RestFieldOperations) {
operations = ((RestFieldOperations) field).getRestFieldOperation().getSupportedOperations();
} else {
operations = Collections.emptyList();
}
Collection<?> allowedValues = null;
FieldTypeInfo fieldTypeInfo;
JsonType jsonType;
if (field instanceof RestAwareField) {
FieldTypeInfoContext fieldTypeInfoContext =
new FieldTypeInfoContextImpl(
field,
issue,
new IssueContextImpl(project.getId(), issueType.getId()),
getOperationContext());
fieldTypeInfo = ((RestAwareField) field).getFieldTypeInfo(fieldTypeInfoContext);
jsonType = getJsonType((RestAwareField) field);
allowedValues = getAllowedValueBeans(field, fieldTypeInfo.getAllowedValues());
} else if (field instanceof CustomField) {
CustomField customField = (CustomField) field;
fieldTypeInfo = new FieldTypeInfo(null, null);
jsonType = getJsonType(customField);
} else {
fieldTypeInfo = new FieldTypeInfo(null, null);
jsonType = null;
}
return new FieldMetaBean(
required || forceRequired,
jsonType,
field.getName(),
fieldTypeInfo.getAutoCompleteUrl(),
operations,
allowedValues);
}
@EventListener
public void onIssueEvent(IssueEvent issueEvent) {
if (!issueEvent.getEventTypeId().equals(EventType.ISSUE_CREATED_ID)) {
return;
}
Issue issue = issueEvent.getIssue();
Collection<ProjectComponent> comps = issue.getComponentObjects();
if (comps == null || comps.size() < 2) {
return;
}
Project project = issue.getProjectObject();
if (project == null || !isApplyPlugin(project.getId())) {
return;
}
List<Issue> newIssues = new ArrayList<Issue>();
ProjectComponent gv = null;
Iterator<ProjectComponent> iter = comps.iterator();
while (iter.hasNext()) {
gv = iter.next();
MutableIssue nissue = ComponentManager.getInstance().getIssueFactory().getIssue();
// --> summary
nissue.setSummary(String.format("[%s] %s", gv.getName(), issue.getSummary()));
// --> project
if (issue.getProjectObject() != null) {
nissue.setProjectId(issue.getProjectObject().getId());
}
// --> issue type
if (issue.getIssueTypeObject() != null) {
nissue.setIssueTypeId(issue.getIssueTypeObject().getId());
}
// --> components
Collection<ProjectComponent> nComps = new LinkedList<ProjectComponent>();
nComps.add(gv);
nissue.setComponentObjects(nComps);
// --> assignee
String compLead = gv.getLead();
nissue.setAssigneeId(compLead);
// --> reporter
nissue.setReporter(issueEvent.getUser());
// --> priority
nissue.setPriorityObject(issue.getPriorityObject());
// --> description
nissue.setDescription(issue.getDescription());
// --> env
nissue.setEnvironment(issue.getEnvironment());
// --> due date
nissue.setDueDate(issue.getDueDate());
// --> estimate
nissue.setEstimate(issue.getEstimate());
// --> labels
nissue.setLabels(issue.getLabels());
nissue.setAffectedVersions(issue.getAffectedVersions());
nissue.setWorkflowId(issue.getWorkflowId());
nissue.setParentId(issue.getParentId());
// --> status
if (issue.getStatusObject() != null) {
nissue.setStatusId(issue.getStatusObject().getId());
}
// --> resolution
if (issue.getResolutionObject() != null) {
nissue.setResolutionId(issue.getResolutionObject().getId());
}
nissue.setFixVersions(issue.getFixVersions());
nissue.setResolutionDate(issue.getResolutionDate());
nissue.setTimeSpent(issue.getTimeSpent());
nissue.setVotes(issue.getVotes());
nissue.setCreated(issue.getCreated());
nissue.setSecurityLevelId(issue.getSecurityLevelId());
nissue.setOriginalEstimate(issue.getOriginalEstimate());
List<CustomField> cfs =
ComponentManager.getInstance().getCustomFieldManager().getCustomFieldObjects(issue);
if (cfs != null) {
for (CustomField cf : cfs) {
Object cfVal = issue.getCustomFieldValue(cf);
if (cfVal != null) {
nissue.setCustomFieldValue(cf, cfVal);
}
}
}
// --> create issue
try {
Issue newIssueObj =
ComponentManager.getInstance()
.getIssueManager()
.createIssueObject(issueEvent.getUser(), nissue);
newIssues.add(newIssueObj);
} catch (CreateException crex) {
log.error("IssueClonerByComponents::onIssueEvent - Cannot create dependent issues", crex);
}
}
Collection<Attachment> atts = issue.getAttachments();
if (atts != null) {
AttachmentManager am = ComponentManager.getInstance().getAttachmentManager();
for (Attachment att : atts) {
File attFile = AttachmentUtils.getAttachmentFile(att);
String filename = att.getFilename();
String contentType = att.getMimetype();
for (Issue nissue : newIssues) {
File newFile = new File(attFile.getAbsolutePath() + nissue.getKey());
try {
FileUtils.copyFile(attFile, newFile);
am.createAttachment(newFile, filename, contentType, issueEvent.getUser(), nissue);
} catch (Exception ex) {
log.error("IssueClonerByComponents::onIssueEvent - Cannot copy attachment", ex);
}
}
}
}
IssueLinkTypeManager issueLinkTypeManager =
ComponentManager.getComponentInstanceOfType(IssueLinkTypeManager.class);
Collection<IssueLinkType> types = issueLinkTypeManager.getIssueLinkTypesByName(LINK_TYPE);
if (types == null || types.isEmpty()) {
return;
}
IssueLinkType ilt = types.iterator().next();
if (ilt != null) {
IssueLinkManager ilm = ComponentManager.getInstance().getIssueLinkManager();
for (Issue nissue : newIssues) {
try {
ilm.createIssueLink(
issue.getId(), nissue.getId(), ilt.getId(), null, issueEvent.getUser());
} catch (CreateException crex) {
log.error("IssueClonerByComponents::onIssueEvent - Cannot create link", crex);
}
}
}
}
public String getProjectKey(ProjectComponent component) {
final Project project = getProjectManager().getProjectObj(component.getProjectId());
return project.getKey();
}
@Override
public boolean handleMessage(Message message, MessageHandlerContext context)
throws MessagingException {
log.debug("CreateIssueHandler.handleMessage");
if (!canHandleMessage(message, context.getMonitor())) {
return deleteEmail;
}
try {
// get either the sender of the message, or the default reporter
User reporter = getReporter(message, context);
// no reporter - so reject the message
if (reporter == null) {
final String error = getI18nBean().getText("admin.mail.no.default.reporter");
context.getMonitor().warning(error);
context.getMonitor().messageRejected(message, error);
return false;
}
final Project project = getProject(message);
log.debug("Project = " + project);
if (project == null) {
final String text = getI18nBean().getText("admin.mail.no.project.configured");
context.getMonitor().warning(text);
context.getMonitor().messageRejected(message, text);
return false;
}
// Check that the license is valid before allowing issues to be created
// This checks for: evaluation licenses expired, user limit licenses where limit has been
// exceeded
ErrorCollection errorCollection = new SimpleErrorCollection();
// Note: want English locale here for logging purposes
I18nHelper i18nHelper = new I18nBean(Locale.ENGLISH);
getIssueCreationHelperBean().validateLicense(errorCollection, i18nHelper);
if (errorCollection.hasAnyErrors()) {
context
.getMonitor()
.warning(
getI18nBean()
.getText(
"admin.mail.bad.license", errorCollection.getErrorMessages().toString()));
return false;
}
// If user does not have create permissions, there's no point proceeding. Error out here to
// avoid a stack
// trace blow up from the WorkflowManager later on.
if (!getPermissionManager().hasPermission(Permissions.CREATE_ISSUE, project, reporter, true)
&& reporter.getDirectoryId() != -1) {
final String error =
getI18nBean().getText("admin.mail.no.create.permission", reporter.getName());
context.getMonitor().warning(error);
context.getMonitor().messageRejected(message, error);
return false;
}
log.debug("Issue Type Key = = " + issueType);
if (!hasValidIssueType()) {
context.getMonitor().warning(getI18nBean().getText("admin.mail.invalid.issue.type"));
return false;
}
String summary = message.getSubject();
if (!TextUtils.stringSet(summary)) {
context.getMonitor().error(getI18nBean().getText("admin.mail.no.subject"));
return false;
}
if (summary.length() > SummarySystemField.MAX_LEN.intValue()) {
context.getMonitor().info("Truncating summary field because it is too long: " + summary);
summary = summary.substring(0, SummarySystemField.MAX_LEN.intValue() - 3) + "...";
}
// JRA-7646 - check if priority/description is hidden - if so, do not set
String priority = null;
String description = null;
if (!getFieldVisibilityManager()
.isFieldHiddenInAllSchemes(
project.getId(),
IssueFieldConstants.PRIORITY,
Collections.singletonList(issueType))) {
priority = getPriority(message);
}
if (!getFieldVisibilityManager()
.isFieldHiddenInAllSchemes(
project.getId(),
IssueFieldConstants.DESCRIPTION,
Collections.singletonList(issueType))) {
description = getDescription(reporter, message);
}
MutableIssue issueObject = getIssueFactory().getIssue();
issueObject.setProjectObject(project);
issueObject.setSummary(summary);
issueObject.setDescription(description);
issueObject.setIssueTypeId(issueType);
issueObject.setReporter(reporter);
// if no valid assignee found, attempt to assign to default assignee
User assignee = null;
if (ccAssignee) {
assignee = getFirstValidAssignee(message.getAllRecipients(), project);
}
if (assignee == null) {
assignee = getAssigneeResolver().getDefaultAssignee(issueObject, Collections.EMPTY_MAP);
}
if (assignee != null) {
issueObject.setAssignee(assignee);
}
issueObject.setPriorityId(priority);
// Ensure issue level security is correct
setDefaultSecurityLevel(issueObject);
/*
* + FIXME -- set cf defaults @todo +
*/
// set default custom field values
// CustomFieldValuesHolder cfvh = new CustomFieldValuesHolder(issueType, project.getId());
// fields.put("customFields", CustomFieldUtils.getCustomFieldValues(cfvh.getCustomFields()));
Map<String, Object> fields = new HashMap<String, Object>();
fields.put("issue", issueObject);
// TODO: How is this supposed to work? There is no issue created yet; ID = null.
// wseliga note: Ineed I think that such call does not make sense - it will be always null
MutableIssue originalIssue = getIssueManager().getIssueObject(issueObject.getId());
// Give the CustomFields a chance to set their default values JRA-11762
List<CustomField> customFieldObjects =
ComponentAccessor.getCustomFieldManager().getCustomFieldObjects(issueObject);
for (CustomField customField : customFieldObjects) {
issueObject.setCustomFieldValue(customField, customField.getDefaultValue(issueObject));
}
fields.put(WorkflowFunctionUtils.ORIGINAL_ISSUE_KEY, originalIssue);
final Issue issue = context.createIssue(reporter, issueObject);
if (issue != null) {
// Add Cc'ed users as watchers if params set - JRA-9983
if (ccWatcher) {
addCcWatchersToIssue(message, issue, reporter, context, context.getMonitor());
}
// Record the message id of this e-mail message so we can track replies to this message
// and associate them with this issue
recordMessageId(
MailThreadManager.ISSUE_CREATED_FROM_EMAIL, message, issue.getId(), context);
}
// TODO: if this throws an error, then the issue is already created, but the email not deleted
// - we will keep "handling" this email over and over :(
createAttachmentsForMessage(message, issue, context);
return true;
} catch (Exception e) {
context.getMonitor().warning(getI18nBean().getText("admin.mail.unable.to.create.issue"), e);
}
// something went wrong - don't delete the message
return false;
}
Set<ProjectIssueTypeContext> getContextFromStatusValues(
final User searcher, final TerminalClause clause, final boolean equality) {
// if we don't have any ids, then the result will always be global: either by an empty set or
// the everything set
Set<String> ids = getIds(searcher, clause);
if (ids.isEmpty()) {
return Collections.emptySet();
}
boolean allProjects = true;
boolean allIssueTypesAcrossAllProjects = true;
final Map<String, Boolean> resultCache = new HashMap<String, Boolean>();
final Set<ProjectIssueTypeContext> allContexts = new HashSet<ProjectIssueTypeContext>();
final Collection<Project> projects =
permissionManager.getProjectObjects(Permissions.BROWSE, searcher);
for (final Project project : projects) {
boolean projectAdded = false; // is this project added to the contxt
boolean allIssueTypesAcrossProject =
true; // are ALL issue types of this project added to the context
Set<ProjectIssueTypeContext> projectIssueTypeContexts =
new HashSet<ProjectIssueTypeContext>();
// IssueType -> Workflowname
final Map<String, String> workflowMap = workflowSchemeManager.getWorkflowMap(project);
for (Map.Entry<String, String> entry : workflowMap.entrySet()) {
final boolean typeAdded;
final String issueType = entry.getKey();
final String workflowName = entry.getValue();
final Boolean cachedResult = resultCache.get(workflowName);
if (cachedResult != null) {
typeAdded = cachedResult;
} else {
typeAdded = checkWorkflow(equality, ids, project, issueType, workflowName);
resultCache.put(workflowName, typeAdded);
}
if (typeAdded) {
projectIssueTypeContexts.addAll(getContextsForIssueType(project, workflowMap, issueType));
projectAdded = true;
} else {
allIssueTypesAcrossAllProjects = false;
allIssueTypesAcrossProject = false;
}
}
if (allIssueTypesAcrossProject) // if all issue types were added, its an ALL issue type
// context type
{
projectIssueTypeContexts =
Collections.<ProjectIssueTypeContext>singleton(
new ProjectIssueTypeContextImpl(
new ProjectContextImpl(project.getId()), AllIssueTypesContext.INSTANCE));
}
if (!projectAdded) {
allProjects = false;
}
allContexts.addAll(projectIssueTypeContexts);
}
if (allProjects
&& allIssueTypesAcrossAllProjects) // if all ALL projects and ALL issue types were added to
// the context, it is an ALL ALL context type
{
return Collections.singleton(ProjectIssueTypeContextImpl.createGlobalContext());
} else {
return allContexts;
}
}
public AffectedProject(final Project project) {
this.projectId = project.getId();
this.projectName = project.getName();
}
public int hashCode() {
int result = super.hashCode();
result = 29 * result + (project != null ? project.hashCode() : 0);
result = 29 * result + (user != null ? user.hashCode() : 0);
return result;
}