@Override public void deleteEntities(final Iterable<Long> ids) { acquireLocksAndExecute(ids, DELETE_ENTITY, new Runnable() { @Override public void run() { try { DefaultWorkflowSchemeManager.super.deleteEntities(ids); } finally { clearWorkflowSchemeEntityCache(); } } }); }
public void addWorkflowToScheme(final GenericValue scheme, final String workflowName, final String issueTypeId) throws GenericEntityException { try { final SchemeEntity schemeEntity = new SchemeEntity(workflowName, issueTypeId); // prevent adding the same workflow multiple times to one scheme if (getEntities(scheme, issueTypeId).isEmpty()) { createSchemeEntity(scheme, schemeEntity); } } finally { clearWorkflowCache(); } }
@Override public boolean removeEntities(final GenericValue scheme, final Long entityTypeId) throws RemoveException { try { return super.removeEntities(scheme, entityTypeId); } finally { clearWorkflowSchemeEntityCache(); } }
@Override public void run() { final AssignableWorkflowScheme scheme = getWorkflowSchemeObj(id); doDeleteScheme(scheme); } });
@Override public AssignableWorkflowScheme cleanUpSchemeDraft(Project project, ApplicationUser user) { AssignableWorkflowScheme workflowScheme = getWorkflowSchemeObj(project); if (workflowScheme.isDefault()) { return null; } List<Project> projectsUsing = getProjectsUsing(workflowScheme); if (projectsUsing.size() > 1) { return null; } DraftWorkflowScheme draft = getDraftForParent(workflowScheme); if (draft == null) { return null; } AssignableWorkflowScheme.Builder copyOfDraftBuilder = new AssignableWorkflowSchemeBuilder() .setName(getNameForCopy(draft)) .setDescription(getDescriptionForCopy(user, workflowScheme)) .setMappings(draft.getMappings()); AssignableWorkflowScheme scheme = createScheme(copyOfDraftBuilder.build()); deleteWorkflowScheme(draft); return scheme; }
@Override public void replaceSchemeWithDraft(DraftWorkflowScheme draft) { AssignableWorkflowScheme parentScheme = getParentForDraft(draft.getId()) .builder() .setMappings(draft.getMappings()) .build(); updateWorkflowScheme(parentScheme); deleteWorkflowScheme(draft); }
@Nonnull @Override public AssignableWorkflowScheme createScheme(@Nonnull AssignableWorkflowScheme workflowScheme) { notNull("wokflowScheme", workflowScheme); AssignableWorkflowSchemeStore.AssignableState.Builder builder = assignableWorkflowSchemeStore.builder(); builder.setName(workflowScheme.getName()) .setDescription(workflowScheme.getDescription()) .setMappings(workflowScheme.getMappings()); AssignableWorkflowSchemeStore.AssignableState savedState = assignableWorkflowSchemeStore.create(builder.build()); eventPublisher.publish(createSchemeCreatedEvent(getSchemeObject(savedState.getId()))); return toWorkflowScheme(savedState); }
public void updateSchemesForRenamedWorkflow(final String oldWorkflowName, final String newWorkflowName) { if (StringUtils.isBlank(oldWorkflowName)) { throw new IllegalArgumentException("oldWorkflowName must not be null or empty string"); } if (StringUtils.isBlank(newWorkflowName)) { throw new IllegalArgumentException("newWorkflowName must not be null or empty string"); } //TODO: Will have to fix this for workflow schemes. ofBizDelegator.bulkUpdateByAnd(getEntityName(), ImmutableMap.of(COLUMN_WORKFLOW, newWorkflowName), ImmutableMap.of(COLUMN_WORKFLOW, oldWorkflowName)); draftWorkflowSchemeStore.renameWorkflow(oldWorkflowName, newWorkflowName); clearWorkflowCache(); }
public GenericValue createSchemeEntity(long schemeId, final SchemeEntity schemeEntity) throws GenericEntityException { if (!(schemeEntity.getEntityTypeId() instanceof String)) { throw new IllegalArgumentException("Workflow scheme IDs must be String values."); } try { return EntityUtils.createValue(getEntityName(), FieldMap.build("scheme", schemeId, COLUMN_WORKFLOW, schemeEntity.getType(), COLUMN_ISSUETYPE, schemeEntity.getEntityTypeId().toString())); } finally { clearWorkflowSchemeEntityCache(); } }
@Override public AssignableWorkflowScheme copyDraft(DraftWorkflowScheme draft, ApplicationUser user, String newDescription) { AssignableWorkflowScheme.Builder copyOfDraftBuilder = new AssignableWorkflowSchemeBuilder() .setName(getNameForCopy(draft)) .setDescription(newDescription) .setMappings(draft.getMappings()); return createScheme(copyOfDraftBuilder.build()); }
public GenericValue createSchemeEntity(final GenericValue scheme, final SchemeEntity schemeEntity) throws GenericEntityException { return createSchemeEntity(scheme.getLong("id"), schemeEntity); }
@Override public void deleteEntity(final Long id) throws DataAccessException { deleteEntities(Collections.singleton(id)); }
@EventListener public void onClearCache(final ClearCacheEvent event) { super.onClearCache(event); clearWorkflowCache(); }
void doDeleteScheme(AssignableWorkflowScheme scheme) { checkMigration(scheme); try { super.deleteScheme(scheme.getId()); } catch (GenericEntityException e) { throw new DataAccessException(e); } draftWorkflowSchemeStore.deleteByParentId(scheme.getId()); eventPublisher.publish(new WorkflowSchemeDeletedEvent(scheme.getId(), scheme.getName())); }
protected GenericValue createSchemeEntityNoEvent(final GenericValue scheme, final SchemeEntity schemeEntity) throws GenericEntityException { return createSchemeEntity(scheme.getLong("id"), schemeEntity); }
public void clearWorkflowCache() { activeWorkflowCache.reset(); clearWorkflowSchemeEntityCache(); }
private void createSchemeEntities(AssignableWorkflowScheme workflowScheme) { // Create all new entities for (Map.Entry<String, String> mappingEntry : workflowScheme.getMappings().entrySet()) { String issueTypeId = mappingEntry.getKey(); if (issueTypeId == null) { issueTypeId = ALL_ISSUE_TYPES; } String workflowName = mappingEntry.getValue(); SchemeEntity schemeEntity = new SchemeEntity(workflowName, issueTypeId); try { createSchemeEntity(workflowScheme.getId(), schemeEntity); } catch (GenericEntityException e) { throw new DataAccessException(e); } } }
@Override public GenericValue createScheme(final String name, final String description) throws GenericEntityException { try { return super.createScheme(name, description); } finally { clearWorkflowSchemeEntityCache(); } }
@Override protected void flushProjectSchemes() { try { super.flushProjectSchemes(); } finally { clearWorkflowSchemeEntityCache(); } }