target stringlengths 20 113k | src_fm stringlengths 11 86.3k | src_fm_fc stringlengths 21 86.4k | src_fm_fc_co stringlengths 30 86.4k | src_fm_fc_ms stringlengths 42 86.8k | src_fm_fc_ms_ff stringlengths 43 86.8k |
|---|---|---|---|---|---|
@Test public void repoConfigurationHasOriginAndAvoidIndex() throws Exception { service.importProjects(target); verify(repoService).createRepository(any(), any(), any(), configsCaptor.capture()); RepositoryEnvironmentConfigurations configs = configsCaptor.getValue(); assertEquals(target.toUri().toString(), assertValue(configs.getOrigin(), String.class)); assertEquals("true", configs.getConfigurationMap().get(AVOID_INDEX)); } | public void importProjects(Path actualTarget) { OrganizationalUnit ou = ouService.createOrganizationalUnit(OU_NAME, "org.migration", Collections.emptyList(), Collections.singletonList(new Contributor(OU_OWNER, ContributorType.OWNER))); String repositoryURL = actualTarget.toUri().toString(); RepositoryEnvironmentConfigurations configurations = new RepositoryEnvironmentConfigurations(); Map<String, Object> configMap = configurations.getConfigurationMap(); configMap.put(EnvironmentParameters.AVOID_INDEX, "true"); configMap.put("origin", repositoryURL); Repository repo = repoService.createRepository(ou, GitRepository.SCHEME.toString(), TMP_REPO_ALIAS, configurations); WorkspaceProject project = projectService.resolveProject(repo); migrationService.migrate(project); repoService.removeRepository(ou.getSpace(), TMP_REPO_ALIAS); } | TemporaryNiogitService { public void importProjects(Path actualTarget) { OrganizationalUnit ou = ouService.createOrganizationalUnit(OU_NAME, "org.migration", Collections.emptyList(), Collections.singletonList(new Contributor(OU_OWNER, ContributorType.OWNER))); String repositoryURL = actualTarget.toUri().toString(); RepositoryEnvironmentConfigurations configurations = new RepositoryEnvironmentConfigurations(); Map<String, Object> configMap = configurations.getConfigurationMap(); configMap.put(EnvironmentParameters.AVOID_INDEX, "true"); configMap.put("origin", repositoryURL); Repository repo = repoService.createRepository(ou, GitRepository.SCHEME.toString(), TMP_REPO_ALIAS, configurations); WorkspaceProject project = projectService.resolveProject(repo); migrationService.migrate(project); repoService.removeRepository(ou.getSpace(), TMP_REPO_ALIAS); } } | TemporaryNiogitService { public void importProjects(Path actualTarget) { OrganizationalUnit ou = ouService.createOrganizationalUnit(OU_NAME, "org.migration", Collections.emptyList(), Collections.singletonList(new Contributor(OU_OWNER, ContributorType.OWNER))); String repositoryURL = actualTarget.toUri().toString(); RepositoryEnvironmentConfigurations configurations = new RepositoryEnvironmentConfigurations(); Map<String, Object> configMap = configurations.getConfigurationMap(); configMap.put(EnvironmentParameters.AVOID_INDEX, "true"); configMap.put("origin", repositoryURL); Repository repo = repoService.createRepository(ou, GitRepository.SCHEME.toString(), TMP_REPO_ALIAS, configurations); WorkspaceProject project = projectService.resolveProject(repo); migrationService.migrate(project); repoService.removeRepository(ou.getSpace(), TMP_REPO_ALIAS); } @Inject TemporaryNiogitService(OrganizationalUnitService ouService,
RepositoryService repoService,
WorkspaceProjectService projectService,
WorkspaceProjectMigrationService migrationService); } | TemporaryNiogitService { public void importProjects(Path actualTarget) { OrganizationalUnit ou = ouService.createOrganizationalUnit(OU_NAME, "org.migration", Collections.emptyList(), Collections.singletonList(new Contributor(OU_OWNER, ContributorType.OWNER))); String repositoryURL = actualTarget.toUri().toString(); RepositoryEnvironmentConfigurations configurations = new RepositoryEnvironmentConfigurations(); Map<String, Object> configMap = configurations.getConfigurationMap(); configMap.put(EnvironmentParameters.AVOID_INDEX, "true"); configMap.put("origin", repositoryURL); Repository repo = repoService.createRepository(ou, GitRepository.SCHEME.toString(), TMP_REPO_ALIAS, configurations); WorkspaceProject project = projectService.resolveProject(repo); migrationService.migrate(project); repoService.removeRepository(ou.getSpace(), TMP_REPO_ALIAS); } @Inject TemporaryNiogitService(OrganizationalUnitService ouService,
RepositoryService repoService,
WorkspaceProjectService projectService,
WorkspaceProjectMigrationService migrationService); void importProjects(Path actualTarget); } | TemporaryNiogitService { public void importProjects(Path actualTarget) { OrganizationalUnit ou = ouService.createOrganizationalUnit(OU_NAME, "org.migration", Collections.emptyList(), Collections.singletonList(new Contributor(OU_OWNER, ContributorType.OWNER))); String repositoryURL = actualTarget.toUri().toString(); RepositoryEnvironmentConfigurations configurations = new RepositoryEnvironmentConfigurations(); Map<String, Object> configMap = configurations.getConfigurationMap(); configMap.put(EnvironmentParameters.AVOID_INDEX, "true"); configMap.put("origin", repositoryURL); Repository repo = repoService.createRepository(ou, GitRepository.SCHEME.toString(), TMP_REPO_ALIAS, configurations); WorkspaceProject project = projectService.resolveProject(repo); migrationService.migrate(project); repoService.removeRepository(ou.getSpace(), TMP_REPO_ALIAS); } @Inject TemporaryNiogitService(OrganizationalUnitService ouService,
RepositoryService repoService,
WorkspaceProjectService projectService,
WorkspaceProjectMigrationService migrationService); void importProjects(Path actualTarget); } |
@Test public void groupSystemConfigGroupsTest() { createConfigGroupsWithOldConfigurationService(); migrateConfigGroups(); checkConfigGroupsWithNewConfigurationService(); } | public void groupSystemConfigGroups() { try { startBatch(); system.out().println("Moving existing configurations to their type directories..."); groupConfigGroupsByType(); system.out().println("Moving existing repositories configurations to their space directories..."); groupRepositoryConfigGroupsBySpace(); } finally { endBatch(); } } | ConfigGroupsMigrationService { public void groupSystemConfigGroups() { try { startBatch(); system.out().println("Moving existing configurations to their type directories..."); groupConfigGroupsByType(); system.out().println("Moving existing repositories configurations to their space directories..."); groupRepositoryConfigGroupsBySpace(); } finally { endBatch(); } } } | ConfigGroupsMigrationService { public void groupSystemConfigGroups() { try { startBatch(); system.out().println("Moving existing configurations to their type directories..."); groupConfigGroupsByType(); system.out().println("Moving existing repositories configurations to their space directories..."); groupRepositoryConfigGroupsBySpace(); } finally { endBatch(); } } ConfigGroupsMigrationService(); @Inject ConfigGroupsMigrationService(final @Named("system") Repository systemRepository,
final ConfigGroupMarshaller marshaller,
final @Named("configIO") IOService ioService,
final @Named("systemFS") FileSystem fs,
final SystemAccess system,
final User identity); } | ConfigGroupsMigrationService { public void groupSystemConfigGroups() { try { startBatch(); system.out().println("Moving existing configurations to their type directories..."); groupConfigGroupsByType(); system.out().println("Moving existing repositories configurations to their space directories..."); groupRepositoryConfigGroupsBySpace(); } finally { endBatch(); } } ConfigGroupsMigrationService(); @Inject ConfigGroupsMigrationService(final @Named("system") Repository systemRepository,
final ConfigGroupMarshaller marshaller,
final @Named("configIO") IOService ioService,
final @Named("systemFS") FileSystem fs,
final SystemAccess system,
final User identity); void groupSystemConfigGroups(); } | ConfigGroupsMigrationService { public void groupSystemConfigGroups() { try { startBatch(); system.out().println("Moving existing configurations to their type directories..."); groupConfigGroupsByType(); system.out().println("Moving existing repositories configurations to their space directories..."); groupRepositoryConfigGroupsBySpace(); } finally { endBatch(); } } ConfigGroupsMigrationService(); @Inject ConfigGroupsMigrationService(final @Named("system") Repository systemRepository,
final ConfigGroupMarshaller marshaller,
final @Named("configIO") IOService ioService,
final @Named("systemFS") FileSystem fs,
final SystemAccess system,
final User identity); void groupSystemConfigGroups(); } |
@Test public void testCreateForm() { when(formDefinitionSerializer.serialize(any())).thenAnswer(this::verifyNewForm); FormModel formModel = mock(FormModel.class); Path resultPath = formEditorService.createForm(path, FULL_FORM_NAME, formModel); assertNotNull(resultPath); } | @Override public Path createForm(Path path, String formName, FormModel formModel) { org.uberfire.java.nio.file.Path kiePath = Paths.convert(path).resolve(formName); try { if (ioService.exists(kiePath)) { throw new FileAlreadyExistsException(kiePath.toString()); } FormDefinition form = new FormDefinition(formModel); form.setId(UIDGenerator.generateUID()); form.setName(formName.substring(0, formName.lastIndexOf("."))); form.setLayoutTemplate(new LayoutTemplate()); ioService.write(kiePath, formDefinitionSerializer.serialize(form), commentedOptionFactory.makeCommentedOption("")); return Paths.convert(kiePath); } catch (Exception e) { throw ExceptionUtilities.handleException(e); } } | FormEditorServiceImpl extends KieService<FormModelerContent> implements FormEditorService { @Override public Path createForm(Path path, String formName, FormModel formModel) { org.uberfire.java.nio.file.Path kiePath = Paths.convert(path).resolve(formName); try { if (ioService.exists(kiePath)) { throw new FileAlreadyExistsException(kiePath.toString()); } FormDefinition form = new FormDefinition(formModel); form.setId(UIDGenerator.generateUID()); form.setName(formName.substring(0, formName.lastIndexOf("."))); form.setLayoutTemplate(new LayoutTemplate()); ioService.write(kiePath, formDefinitionSerializer.serialize(form), commentedOptionFactory.makeCommentedOption("")); return Paths.convert(kiePath); } catch (Exception e) { throw ExceptionUtilities.handleException(e); } } } | FormEditorServiceImpl extends KieService<FormModelerContent> implements FormEditorService { @Override public Path createForm(Path path, String formName, FormModel formModel) { org.uberfire.java.nio.file.Path kiePath = Paths.convert(path).resolve(formName); try { if (ioService.exists(kiePath)) { throw new FileAlreadyExistsException(kiePath.toString()); } FormDefinition form = new FormDefinition(formModel); form.setId(UIDGenerator.generateUID()); form.setName(formName.substring(0, formName.lastIndexOf("."))); form.setLayoutTemplate(new LayoutTemplate()); ioService.write(kiePath, formDefinitionSerializer.serialize(form), commentedOptionFactory.makeCommentedOption("")); return Paths.convert(kiePath); } catch (Exception e) { throw ExceptionUtilities.handleException(e); } } @Inject FormEditorServiceImpl(@Named("ioStrategy") IOService ioService,
SessionInfo sessionInfo,
Event<ResourceOpenedEvent> resourceOpenedEvent,
FieldManager fieldManager,
FormModelHandlerManager modelHandlerManager,
KieModuleService moduleService,
FormDefinitionSerializer formDefinitionSerializer,
ModuleFormFinderService moduleFormFinderService,
DeleteService deleteService,
CommentedOptionFactory commentedOptionFactory,
RenameService renameService,
CopyService copyService); } | FormEditorServiceImpl extends KieService<FormModelerContent> implements FormEditorService { @Override public Path createForm(Path path, String formName, FormModel formModel) { org.uberfire.java.nio.file.Path kiePath = Paths.convert(path).resolve(formName); try { if (ioService.exists(kiePath)) { throw new FileAlreadyExistsException(kiePath.toString()); } FormDefinition form = new FormDefinition(formModel); form.setId(UIDGenerator.generateUID()); form.setName(formName.substring(0, formName.lastIndexOf("."))); form.setLayoutTemplate(new LayoutTemplate()); ioService.write(kiePath, formDefinitionSerializer.serialize(form), commentedOptionFactory.makeCommentedOption("")); return Paths.convert(kiePath); } catch (Exception e) { throw ExceptionUtilities.handleException(e); } } @Inject FormEditorServiceImpl(@Named("ioStrategy") IOService ioService,
SessionInfo sessionInfo,
Event<ResourceOpenedEvent> resourceOpenedEvent,
FieldManager fieldManager,
FormModelHandlerManager modelHandlerManager,
KieModuleService moduleService,
FormDefinitionSerializer formDefinitionSerializer,
ModuleFormFinderService moduleFormFinderService,
DeleteService deleteService,
CommentedOptionFactory commentedOptionFactory,
RenameService renameService,
CopyService copyService); @Override FormModelerContent loadContent(Path path); @Override Path createForm(Path path,
String formName,
FormModel formModel); @Override void delete(Path path,
String comment); @Override Path save(Path path,
FormModelerContent content,
Metadata metadata,
String comment); @Override FormModelerContent rename(Path path,
String newFileName,
String commitMessage,
boolean saveBeforeRenaming,
FormModelerContent content,
Metadata metadata); @Override void copy(Path path,
String newFileName,
String commitMessage,
boolean saveBeforeCopying,
FormModelerContent content,
Metadata metadata); } | FormEditorServiceImpl extends KieService<FormModelerContent> implements FormEditorService { @Override public Path createForm(Path path, String formName, FormModel formModel) { org.uberfire.java.nio.file.Path kiePath = Paths.convert(path).resolve(formName); try { if (ioService.exists(kiePath)) { throw new FileAlreadyExistsException(kiePath.toString()); } FormDefinition form = new FormDefinition(formModel); form.setId(UIDGenerator.generateUID()); form.setName(formName.substring(0, formName.lastIndexOf("."))); form.setLayoutTemplate(new LayoutTemplate()); ioService.write(kiePath, formDefinitionSerializer.serialize(form), commentedOptionFactory.makeCommentedOption("")); return Paths.convert(kiePath); } catch (Exception e) { throw ExceptionUtilities.handleException(e); } } @Inject FormEditorServiceImpl(@Named("ioStrategy") IOService ioService,
SessionInfo sessionInfo,
Event<ResourceOpenedEvent> resourceOpenedEvent,
FieldManager fieldManager,
FormModelHandlerManager modelHandlerManager,
KieModuleService moduleService,
FormDefinitionSerializer formDefinitionSerializer,
ModuleFormFinderService moduleFormFinderService,
DeleteService deleteService,
CommentedOptionFactory commentedOptionFactory,
RenameService renameService,
CopyService copyService); @Override FormModelerContent loadContent(Path path); @Override Path createForm(Path path,
String formName,
FormModel formModel); @Override void delete(Path path,
String comment); @Override Path save(Path path,
FormModelerContent content,
Metadata metadata,
String comment); @Override FormModelerContent rename(Path path,
String newFileName,
String commitMessage,
boolean saveBeforeRenaming,
FormModelerContent content,
Metadata metadata); @Override void copy(Path path,
String newFileName,
String commitMessage,
boolean saveBeforeCopying,
FormModelerContent content,
Metadata metadata); static final String SHORT_KEY; static final String LONG_KEY; } |
@Test public void testDeleteForm() { formEditorService.delete(path, COMMIT_MESSAGE); verify(moduleService).resolveModule(path); verify(deleteService).delete(path, COMMIT_MESSAGE); } | @Override public void delete(Path path, String comment) { try { KieModule module = moduleService.resolveModule(path); if (module == null) { logger.warn("Form : " + path.toURI() + " does not belong to a valid module"); return; } deleteService.delete(path, comment); } catch (final Exception e) { logger.error("Form: " + path.toURI() + " couldn't be deleted due to the following error. ", e); } } | FormEditorServiceImpl extends KieService<FormModelerContent> implements FormEditorService { @Override public void delete(Path path, String comment) { try { KieModule module = moduleService.resolveModule(path); if (module == null) { logger.warn("Form : " + path.toURI() + " does not belong to a valid module"); return; } deleteService.delete(path, comment); } catch (final Exception e) { logger.error("Form: " + path.toURI() + " couldn't be deleted due to the following error. ", e); } } } | FormEditorServiceImpl extends KieService<FormModelerContent> implements FormEditorService { @Override public void delete(Path path, String comment) { try { KieModule module = moduleService.resolveModule(path); if (module == null) { logger.warn("Form : " + path.toURI() + " does not belong to a valid module"); return; } deleteService.delete(path, comment); } catch (final Exception e) { logger.error("Form: " + path.toURI() + " couldn't be deleted due to the following error. ", e); } } @Inject FormEditorServiceImpl(@Named("ioStrategy") IOService ioService,
SessionInfo sessionInfo,
Event<ResourceOpenedEvent> resourceOpenedEvent,
FieldManager fieldManager,
FormModelHandlerManager modelHandlerManager,
KieModuleService moduleService,
FormDefinitionSerializer formDefinitionSerializer,
ModuleFormFinderService moduleFormFinderService,
DeleteService deleteService,
CommentedOptionFactory commentedOptionFactory,
RenameService renameService,
CopyService copyService); } | FormEditorServiceImpl extends KieService<FormModelerContent> implements FormEditorService { @Override public void delete(Path path, String comment) { try { KieModule module = moduleService.resolveModule(path); if (module == null) { logger.warn("Form : " + path.toURI() + " does not belong to a valid module"); return; } deleteService.delete(path, comment); } catch (final Exception e) { logger.error("Form: " + path.toURI() + " couldn't be deleted due to the following error. ", e); } } @Inject FormEditorServiceImpl(@Named("ioStrategy") IOService ioService,
SessionInfo sessionInfo,
Event<ResourceOpenedEvent> resourceOpenedEvent,
FieldManager fieldManager,
FormModelHandlerManager modelHandlerManager,
KieModuleService moduleService,
FormDefinitionSerializer formDefinitionSerializer,
ModuleFormFinderService moduleFormFinderService,
DeleteService deleteService,
CommentedOptionFactory commentedOptionFactory,
RenameService renameService,
CopyService copyService); @Override FormModelerContent loadContent(Path path); @Override Path createForm(Path path,
String formName,
FormModel formModel); @Override void delete(Path path,
String comment); @Override Path save(Path path,
FormModelerContent content,
Metadata metadata,
String comment); @Override FormModelerContent rename(Path path,
String newFileName,
String commitMessage,
boolean saveBeforeRenaming,
FormModelerContent content,
Metadata metadata); @Override void copy(Path path,
String newFileName,
String commitMessage,
boolean saveBeforeCopying,
FormModelerContent content,
Metadata metadata); } | FormEditorServiceImpl extends KieService<FormModelerContent> implements FormEditorService { @Override public void delete(Path path, String comment) { try { KieModule module = moduleService.resolveModule(path); if (module == null) { logger.warn("Form : " + path.toURI() + " does not belong to a valid module"); return; } deleteService.delete(path, comment); } catch (final Exception e) { logger.error("Form: " + path.toURI() + " couldn't be deleted due to the following error. ", e); } } @Inject FormEditorServiceImpl(@Named("ioStrategy") IOService ioService,
SessionInfo sessionInfo,
Event<ResourceOpenedEvent> resourceOpenedEvent,
FieldManager fieldManager,
FormModelHandlerManager modelHandlerManager,
KieModuleService moduleService,
FormDefinitionSerializer formDefinitionSerializer,
ModuleFormFinderService moduleFormFinderService,
DeleteService deleteService,
CommentedOptionFactory commentedOptionFactory,
RenameService renameService,
CopyService copyService); @Override FormModelerContent loadContent(Path path); @Override Path createForm(Path path,
String formName,
FormModel formModel); @Override void delete(Path path,
String comment); @Override Path save(Path path,
FormModelerContent content,
Metadata metadata,
String comment); @Override FormModelerContent rename(Path path,
String newFileName,
String commitMessage,
boolean saveBeforeRenaming,
FormModelerContent content,
Metadata metadata); @Override void copy(Path path,
String newFileName,
String commitMessage,
boolean saveBeforeCopying,
FormModelerContent content,
Metadata metadata); static final String SHORT_KEY; static final String LONG_KEY; } |
@Test public void testDeleteFormWrongProject() { when(moduleService.resolveModule(any())).thenReturn(null); formEditorService.delete(path, COMMIT_MESSAGE); verify(moduleService).resolveModule(path); verify(deleteService, never()).delete(path, COMMIT_MESSAGE); } | @Override public void delete(Path path, String comment) { try { KieModule module = moduleService.resolveModule(path); if (module == null) { logger.warn("Form : " + path.toURI() + " does not belong to a valid module"); return; } deleteService.delete(path, comment); } catch (final Exception e) { logger.error("Form: " + path.toURI() + " couldn't be deleted due to the following error. ", e); } } | FormEditorServiceImpl extends KieService<FormModelerContent> implements FormEditorService { @Override public void delete(Path path, String comment) { try { KieModule module = moduleService.resolveModule(path); if (module == null) { logger.warn("Form : " + path.toURI() + " does not belong to a valid module"); return; } deleteService.delete(path, comment); } catch (final Exception e) { logger.error("Form: " + path.toURI() + " couldn't be deleted due to the following error. ", e); } } } | FormEditorServiceImpl extends KieService<FormModelerContent> implements FormEditorService { @Override public void delete(Path path, String comment) { try { KieModule module = moduleService.resolveModule(path); if (module == null) { logger.warn("Form : " + path.toURI() + " does not belong to a valid module"); return; } deleteService.delete(path, comment); } catch (final Exception e) { logger.error("Form: " + path.toURI() + " couldn't be deleted due to the following error. ", e); } } @Inject FormEditorServiceImpl(@Named("ioStrategy") IOService ioService,
SessionInfo sessionInfo,
Event<ResourceOpenedEvent> resourceOpenedEvent,
FieldManager fieldManager,
FormModelHandlerManager modelHandlerManager,
KieModuleService moduleService,
FormDefinitionSerializer formDefinitionSerializer,
ModuleFormFinderService moduleFormFinderService,
DeleteService deleteService,
CommentedOptionFactory commentedOptionFactory,
RenameService renameService,
CopyService copyService); } | FormEditorServiceImpl extends KieService<FormModelerContent> implements FormEditorService { @Override public void delete(Path path, String comment) { try { KieModule module = moduleService.resolveModule(path); if (module == null) { logger.warn("Form : " + path.toURI() + " does not belong to a valid module"); return; } deleteService.delete(path, comment); } catch (final Exception e) { logger.error("Form: " + path.toURI() + " couldn't be deleted due to the following error. ", e); } } @Inject FormEditorServiceImpl(@Named("ioStrategy") IOService ioService,
SessionInfo sessionInfo,
Event<ResourceOpenedEvent> resourceOpenedEvent,
FieldManager fieldManager,
FormModelHandlerManager modelHandlerManager,
KieModuleService moduleService,
FormDefinitionSerializer formDefinitionSerializer,
ModuleFormFinderService moduleFormFinderService,
DeleteService deleteService,
CommentedOptionFactory commentedOptionFactory,
RenameService renameService,
CopyService copyService); @Override FormModelerContent loadContent(Path path); @Override Path createForm(Path path,
String formName,
FormModel formModel); @Override void delete(Path path,
String comment); @Override Path save(Path path,
FormModelerContent content,
Metadata metadata,
String comment); @Override FormModelerContent rename(Path path,
String newFileName,
String commitMessage,
boolean saveBeforeRenaming,
FormModelerContent content,
Metadata metadata); @Override void copy(Path path,
String newFileName,
String commitMessage,
boolean saveBeforeCopying,
FormModelerContent content,
Metadata metadata); } | FormEditorServiceImpl extends KieService<FormModelerContent> implements FormEditorService { @Override public void delete(Path path, String comment) { try { KieModule module = moduleService.resolveModule(path); if (module == null) { logger.warn("Form : " + path.toURI() + " does not belong to a valid module"); return; } deleteService.delete(path, comment); } catch (final Exception e) { logger.error("Form: " + path.toURI() + " couldn't be deleted due to the following error. ", e); } } @Inject FormEditorServiceImpl(@Named("ioStrategy") IOService ioService,
SessionInfo sessionInfo,
Event<ResourceOpenedEvent> resourceOpenedEvent,
FieldManager fieldManager,
FormModelHandlerManager modelHandlerManager,
KieModuleService moduleService,
FormDefinitionSerializer formDefinitionSerializer,
ModuleFormFinderService moduleFormFinderService,
DeleteService deleteService,
CommentedOptionFactory commentedOptionFactory,
RenameService renameService,
CopyService copyService); @Override FormModelerContent loadContent(Path path); @Override Path createForm(Path path,
String formName,
FormModel formModel); @Override void delete(Path path,
String comment); @Override Path save(Path path,
FormModelerContent content,
Metadata metadata,
String comment); @Override FormModelerContent rename(Path path,
String newFileName,
String commitMessage,
boolean saveBeforeRenaming,
FormModelerContent content,
Metadata metadata); @Override void copy(Path path,
String newFileName,
String commitMessage,
boolean saveBeforeCopying,
FormModelerContent content,
Metadata metadata); static final String SHORT_KEY; static final String LONG_KEY; } |
@Test public void testDeleteFormWithException() { when(moduleService.resolveModule(any())).thenThrow(new IllegalStateException("Testing exception handling")); formEditorService.delete(path, COMMIT_MESSAGE); verify(moduleService).resolveModule(path); verify(deleteService, never()).delete(path, COMMIT_MESSAGE); } | @Override public void delete(Path path, String comment) { try { KieModule module = moduleService.resolveModule(path); if (module == null) { logger.warn("Form : " + path.toURI() + " does not belong to a valid module"); return; } deleteService.delete(path, comment); } catch (final Exception e) { logger.error("Form: " + path.toURI() + " couldn't be deleted due to the following error. ", e); } } | FormEditorServiceImpl extends KieService<FormModelerContent> implements FormEditorService { @Override public void delete(Path path, String comment) { try { KieModule module = moduleService.resolveModule(path); if (module == null) { logger.warn("Form : " + path.toURI() + " does not belong to a valid module"); return; } deleteService.delete(path, comment); } catch (final Exception e) { logger.error("Form: " + path.toURI() + " couldn't be deleted due to the following error. ", e); } } } | FormEditorServiceImpl extends KieService<FormModelerContent> implements FormEditorService { @Override public void delete(Path path, String comment) { try { KieModule module = moduleService.resolveModule(path); if (module == null) { logger.warn("Form : " + path.toURI() + " does not belong to a valid module"); return; } deleteService.delete(path, comment); } catch (final Exception e) { logger.error("Form: " + path.toURI() + " couldn't be deleted due to the following error. ", e); } } @Inject FormEditorServiceImpl(@Named("ioStrategy") IOService ioService,
SessionInfo sessionInfo,
Event<ResourceOpenedEvent> resourceOpenedEvent,
FieldManager fieldManager,
FormModelHandlerManager modelHandlerManager,
KieModuleService moduleService,
FormDefinitionSerializer formDefinitionSerializer,
ModuleFormFinderService moduleFormFinderService,
DeleteService deleteService,
CommentedOptionFactory commentedOptionFactory,
RenameService renameService,
CopyService copyService); } | FormEditorServiceImpl extends KieService<FormModelerContent> implements FormEditorService { @Override public void delete(Path path, String comment) { try { KieModule module = moduleService.resolveModule(path); if (module == null) { logger.warn("Form : " + path.toURI() + " does not belong to a valid module"); return; } deleteService.delete(path, comment); } catch (final Exception e) { logger.error("Form: " + path.toURI() + " couldn't be deleted due to the following error. ", e); } } @Inject FormEditorServiceImpl(@Named("ioStrategy") IOService ioService,
SessionInfo sessionInfo,
Event<ResourceOpenedEvent> resourceOpenedEvent,
FieldManager fieldManager,
FormModelHandlerManager modelHandlerManager,
KieModuleService moduleService,
FormDefinitionSerializer formDefinitionSerializer,
ModuleFormFinderService moduleFormFinderService,
DeleteService deleteService,
CommentedOptionFactory commentedOptionFactory,
RenameService renameService,
CopyService copyService); @Override FormModelerContent loadContent(Path path); @Override Path createForm(Path path,
String formName,
FormModel formModel); @Override void delete(Path path,
String comment); @Override Path save(Path path,
FormModelerContent content,
Metadata metadata,
String comment); @Override FormModelerContent rename(Path path,
String newFileName,
String commitMessage,
boolean saveBeforeRenaming,
FormModelerContent content,
Metadata metadata); @Override void copy(Path path,
String newFileName,
String commitMessage,
boolean saveBeforeCopying,
FormModelerContent content,
Metadata metadata); } | FormEditorServiceImpl extends KieService<FormModelerContent> implements FormEditorService { @Override public void delete(Path path, String comment) { try { KieModule module = moduleService.resolveModule(path); if (module == null) { logger.warn("Form : " + path.toURI() + " does not belong to a valid module"); return; } deleteService.delete(path, comment); } catch (final Exception e) { logger.error("Form: " + path.toURI() + " couldn't be deleted due to the following error. ", e); } } @Inject FormEditorServiceImpl(@Named("ioStrategy") IOService ioService,
SessionInfo sessionInfo,
Event<ResourceOpenedEvent> resourceOpenedEvent,
FieldManager fieldManager,
FormModelHandlerManager modelHandlerManager,
KieModuleService moduleService,
FormDefinitionSerializer formDefinitionSerializer,
ModuleFormFinderService moduleFormFinderService,
DeleteService deleteService,
CommentedOptionFactory commentedOptionFactory,
RenameService renameService,
CopyService copyService); @Override FormModelerContent loadContent(Path path); @Override Path createForm(Path path,
String formName,
FormModel formModel); @Override void delete(Path path,
String comment); @Override Path save(Path path,
FormModelerContent content,
Metadata metadata,
String comment); @Override FormModelerContent rename(Path path,
String newFileName,
String commitMessage,
boolean saveBeforeRenaming,
FormModelerContent content,
Metadata metadata); @Override void copy(Path path,
String newFileName,
String commitMessage,
boolean saveBeforeCopying,
FormModelerContent content,
Metadata metadata); static final String SHORT_KEY; static final String LONG_KEY; } |
@Test public void testCreateFormThatExistsOnVFS() { try { when(ioService.exists(any())).thenReturn(true); FormModel formModel = mock(FormModel.class); formEditorService.createForm(path, FULL_FORM_NAME, formModel); fail("If form exists we shouldn't be here"); } catch (FileAlreadyExistsException ex) { } } | @Override public Path createForm(Path path, String formName, FormModel formModel) { org.uberfire.java.nio.file.Path kiePath = Paths.convert(path).resolve(formName); try { if (ioService.exists(kiePath)) { throw new FileAlreadyExistsException(kiePath.toString()); } FormDefinition form = new FormDefinition(formModel); form.setId(UIDGenerator.generateUID()); form.setName(formName.substring(0, formName.lastIndexOf("."))); form.setLayoutTemplate(new LayoutTemplate()); ioService.write(kiePath, formDefinitionSerializer.serialize(form), commentedOptionFactory.makeCommentedOption("")); return Paths.convert(kiePath); } catch (Exception e) { throw ExceptionUtilities.handleException(e); } } | FormEditorServiceImpl extends KieService<FormModelerContent> implements FormEditorService { @Override public Path createForm(Path path, String formName, FormModel formModel) { org.uberfire.java.nio.file.Path kiePath = Paths.convert(path).resolve(formName); try { if (ioService.exists(kiePath)) { throw new FileAlreadyExistsException(kiePath.toString()); } FormDefinition form = new FormDefinition(formModel); form.setId(UIDGenerator.generateUID()); form.setName(formName.substring(0, formName.lastIndexOf("."))); form.setLayoutTemplate(new LayoutTemplate()); ioService.write(kiePath, formDefinitionSerializer.serialize(form), commentedOptionFactory.makeCommentedOption("")); return Paths.convert(kiePath); } catch (Exception e) { throw ExceptionUtilities.handleException(e); } } } | FormEditorServiceImpl extends KieService<FormModelerContent> implements FormEditorService { @Override public Path createForm(Path path, String formName, FormModel formModel) { org.uberfire.java.nio.file.Path kiePath = Paths.convert(path).resolve(formName); try { if (ioService.exists(kiePath)) { throw new FileAlreadyExistsException(kiePath.toString()); } FormDefinition form = new FormDefinition(formModel); form.setId(UIDGenerator.generateUID()); form.setName(formName.substring(0, formName.lastIndexOf("."))); form.setLayoutTemplate(new LayoutTemplate()); ioService.write(kiePath, formDefinitionSerializer.serialize(form), commentedOptionFactory.makeCommentedOption("")); return Paths.convert(kiePath); } catch (Exception e) { throw ExceptionUtilities.handleException(e); } } @Inject FormEditorServiceImpl(@Named("ioStrategy") IOService ioService,
SessionInfo sessionInfo,
Event<ResourceOpenedEvent> resourceOpenedEvent,
FieldManager fieldManager,
FormModelHandlerManager modelHandlerManager,
KieModuleService moduleService,
FormDefinitionSerializer formDefinitionSerializer,
ModuleFormFinderService moduleFormFinderService,
DeleteService deleteService,
CommentedOptionFactory commentedOptionFactory,
RenameService renameService,
CopyService copyService); } | FormEditorServiceImpl extends KieService<FormModelerContent> implements FormEditorService { @Override public Path createForm(Path path, String formName, FormModel formModel) { org.uberfire.java.nio.file.Path kiePath = Paths.convert(path).resolve(formName); try { if (ioService.exists(kiePath)) { throw new FileAlreadyExistsException(kiePath.toString()); } FormDefinition form = new FormDefinition(formModel); form.setId(UIDGenerator.generateUID()); form.setName(formName.substring(0, formName.lastIndexOf("."))); form.setLayoutTemplate(new LayoutTemplate()); ioService.write(kiePath, formDefinitionSerializer.serialize(form), commentedOptionFactory.makeCommentedOption("")); return Paths.convert(kiePath); } catch (Exception e) { throw ExceptionUtilities.handleException(e); } } @Inject FormEditorServiceImpl(@Named("ioStrategy") IOService ioService,
SessionInfo sessionInfo,
Event<ResourceOpenedEvent> resourceOpenedEvent,
FieldManager fieldManager,
FormModelHandlerManager modelHandlerManager,
KieModuleService moduleService,
FormDefinitionSerializer formDefinitionSerializer,
ModuleFormFinderService moduleFormFinderService,
DeleteService deleteService,
CommentedOptionFactory commentedOptionFactory,
RenameService renameService,
CopyService copyService); @Override FormModelerContent loadContent(Path path); @Override Path createForm(Path path,
String formName,
FormModel formModel); @Override void delete(Path path,
String comment); @Override Path save(Path path,
FormModelerContent content,
Metadata metadata,
String comment); @Override FormModelerContent rename(Path path,
String newFileName,
String commitMessage,
boolean saveBeforeRenaming,
FormModelerContent content,
Metadata metadata); @Override void copy(Path path,
String newFileName,
String commitMessage,
boolean saveBeforeCopying,
FormModelerContent content,
Metadata metadata); } | FormEditorServiceImpl extends KieService<FormModelerContent> implements FormEditorService { @Override public Path createForm(Path path, String formName, FormModel formModel) { org.uberfire.java.nio.file.Path kiePath = Paths.convert(path).resolve(formName); try { if (ioService.exists(kiePath)) { throw new FileAlreadyExistsException(kiePath.toString()); } FormDefinition form = new FormDefinition(formModel); form.setId(UIDGenerator.generateUID()); form.setName(formName.substring(0, formName.lastIndexOf("."))); form.setLayoutTemplate(new LayoutTemplate()); ioService.write(kiePath, formDefinitionSerializer.serialize(form), commentedOptionFactory.makeCommentedOption("")); return Paths.convert(kiePath); } catch (Exception e) { throw ExceptionUtilities.handleException(e); } } @Inject FormEditorServiceImpl(@Named("ioStrategy") IOService ioService,
SessionInfo sessionInfo,
Event<ResourceOpenedEvent> resourceOpenedEvent,
FieldManager fieldManager,
FormModelHandlerManager modelHandlerManager,
KieModuleService moduleService,
FormDefinitionSerializer formDefinitionSerializer,
ModuleFormFinderService moduleFormFinderService,
DeleteService deleteService,
CommentedOptionFactory commentedOptionFactory,
RenameService renameService,
CopyService copyService); @Override FormModelerContent loadContent(Path path); @Override Path createForm(Path path,
String formName,
FormModel formModel); @Override void delete(Path path,
String comment); @Override Path save(Path path,
FormModelerContent content,
Metadata metadata,
String comment); @Override FormModelerContent rename(Path path,
String newFileName,
String commitMessage,
boolean saveBeforeRenaming,
FormModelerContent content,
Metadata metadata); @Override void copy(Path path,
String newFileName,
String commitMessage,
boolean saveBeforeCopying,
FormModelerContent content,
Metadata metadata); static final String SHORT_KEY; static final String LONG_KEY; } |
@Test public void testPrepare() { assertThat(line.prepare(context, attributes, 1.0)).isTrue(); verify(context).beginPath(); verify(context).moveTo(eq(0.0), eq(0.0)); verify(context).lineTo(eq(WIDTH), eq(0.0)); } | @Override protected boolean prepare(final Context2D context, final Attributes attr, final double alpha) { context.beginPath(); context.moveTo(0.0, 0.0); context.lineTo(dynamicWidthSupplier.get(), 0.0); return true; } | DecisionServiceDividerLine extends Line { @Override protected boolean prepare(final Context2D context, final Attributes attr, final double alpha) { context.beginPath(); context.moveTo(0.0, 0.0); context.lineTo(dynamicWidthSupplier.get(), 0.0); return true; } } | DecisionServiceDividerLine extends Line { @Override protected boolean prepare(final Context2D context, final Attributes attr, final double alpha) { context.beginPath(); context.moveTo(0.0, 0.0); context.lineTo(dynamicWidthSupplier.get(), 0.0); return true; } DecisionServiceDividerLine(final Supplier<Double> dynamicWidthSupplier); } | DecisionServiceDividerLine extends Line { @Override protected boolean prepare(final Context2D context, final Attributes attr, final double alpha) { context.beginPath(); context.moveTo(0.0, 0.0); context.lineTo(dynamicWidthSupplier.get(), 0.0); return true; } DecisionServiceDividerLine(final Supplier<Double> dynamicWidthSupplier); } | DecisionServiceDividerLine extends Line { @Override protected boolean prepare(final Context2D context, final Attributes attr, final double alpha) { context.beginPath(); context.moveTo(0.0, 0.0); context.lineTo(dynamicWidthSupplier.get(), 0.0); return true; } DecisionServiceDividerLine(final Supplier<Double> dynamicWidthSupplier); } |
@Test public void testConstructContent() throws IOException, SourceFormModelNotFoundException { String formContent = IOUtils.toString(new InputStreamReader(this.getClass().getResourceAsStream("test.frm"))); when(ioService.readAllString(any())).thenReturn(formContent); FormModelerContent content = formEditorService.constructContent(path, overview); verify(modelHandlerManager).getFormModelHandler(any()); verify(dataObjectFormModelHandler).init(any(), any()); verify(dataObjectFormModelHandler).checkSourceModel(); verify(dataObjectFormModelHandler).synchronizeFormModel(); verify(resourceOpenedEvent).fire(any()); assertNotNull(content); assertNull(content.getError()); assertEquals(RenderMode.READ_ONLY_MODE, content.getRenderingContext().getRenderMode()); } | @Override protected FormModelerContent constructContent(Path path, Overview overview) { FormModelerContent formModelConent = new FormModelerContent(); try { org.uberfire.java.nio.file.Path kiePath = Paths.convert(path); FormDefinition form = findForm(kiePath); formModelConent.setDefinition(form); formModelConent.setPath(path); formModelConent.setOverview(overview); FormEditorRenderingContext context = createRenderingContext(form, path); formModelConent.setRenderingContext(context); if (Optional.ofNullable(form.getModel()).isPresent()) { FormModel formModel = form.getModel(); Optional<FormModelHandler> modelHandlerOptional = getHandlerForForm(form); if (modelHandlerOptional.isPresent()) { try { FormModelHandler formModelHandler = modelHandlerOptional.get(); formModelHandler.init(formModel, path); formModelHandler.checkSourceModel(); FormModelSynchronizationResult synchronizationResult = formModelHandler.synchronizeFormModel(); formModel.getProperties().forEach(property -> { Optional<FieldDefinition> fieldOptional = Optional.ofNullable(form.getFieldByBinding(property.getName())); if (!fieldOptional.isPresent()) { synchronizationResult.resolveConflict(property.getName()); } }); formModelConent.setSynchronizationResult(synchronizationResult); } catch (SourceFormModelNotFoundException ex) { formModelConent.setError(new FormModelerContentError(ex.getShortKey(), ex.getShortKeyParams(), ex.getLongKey(), ex.getLongKeyParams(), ex.getModelSourceKey())); } } } } catch (Exception e) { StringWriter writer = new StringWriter(); e.printStackTrace(new PrintWriter(writer)); formModelConent.setError(new FormModelerContentError(SHORT_KEY, null, LONG_KEY, new String[] {writer.toString()}, null)); log.warn("Error loading form " + path.toURI(), e); } resourceOpenedEvent.fire(new ResourceOpenedEvent(path, sessionInfo)); return formModelConent; } | FormEditorServiceImpl extends KieService<FormModelerContent> implements FormEditorService { @Override protected FormModelerContent constructContent(Path path, Overview overview) { FormModelerContent formModelConent = new FormModelerContent(); try { org.uberfire.java.nio.file.Path kiePath = Paths.convert(path); FormDefinition form = findForm(kiePath); formModelConent.setDefinition(form); formModelConent.setPath(path); formModelConent.setOverview(overview); FormEditorRenderingContext context = createRenderingContext(form, path); formModelConent.setRenderingContext(context); if (Optional.ofNullable(form.getModel()).isPresent()) { FormModel formModel = form.getModel(); Optional<FormModelHandler> modelHandlerOptional = getHandlerForForm(form); if (modelHandlerOptional.isPresent()) { try { FormModelHandler formModelHandler = modelHandlerOptional.get(); formModelHandler.init(formModel, path); formModelHandler.checkSourceModel(); FormModelSynchronizationResult synchronizationResult = formModelHandler.synchronizeFormModel(); formModel.getProperties().forEach(property -> { Optional<FieldDefinition> fieldOptional = Optional.ofNullable(form.getFieldByBinding(property.getName())); if (!fieldOptional.isPresent()) { synchronizationResult.resolveConflict(property.getName()); } }); formModelConent.setSynchronizationResult(synchronizationResult); } catch (SourceFormModelNotFoundException ex) { formModelConent.setError(new FormModelerContentError(ex.getShortKey(), ex.getShortKeyParams(), ex.getLongKey(), ex.getLongKeyParams(), ex.getModelSourceKey())); } } } } catch (Exception e) { StringWriter writer = new StringWriter(); e.printStackTrace(new PrintWriter(writer)); formModelConent.setError(new FormModelerContentError(SHORT_KEY, null, LONG_KEY, new String[] {writer.toString()}, null)); log.warn("Error loading form " + path.toURI(), e); } resourceOpenedEvent.fire(new ResourceOpenedEvent(path, sessionInfo)); return formModelConent; } } | FormEditorServiceImpl extends KieService<FormModelerContent> implements FormEditorService { @Override protected FormModelerContent constructContent(Path path, Overview overview) { FormModelerContent formModelConent = new FormModelerContent(); try { org.uberfire.java.nio.file.Path kiePath = Paths.convert(path); FormDefinition form = findForm(kiePath); formModelConent.setDefinition(form); formModelConent.setPath(path); formModelConent.setOverview(overview); FormEditorRenderingContext context = createRenderingContext(form, path); formModelConent.setRenderingContext(context); if (Optional.ofNullable(form.getModel()).isPresent()) { FormModel formModel = form.getModel(); Optional<FormModelHandler> modelHandlerOptional = getHandlerForForm(form); if (modelHandlerOptional.isPresent()) { try { FormModelHandler formModelHandler = modelHandlerOptional.get(); formModelHandler.init(formModel, path); formModelHandler.checkSourceModel(); FormModelSynchronizationResult synchronizationResult = formModelHandler.synchronizeFormModel(); formModel.getProperties().forEach(property -> { Optional<FieldDefinition> fieldOptional = Optional.ofNullable(form.getFieldByBinding(property.getName())); if (!fieldOptional.isPresent()) { synchronizationResult.resolveConflict(property.getName()); } }); formModelConent.setSynchronizationResult(synchronizationResult); } catch (SourceFormModelNotFoundException ex) { formModelConent.setError(new FormModelerContentError(ex.getShortKey(), ex.getShortKeyParams(), ex.getLongKey(), ex.getLongKeyParams(), ex.getModelSourceKey())); } } } } catch (Exception e) { StringWriter writer = new StringWriter(); e.printStackTrace(new PrintWriter(writer)); formModelConent.setError(new FormModelerContentError(SHORT_KEY, null, LONG_KEY, new String[] {writer.toString()}, null)); log.warn("Error loading form " + path.toURI(), e); } resourceOpenedEvent.fire(new ResourceOpenedEvent(path, sessionInfo)); return formModelConent; } @Inject FormEditorServiceImpl(@Named("ioStrategy") IOService ioService,
SessionInfo sessionInfo,
Event<ResourceOpenedEvent> resourceOpenedEvent,
FieldManager fieldManager,
FormModelHandlerManager modelHandlerManager,
KieModuleService moduleService,
FormDefinitionSerializer formDefinitionSerializer,
ModuleFormFinderService moduleFormFinderService,
DeleteService deleteService,
CommentedOptionFactory commentedOptionFactory,
RenameService renameService,
CopyService copyService); } | FormEditorServiceImpl extends KieService<FormModelerContent> implements FormEditorService { @Override protected FormModelerContent constructContent(Path path, Overview overview) { FormModelerContent formModelConent = new FormModelerContent(); try { org.uberfire.java.nio.file.Path kiePath = Paths.convert(path); FormDefinition form = findForm(kiePath); formModelConent.setDefinition(form); formModelConent.setPath(path); formModelConent.setOverview(overview); FormEditorRenderingContext context = createRenderingContext(form, path); formModelConent.setRenderingContext(context); if (Optional.ofNullable(form.getModel()).isPresent()) { FormModel formModel = form.getModel(); Optional<FormModelHandler> modelHandlerOptional = getHandlerForForm(form); if (modelHandlerOptional.isPresent()) { try { FormModelHandler formModelHandler = modelHandlerOptional.get(); formModelHandler.init(formModel, path); formModelHandler.checkSourceModel(); FormModelSynchronizationResult synchronizationResult = formModelHandler.synchronizeFormModel(); formModel.getProperties().forEach(property -> { Optional<FieldDefinition> fieldOptional = Optional.ofNullable(form.getFieldByBinding(property.getName())); if (!fieldOptional.isPresent()) { synchronizationResult.resolveConflict(property.getName()); } }); formModelConent.setSynchronizationResult(synchronizationResult); } catch (SourceFormModelNotFoundException ex) { formModelConent.setError(new FormModelerContentError(ex.getShortKey(), ex.getShortKeyParams(), ex.getLongKey(), ex.getLongKeyParams(), ex.getModelSourceKey())); } } } } catch (Exception e) { StringWriter writer = new StringWriter(); e.printStackTrace(new PrintWriter(writer)); formModelConent.setError(new FormModelerContentError(SHORT_KEY, null, LONG_KEY, new String[] {writer.toString()}, null)); log.warn("Error loading form " + path.toURI(), e); } resourceOpenedEvent.fire(new ResourceOpenedEvent(path, sessionInfo)); return formModelConent; } @Inject FormEditorServiceImpl(@Named("ioStrategy") IOService ioService,
SessionInfo sessionInfo,
Event<ResourceOpenedEvent> resourceOpenedEvent,
FieldManager fieldManager,
FormModelHandlerManager modelHandlerManager,
KieModuleService moduleService,
FormDefinitionSerializer formDefinitionSerializer,
ModuleFormFinderService moduleFormFinderService,
DeleteService deleteService,
CommentedOptionFactory commentedOptionFactory,
RenameService renameService,
CopyService copyService); @Override FormModelerContent loadContent(Path path); @Override Path createForm(Path path,
String formName,
FormModel formModel); @Override void delete(Path path,
String comment); @Override Path save(Path path,
FormModelerContent content,
Metadata metadata,
String comment); @Override FormModelerContent rename(Path path,
String newFileName,
String commitMessage,
boolean saveBeforeRenaming,
FormModelerContent content,
Metadata metadata); @Override void copy(Path path,
String newFileName,
String commitMessage,
boolean saveBeforeCopying,
FormModelerContent content,
Metadata metadata); } | FormEditorServiceImpl extends KieService<FormModelerContent> implements FormEditorService { @Override protected FormModelerContent constructContent(Path path, Overview overview) { FormModelerContent formModelConent = new FormModelerContent(); try { org.uberfire.java.nio.file.Path kiePath = Paths.convert(path); FormDefinition form = findForm(kiePath); formModelConent.setDefinition(form); formModelConent.setPath(path); formModelConent.setOverview(overview); FormEditorRenderingContext context = createRenderingContext(form, path); formModelConent.setRenderingContext(context); if (Optional.ofNullable(form.getModel()).isPresent()) { FormModel formModel = form.getModel(); Optional<FormModelHandler> modelHandlerOptional = getHandlerForForm(form); if (modelHandlerOptional.isPresent()) { try { FormModelHandler formModelHandler = modelHandlerOptional.get(); formModelHandler.init(formModel, path); formModelHandler.checkSourceModel(); FormModelSynchronizationResult synchronizationResult = formModelHandler.synchronizeFormModel(); formModel.getProperties().forEach(property -> { Optional<FieldDefinition> fieldOptional = Optional.ofNullable(form.getFieldByBinding(property.getName())); if (!fieldOptional.isPresent()) { synchronizationResult.resolveConflict(property.getName()); } }); formModelConent.setSynchronizationResult(synchronizationResult); } catch (SourceFormModelNotFoundException ex) { formModelConent.setError(new FormModelerContentError(ex.getShortKey(), ex.getShortKeyParams(), ex.getLongKey(), ex.getLongKeyParams(), ex.getModelSourceKey())); } } } } catch (Exception e) { StringWriter writer = new StringWriter(); e.printStackTrace(new PrintWriter(writer)); formModelConent.setError(new FormModelerContentError(SHORT_KEY, null, LONG_KEY, new String[] {writer.toString()}, null)); log.warn("Error loading form " + path.toURI(), e); } resourceOpenedEvent.fire(new ResourceOpenedEvent(path, sessionInfo)); return formModelConent; } @Inject FormEditorServiceImpl(@Named("ioStrategy") IOService ioService,
SessionInfo sessionInfo,
Event<ResourceOpenedEvent> resourceOpenedEvent,
FieldManager fieldManager,
FormModelHandlerManager modelHandlerManager,
KieModuleService moduleService,
FormDefinitionSerializer formDefinitionSerializer,
ModuleFormFinderService moduleFormFinderService,
DeleteService deleteService,
CommentedOptionFactory commentedOptionFactory,
RenameService renameService,
CopyService copyService); @Override FormModelerContent loadContent(Path path); @Override Path createForm(Path path,
String formName,
FormModel formModel); @Override void delete(Path path,
String comment); @Override Path save(Path path,
FormModelerContent content,
Metadata metadata,
String comment); @Override FormModelerContent rename(Path path,
String newFileName,
String commitMessage,
boolean saveBeforeRenaming,
FormModelerContent content,
Metadata metadata); @Override void copy(Path path,
String newFileName,
String commitMessage,
boolean saveBeforeCopying,
FormModelerContent content,
Metadata metadata); static final String SHORT_KEY; static final String LONG_KEY; } |
@Test public void testConstructContentWithCheckModelFailure() throws IOException, SourceFormModelNotFoundException { SourceFormModelNotFoundException exception = new SourceFormModelNotFoundException("exception", null, "exception", null, "model", null); doThrow(exception) .when(dataObjectFormModelHandler).checkSourceModel(); String formContent = IOUtils.toString(new InputStreamReader(this.getClass().getResourceAsStream("test.frm"))); when(ioService.readAllString(any())).thenReturn(formContent); FormModelerContent content = formEditorService.constructContent(path, overview); verify(modelHandlerManager).getFormModelHandler(any()); verify(dataObjectFormModelHandler).init(any(), any()); verify(dataObjectFormModelHandler).checkSourceModel(); verify(dataObjectFormModelHandler, never()).synchronizeFormModel(); verify(resourceOpenedEvent).fire(any()); assertNotNull(content); assertNotNull(content.getError()); assertEquals(exception.getShortKey(), content.getError().getShortKey()); assertArrayEquals(exception.getShortKeyParams(), content.getError().getShortKeyParams()); assertEquals(exception.getLongKey(), content.getError().getLongKey()); assertArrayEquals(exception.getLongKeyParams(), content.getError().getLongKeyParams()); } | @Override protected FormModelerContent constructContent(Path path, Overview overview) { FormModelerContent formModelConent = new FormModelerContent(); try { org.uberfire.java.nio.file.Path kiePath = Paths.convert(path); FormDefinition form = findForm(kiePath); formModelConent.setDefinition(form); formModelConent.setPath(path); formModelConent.setOverview(overview); FormEditorRenderingContext context = createRenderingContext(form, path); formModelConent.setRenderingContext(context); if (Optional.ofNullable(form.getModel()).isPresent()) { FormModel formModel = form.getModel(); Optional<FormModelHandler> modelHandlerOptional = getHandlerForForm(form); if (modelHandlerOptional.isPresent()) { try { FormModelHandler formModelHandler = modelHandlerOptional.get(); formModelHandler.init(formModel, path); formModelHandler.checkSourceModel(); FormModelSynchronizationResult synchronizationResult = formModelHandler.synchronizeFormModel(); formModel.getProperties().forEach(property -> { Optional<FieldDefinition> fieldOptional = Optional.ofNullable(form.getFieldByBinding(property.getName())); if (!fieldOptional.isPresent()) { synchronizationResult.resolveConflict(property.getName()); } }); formModelConent.setSynchronizationResult(synchronizationResult); } catch (SourceFormModelNotFoundException ex) { formModelConent.setError(new FormModelerContentError(ex.getShortKey(), ex.getShortKeyParams(), ex.getLongKey(), ex.getLongKeyParams(), ex.getModelSourceKey())); } } } } catch (Exception e) { StringWriter writer = new StringWriter(); e.printStackTrace(new PrintWriter(writer)); formModelConent.setError(new FormModelerContentError(SHORT_KEY, null, LONG_KEY, new String[] {writer.toString()}, null)); log.warn("Error loading form " + path.toURI(), e); } resourceOpenedEvent.fire(new ResourceOpenedEvent(path, sessionInfo)); return formModelConent; } | FormEditorServiceImpl extends KieService<FormModelerContent> implements FormEditorService { @Override protected FormModelerContent constructContent(Path path, Overview overview) { FormModelerContent formModelConent = new FormModelerContent(); try { org.uberfire.java.nio.file.Path kiePath = Paths.convert(path); FormDefinition form = findForm(kiePath); formModelConent.setDefinition(form); formModelConent.setPath(path); formModelConent.setOverview(overview); FormEditorRenderingContext context = createRenderingContext(form, path); formModelConent.setRenderingContext(context); if (Optional.ofNullable(form.getModel()).isPresent()) { FormModel formModel = form.getModel(); Optional<FormModelHandler> modelHandlerOptional = getHandlerForForm(form); if (modelHandlerOptional.isPresent()) { try { FormModelHandler formModelHandler = modelHandlerOptional.get(); formModelHandler.init(formModel, path); formModelHandler.checkSourceModel(); FormModelSynchronizationResult synchronizationResult = formModelHandler.synchronizeFormModel(); formModel.getProperties().forEach(property -> { Optional<FieldDefinition> fieldOptional = Optional.ofNullable(form.getFieldByBinding(property.getName())); if (!fieldOptional.isPresent()) { synchronizationResult.resolveConflict(property.getName()); } }); formModelConent.setSynchronizationResult(synchronizationResult); } catch (SourceFormModelNotFoundException ex) { formModelConent.setError(new FormModelerContentError(ex.getShortKey(), ex.getShortKeyParams(), ex.getLongKey(), ex.getLongKeyParams(), ex.getModelSourceKey())); } } } } catch (Exception e) { StringWriter writer = new StringWriter(); e.printStackTrace(new PrintWriter(writer)); formModelConent.setError(new FormModelerContentError(SHORT_KEY, null, LONG_KEY, new String[] {writer.toString()}, null)); log.warn("Error loading form " + path.toURI(), e); } resourceOpenedEvent.fire(new ResourceOpenedEvent(path, sessionInfo)); return formModelConent; } } | FormEditorServiceImpl extends KieService<FormModelerContent> implements FormEditorService { @Override protected FormModelerContent constructContent(Path path, Overview overview) { FormModelerContent formModelConent = new FormModelerContent(); try { org.uberfire.java.nio.file.Path kiePath = Paths.convert(path); FormDefinition form = findForm(kiePath); formModelConent.setDefinition(form); formModelConent.setPath(path); formModelConent.setOverview(overview); FormEditorRenderingContext context = createRenderingContext(form, path); formModelConent.setRenderingContext(context); if (Optional.ofNullable(form.getModel()).isPresent()) { FormModel formModel = form.getModel(); Optional<FormModelHandler> modelHandlerOptional = getHandlerForForm(form); if (modelHandlerOptional.isPresent()) { try { FormModelHandler formModelHandler = modelHandlerOptional.get(); formModelHandler.init(formModel, path); formModelHandler.checkSourceModel(); FormModelSynchronizationResult synchronizationResult = formModelHandler.synchronizeFormModel(); formModel.getProperties().forEach(property -> { Optional<FieldDefinition> fieldOptional = Optional.ofNullable(form.getFieldByBinding(property.getName())); if (!fieldOptional.isPresent()) { synchronizationResult.resolveConflict(property.getName()); } }); formModelConent.setSynchronizationResult(synchronizationResult); } catch (SourceFormModelNotFoundException ex) { formModelConent.setError(new FormModelerContentError(ex.getShortKey(), ex.getShortKeyParams(), ex.getLongKey(), ex.getLongKeyParams(), ex.getModelSourceKey())); } } } } catch (Exception e) { StringWriter writer = new StringWriter(); e.printStackTrace(new PrintWriter(writer)); formModelConent.setError(new FormModelerContentError(SHORT_KEY, null, LONG_KEY, new String[] {writer.toString()}, null)); log.warn("Error loading form " + path.toURI(), e); } resourceOpenedEvent.fire(new ResourceOpenedEvent(path, sessionInfo)); return formModelConent; } @Inject FormEditorServiceImpl(@Named("ioStrategy") IOService ioService,
SessionInfo sessionInfo,
Event<ResourceOpenedEvent> resourceOpenedEvent,
FieldManager fieldManager,
FormModelHandlerManager modelHandlerManager,
KieModuleService moduleService,
FormDefinitionSerializer formDefinitionSerializer,
ModuleFormFinderService moduleFormFinderService,
DeleteService deleteService,
CommentedOptionFactory commentedOptionFactory,
RenameService renameService,
CopyService copyService); } | FormEditorServiceImpl extends KieService<FormModelerContent> implements FormEditorService { @Override protected FormModelerContent constructContent(Path path, Overview overview) { FormModelerContent formModelConent = new FormModelerContent(); try { org.uberfire.java.nio.file.Path kiePath = Paths.convert(path); FormDefinition form = findForm(kiePath); formModelConent.setDefinition(form); formModelConent.setPath(path); formModelConent.setOverview(overview); FormEditorRenderingContext context = createRenderingContext(form, path); formModelConent.setRenderingContext(context); if (Optional.ofNullable(form.getModel()).isPresent()) { FormModel formModel = form.getModel(); Optional<FormModelHandler> modelHandlerOptional = getHandlerForForm(form); if (modelHandlerOptional.isPresent()) { try { FormModelHandler formModelHandler = modelHandlerOptional.get(); formModelHandler.init(formModel, path); formModelHandler.checkSourceModel(); FormModelSynchronizationResult synchronizationResult = formModelHandler.synchronizeFormModel(); formModel.getProperties().forEach(property -> { Optional<FieldDefinition> fieldOptional = Optional.ofNullable(form.getFieldByBinding(property.getName())); if (!fieldOptional.isPresent()) { synchronizationResult.resolveConflict(property.getName()); } }); formModelConent.setSynchronizationResult(synchronizationResult); } catch (SourceFormModelNotFoundException ex) { formModelConent.setError(new FormModelerContentError(ex.getShortKey(), ex.getShortKeyParams(), ex.getLongKey(), ex.getLongKeyParams(), ex.getModelSourceKey())); } } } } catch (Exception e) { StringWriter writer = new StringWriter(); e.printStackTrace(new PrintWriter(writer)); formModelConent.setError(new FormModelerContentError(SHORT_KEY, null, LONG_KEY, new String[] {writer.toString()}, null)); log.warn("Error loading form " + path.toURI(), e); } resourceOpenedEvent.fire(new ResourceOpenedEvent(path, sessionInfo)); return formModelConent; } @Inject FormEditorServiceImpl(@Named("ioStrategy") IOService ioService,
SessionInfo sessionInfo,
Event<ResourceOpenedEvent> resourceOpenedEvent,
FieldManager fieldManager,
FormModelHandlerManager modelHandlerManager,
KieModuleService moduleService,
FormDefinitionSerializer formDefinitionSerializer,
ModuleFormFinderService moduleFormFinderService,
DeleteService deleteService,
CommentedOptionFactory commentedOptionFactory,
RenameService renameService,
CopyService copyService); @Override FormModelerContent loadContent(Path path); @Override Path createForm(Path path,
String formName,
FormModel formModel); @Override void delete(Path path,
String comment); @Override Path save(Path path,
FormModelerContent content,
Metadata metadata,
String comment); @Override FormModelerContent rename(Path path,
String newFileName,
String commitMessage,
boolean saveBeforeRenaming,
FormModelerContent content,
Metadata metadata); @Override void copy(Path path,
String newFileName,
String commitMessage,
boolean saveBeforeCopying,
FormModelerContent content,
Metadata metadata); } | FormEditorServiceImpl extends KieService<FormModelerContent> implements FormEditorService { @Override protected FormModelerContent constructContent(Path path, Overview overview) { FormModelerContent formModelConent = new FormModelerContent(); try { org.uberfire.java.nio.file.Path kiePath = Paths.convert(path); FormDefinition form = findForm(kiePath); formModelConent.setDefinition(form); formModelConent.setPath(path); formModelConent.setOverview(overview); FormEditorRenderingContext context = createRenderingContext(form, path); formModelConent.setRenderingContext(context); if (Optional.ofNullable(form.getModel()).isPresent()) { FormModel formModel = form.getModel(); Optional<FormModelHandler> modelHandlerOptional = getHandlerForForm(form); if (modelHandlerOptional.isPresent()) { try { FormModelHandler formModelHandler = modelHandlerOptional.get(); formModelHandler.init(formModel, path); formModelHandler.checkSourceModel(); FormModelSynchronizationResult synchronizationResult = formModelHandler.synchronizeFormModel(); formModel.getProperties().forEach(property -> { Optional<FieldDefinition> fieldOptional = Optional.ofNullable(form.getFieldByBinding(property.getName())); if (!fieldOptional.isPresent()) { synchronizationResult.resolveConflict(property.getName()); } }); formModelConent.setSynchronizationResult(synchronizationResult); } catch (SourceFormModelNotFoundException ex) { formModelConent.setError(new FormModelerContentError(ex.getShortKey(), ex.getShortKeyParams(), ex.getLongKey(), ex.getLongKeyParams(), ex.getModelSourceKey())); } } } } catch (Exception e) { StringWriter writer = new StringWriter(); e.printStackTrace(new PrintWriter(writer)); formModelConent.setError(new FormModelerContentError(SHORT_KEY, null, LONG_KEY, new String[] {writer.toString()}, null)); log.warn("Error loading form " + path.toURI(), e); } resourceOpenedEvent.fire(new ResourceOpenedEvent(path, sessionInfo)); return formModelConent; } @Inject FormEditorServiceImpl(@Named("ioStrategy") IOService ioService,
SessionInfo sessionInfo,
Event<ResourceOpenedEvent> resourceOpenedEvent,
FieldManager fieldManager,
FormModelHandlerManager modelHandlerManager,
KieModuleService moduleService,
FormDefinitionSerializer formDefinitionSerializer,
ModuleFormFinderService moduleFormFinderService,
DeleteService deleteService,
CommentedOptionFactory commentedOptionFactory,
RenameService renameService,
CopyService copyService); @Override FormModelerContent loadContent(Path path); @Override Path createForm(Path path,
String formName,
FormModel formModel); @Override void delete(Path path,
String comment); @Override Path save(Path path,
FormModelerContent content,
Metadata metadata,
String comment); @Override FormModelerContent rename(Path path,
String newFileName,
String commitMessage,
boolean saveBeforeRenaming,
FormModelerContent content,
Metadata metadata); @Override void copy(Path path,
String newFileName,
String commitMessage,
boolean saveBeforeCopying,
FormModelerContent content,
Metadata metadata); static final String SHORT_KEY; static final String LONG_KEY; } |
@Test public void testConstructContentWithUnexpectedFailure() { FormModelerContent content = formEditorService.constructContent(path, overview); verify(modelHandlerManager, never()).getFormModelHandler(any()); verify(resourceOpenedEvent).fire(any()); assertNotNull(content); assertNotNull(content.getError()); } | @Override protected FormModelerContent constructContent(Path path, Overview overview) { FormModelerContent formModelConent = new FormModelerContent(); try { org.uberfire.java.nio.file.Path kiePath = Paths.convert(path); FormDefinition form = findForm(kiePath); formModelConent.setDefinition(form); formModelConent.setPath(path); formModelConent.setOverview(overview); FormEditorRenderingContext context = createRenderingContext(form, path); formModelConent.setRenderingContext(context); if (Optional.ofNullable(form.getModel()).isPresent()) { FormModel formModel = form.getModel(); Optional<FormModelHandler> modelHandlerOptional = getHandlerForForm(form); if (modelHandlerOptional.isPresent()) { try { FormModelHandler formModelHandler = modelHandlerOptional.get(); formModelHandler.init(formModel, path); formModelHandler.checkSourceModel(); FormModelSynchronizationResult synchronizationResult = formModelHandler.synchronizeFormModel(); formModel.getProperties().forEach(property -> { Optional<FieldDefinition> fieldOptional = Optional.ofNullable(form.getFieldByBinding(property.getName())); if (!fieldOptional.isPresent()) { synchronizationResult.resolveConflict(property.getName()); } }); formModelConent.setSynchronizationResult(synchronizationResult); } catch (SourceFormModelNotFoundException ex) { formModelConent.setError(new FormModelerContentError(ex.getShortKey(), ex.getShortKeyParams(), ex.getLongKey(), ex.getLongKeyParams(), ex.getModelSourceKey())); } } } } catch (Exception e) { StringWriter writer = new StringWriter(); e.printStackTrace(new PrintWriter(writer)); formModelConent.setError(new FormModelerContentError(SHORT_KEY, null, LONG_KEY, new String[] {writer.toString()}, null)); log.warn("Error loading form " + path.toURI(), e); } resourceOpenedEvent.fire(new ResourceOpenedEvent(path, sessionInfo)); return formModelConent; } | FormEditorServiceImpl extends KieService<FormModelerContent> implements FormEditorService { @Override protected FormModelerContent constructContent(Path path, Overview overview) { FormModelerContent formModelConent = new FormModelerContent(); try { org.uberfire.java.nio.file.Path kiePath = Paths.convert(path); FormDefinition form = findForm(kiePath); formModelConent.setDefinition(form); formModelConent.setPath(path); formModelConent.setOverview(overview); FormEditorRenderingContext context = createRenderingContext(form, path); formModelConent.setRenderingContext(context); if (Optional.ofNullable(form.getModel()).isPresent()) { FormModel formModel = form.getModel(); Optional<FormModelHandler> modelHandlerOptional = getHandlerForForm(form); if (modelHandlerOptional.isPresent()) { try { FormModelHandler formModelHandler = modelHandlerOptional.get(); formModelHandler.init(formModel, path); formModelHandler.checkSourceModel(); FormModelSynchronizationResult synchronizationResult = formModelHandler.synchronizeFormModel(); formModel.getProperties().forEach(property -> { Optional<FieldDefinition> fieldOptional = Optional.ofNullable(form.getFieldByBinding(property.getName())); if (!fieldOptional.isPresent()) { synchronizationResult.resolveConflict(property.getName()); } }); formModelConent.setSynchronizationResult(synchronizationResult); } catch (SourceFormModelNotFoundException ex) { formModelConent.setError(new FormModelerContentError(ex.getShortKey(), ex.getShortKeyParams(), ex.getLongKey(), ex.getLongKeyParams(), ex.getModelSourceKey())); } } } } catch (Exception e) { StringWriter writer = new StringWriter(); e.printStackTrace(new PrintWriter(writer)); formModelConent.setError(new FormModelerContentError(SHORT_KEY, null, LONG_KEY, new String[] {writer.toString()}, null)); log.warn("Error loading form " + path.toURI(), e); } resourceOpenedEvent.fire(new ResourceOpenedEvent(path, sessionInfo)); return formModelConent; } } | FormEditorServiceImpl extends KieService<FormModelerContent> implements FormEditorService { @Override protected FormModelerContent constructContent(Path path, Overview overview) { FormModelerContent formModelConent = new FormModelerContent(); try { org.uberfire.java.nio.file.Path kiePath = Paths.convert(path); FormDefinition form = findForm(kiePath); formModelConent.setDefinition(form); formModelConent.setPath(path); formModelConent.setOverview(overview); FormEditorRenderingContext context = createRenderingContext(form, path); formModelConent.setRenderingContext(context); if (Optional.ofNullable(form.getModel()).isPresent()) { FormModel formModel = form.getModel(); Optional<FormModelHandler> modelHandlerOptional = getHandlerForForm(form); if (modelHandlerOptional.isPresent()) { try { FormModelHandler formModelHandler = modelHandlerOptional.get(); formModelHandler.init(formModel, path); formModelHandler.checkSourceModel(); FormModelSynchronizationResult synchronizationResult = formModelHandler.synchronizeFormModel(); formModel.getProperties().forEach(property -> { Optional<FieldDefinition> fieldOptional = Optional.ofNullable(form.getFieldByBinding(property.getName())); if (!fieldOptional.isPresent()) { synchronizationResult.resolveConflict(property.getName()); } }); formModelConent.setSynchronizationResult(synchronizationResult); } catch (SourceFormModelNotFoundException ex) { formModelConent.setError(new FormModelerContentError(ex.getShortKey(), ex.getShortKeyParams(), ex.getLongKey(), ex.getLongKeyParams(), ex.getModelSourceKey())); } } } } catch (Exception e) { StringWriter writer = new StringWriter(); e.printStackTrace(new PrintWriter(writer)); formModelConent.setError(new FormModelerContentError(SHORT_KEY, null, LONG_KEY, new String[] {writer.toString()}, null)); log.warn("Error loading form " + path.toURI(), e); } resourceOpenedEvent.fire(new ResourceOpenedEvent(path, sessionInfo)); return formModelConent; } @Inject FormEditorServiceImpl(@Named("ioStrategy") IOService ioService,
SessionInfo sessionInfo,
Event<ResourceOpenedEvent> resourceOpenedEvent,
FieldManager fieldManager,
FormModelHandlerManager modelHandlerManager,
KieModuleService moduleService,
FormDefinitionSerializer formDefinitionSerializer,
ModuleFormFinderService moduleFormFinderService,
DeleteService deleteService,
CommentedOptionFactory commentedOptionFactory,
RenameService renameService,
CopyService copyService); } | FormEditorServiceImpl extends KieService<FormModelerContent> implements FormEditorService { @Override protected FormModelerContent constructContent(Path path, Overview overview) { FormModelerContent formModelConent = new FormModelerContent(); try { org.uberfire.java.nio.file.Path kiePath = Paths.convert(path); FormDefinition form = findForm(kiePath); formModelConent.setDefinition(form); formModelConent.setPath(path); formModelConent.setOverview(overview); FormEditorRenderingContext context = createRenderingContext(form, path); formModelConent.setRenderingContext(context); if (Optional.ofNullable(form.getModel()).isPresent()) { FormModel formModel = form.getModel(); Optional<FormModelHandler> modelHandlerOptional = getHandlerForForm(form); if (modelHandlerOptional.isPresent()) { try { FormModelHandler formModelHandler = modelHandlerOptional.get(); formModelHandler.init(formModel, path); formModelHandler.checkSourceModel(); FormModelSynchronizationResult synchronizationResult = formModelHandler.synchronizeFormModel(); formModel.getProperties().forEach(property -> { Optional<FieldDefinition> fieldOptional = Optional.ofNullable(form.getFieldByBinding(property.getName())); if (!fieldOptional.isPresent()) { synchronizationResult.resolveConflict(property.getName()); } }); formModelConent.setSynchronizationResult(synchronizationResult); } catch (SourceFormModelNotFoundException ex) { formModelConent.setError(new FormModelerContentError(ex.getShortKey(), ex.getShortKeyParams(), ex.getLongKey(), ex.getLongKeyParams(), ex.getModelSourceKey())); } } } } catch (Exception e) { StringWriter writer = new StringWriter(); e.printStackTrace(new PrintWriter(writer)); formModelConent.setError(new FormModelerContentError(SHORT_KEY, null, LONG_KEY, new String[] {writer.toString()}, null)); log.warn("Error loading form " + path.toURI(), e); } resourceOpenedEvent.fire(new ResourceOpenedEvent(path, sessionInfo)); return formModelConent; } @Inject FormEditorServiceImpl(@Named("ioStrategy") IOService ioService,
SessionInfo sessionInfo,
Event<ResourceOpenedEvent> resourceOpenedEvent,
FieldManager fieldManager,
FormModelHandlerManager modelHandlerManager,
KieModuleService moduleService,
FormDefinitionSerializer formDefinitionSerializer,
ModuleFormFinderService moduleFormFinderService,
DeleteService deleteService,
CommentedOptionFactory commentedOptionFactory,
RenameService renameService,
CopyService copyService); @Override FormModelerContent loadContent(Path path); @Override Path createForm(Path path,
String formName,
FormModel formModel); @Override void delete(Path path,
String comment); @Override Path save(Path path,
FormModelerContent content,
Metadata metadata,
String comment); @Override FormModelerContent rename(Path path,
String newFileName,
String commitMessage,
boolean saveBeforeRenaming,
FormModelerContent content,
Metadata metadata); @Override void copy(Path path,
String newFileName,
String commitMessage,
boolean saveBeforeCopying,
FormModelerContent content,
Metadata metadata); } | FormEditorServiceImpl extends KieService<FormModelerContent> implements FormEditorService { @Override protected FormModelerContent constructContent(Path path, Overview overview) { FormModelerContent formModelConent = new FormModelerContent(); try { org.uberfire.java.nio.file.Path kiePath = Paths.convert(path); FormDefinition form = findForm(kiePath); formModelConent.setDefinition(form); formModelConent.setPath(path); formModelConent.setOverview(overview); FormEditorRenderingContext context = createRenderingContext(form, path); formModelConent.setRenderingContext(context); if (Optional.ofNullable(form.getModel()).isPresent()) { FormModel formModel = form.getModel(); Optional<FormModelHandler> modelHandlerOptional = getHandlerForForm(form); if (modelHandlerOptional.isPresent()) { try { FormModelHandler formModelHandler = modelHandlerOptional.get(); formModelHandler.init(formModel, path); formModelHandler.checkSourceModel(); FormModelSynchronizationResult synchronizationResult = formModelHandler.synchronizeFormModel(); formModel.getProperties().forEach(property -> { Optional<FieldDefinition> fieldOptional = Optional.ofNullable(form.getFieldByBinding(property.getName())); if (!fieldOptional.isPresent()) { synchronizationResult.resolveConflict(property.getName()); } }); formModelConent.setSynchronizationResult(synchronizationResult); } catch (SourceFormModelNotFoundException ex) { formModelConent.setError(new FormModelerContentError(ex.getShortKey(), ex.getShortKeyParams(), ex.getLongKey(), ex.getLongKeyParams(), ex.getModelSourceKey())); } } } } catch (Exception e) { StringWriter writer = new StringWriter(); e.printStackTrace(new PrintWriter(writer)); formModelConent.setError(new FormModelerContentError(SHORT_KEY, null, LONG_KEY, new String[] {writer.toString()}, null)); log.warn("Error loading form " + path.toURI(), e); } resourceOpenedEvent.fire(new ResourceOpenedEvent(path, sessionInfo)); return formModelConent; } @Inject FormEditorServiceImpl(@Named("ioStrategy") IOService ioService,
SessionInfo sessionInfo,
Event<ResourceOpenedEvent> resourceOpenedEvent,
FieldManager fieldManager,
FormModelHandlerManager modelHandlerManager,
KieModuleService moduleService,
FormDefinitionSerializer formDefinitionSerializer,
ModuleFormFinderService moduleFormFinderService,
DeleteService deleteService,
CommentedOptionFactory commentedOptionFactory,
RenameService renameService,
CopyService copyService); @Override FormModelerContent loadContent(Path path); @Override Path createForm(Path path,
String formName,
FormModel formModel); @Override void delete(Path path,
String comment); @Override Path save(Path path,
FormModelerContent content,
Metadata metadata,
String comment); @Override FormModelerContent rename(Path path,
String newFileName,
String commitMessage,
boolean saveBeforeRenaming,
FormModelerContent content,
Metadata metadata); @Override void copy(Path path,
String newFileName,
String commitMessage,
boolean saveBeforeCopying,
FormModelerContent content,
Metadata metadata); static final String SHORT_KEY; static final String LONG_KEY; } |
@Test public void testSupports() { Assertions.assertThat(helper.supports(originalPath)) .isNotNull() .isTrue(); Path wrongPath = mock(Path.class); when(wrongPath.getFileName()).thenReturn("wrongh.path"); Assertions.assertThat(helper.supports(wrongPath)) .isNotNull() .isFalse(); } | public boolean supports(Path path) { return path.getFileName().endsWith("." + FormResourceTypeDefinition.EXTENSION); } | AbstractFormDefinitionHelper { public boolean supports(Path path) { return path.getFileName().endsWith("." + FormResourceTypeDefinition.EXTENSION); } } | AbstractFormDefinitionHelper { public boolean supports(Path path) { return path.getFileName().endsWith("." + FormResourceTypeDefinition.EXTENSION); } AbstractFormDefinitionHelper(FormDefinitionSerializer serializer, IOService ioService, CommentedOptionFactory commentedOptionFactory); } | AbstractFormDefinitionHelper { public boolean supports(Path path) { return path.getFileName().endsWith("." + FormResourceTypeDefinition.EXTENSION); } AbstractFormDefinitionHelper(FormDefinitionSerializer serializer, IOService ioService, CommentedOptionFactory commentedOptionFactory); boolean supports(Path path); void postProcess(Path source, Path destination); } | AbstractFormDefinitionHelper { public boolean supports(Path path) { return path.getFileName().endsWith("." + FormResourceTypeDefinition.EXTENSION); } AbstractFormDefinitionHelper(FormDefinitionSerializer serializer, IOService ioService, CommentedOptionFactory commentedOptionFactory); boolean supports(Path path); void postProcess(Path source, Path destination); } |
@Test public void testPostProcess() { helper.postProcess(originalPath, destinationPath); verify(ioService).readAllString(any()); verify(serializer).deserialize(anyString()); verify(serializer).serialize(eq(formDefinition)); verifyForm(formDefinition); verify(commentedOptionFactory).makeCommentedOption(anyString()); ioService.write(any(), anyString(), any()); } | public void postProcess(Path source, Path destination) { org.uberfire.java.nio.file.Path destinationNioPath = Paths.convert(destination); FormDefinition formDefinition = serializer.deserialize(ioService.readAllString(destinationNioPath)); processFormDefinition(formDefinition, destination); ioService.write(destinationNioPath, serializer.serialize(formDefinition), commentedOptionFactory.makeCommentedOption("Updating form [" + destination.toURI() + "].")); } | AbstractFormDefinitionHelper { public void postProcess(Path source, Path destination) { org.uberfire.java.nio.file.Path destinationNioPath = Paths.convert(destination); FormDefinition formDefinition = serializer.deserialize(ioService.readAllString(destinationNioPath)); processFormDefinition(formDefinition, destination); ioService.write(destinationNioPath, serializer.serialize(formDefinition), commentedOptionFactory.makeCommentedOption("Updating form [" + destination.toURI() + "].")); } } | AbstractFormDefinitionHelper { public void postProcess(Path source, Path destination) { org.uberfire.java.nio.file.Path destinationNioPath = Paths.convert(destination); FormDefinition formDefinition = serializer.deserialize(ioService.readAllString(destinationNioPath)); processFormDefinition(formDefinition, destination); ioService.write(destinationNioPath, serializer.serialize(formDefinition), commentedOptionFactory.makeCommentedOption("Updating form [" + destination.toURI() + "].")); } AbstractFormDefinitionHelper(FormDefinitionSerializer serializer, IOService ioService, CommentedOptionFactory commentedOptionFactory); } | AbstractFormDefinitionHelper { public void postProcess(Path source, Path destination) { org.uberfire.java.nio.file.Path destinationNioPath = Paths.convert(destination); FormDefinition formDefinition = serializer.deserialize(ioService.readAllString(destinationNioPath)); processFormDefinition(formDefinition, destination); ioService.write(destinationNioPath, serializer.serialize(formDefinition), commentedOptionFactory.makeCommentedOption("Updating form [" + destination.toURI() + "].")); } AbstractFormDefinitionHelper(FormDefinitionSerializer serializer, IOService ioService, CommentedOptionFactory commentedOptionFactory); boolean supports(Path path); void postProcess(Path source, Path destination); } | AbstractFormDefinitionHelper { public void postProcess(Path source, Path destination) { org.uberfire.java.nio.file.Path destinationNioPath = Paths.convert(destination); FormDefinition formDefinition = serializer.deserialize(ioService.readAllString(destinationNioPath)); processFormDefinition(formDefinition, destination); ioService.write(destinationNioPath, serializer.serialize(formDefinition), commentedOptionFactory.makeCommentedOption("Updating form [" + destination.toURI() + "].")); } AbstractFormDefinitionHelper(FormDefinitionSerializer serializer, IOService ioService, CommentedOptionFactory commentedOptionFactory); boolean supports(Path path); void postProcess(Path source, Path destination); } |
@Test public void testAssetNameValidationWithFormModelPresenterFailure() { when(formModelsPresenter.isValid()).thenReturn(false); handler.validate(NEW_FORM_NAME, validatorCallback); verify(formModelsPresenter, times(1)).isValid(); verify(validatorCallback, times(1)).onFailure(); } | @Override public void validate(String baseFileName, ValidatorWithReasonCallback callback) { boolean isValid = formModelsPresenter.isValid(); if (!isValid) { callback.onFailure(); } else { super.validate(baseFileName, callback); } } | NewFormDefinitionlHandler extends DefaultNewResourceHandler { @Override public void validate(String baseFileName, ValidatorWithReasonCallback callback) { boolean isValid = formModelsPresenter.isValid(); if (!isValid) { callback.onFailure(); } else { super.validate(baseFileName, callback); } } } | NewFormDefinitionlHandler extends DefaultNewResourceHandler { @Override public void validate(String baseFileName, ValidatorWithReasonCallback callback) { boolean isValid = formModelsPresenter.isValid(); if (!isValid) { callback.onFailure(); } else { super.validate(baseFileName, callback); } } @Inject NewFormDefinitionlHandler(final Caller<FormEditorService> modelerService,
final FormDefinitionResourceType resourceType,
final TranslationService translationService,
final FormModelsPresenter formModelsPresenter,
final WorkspaceProjectContext context,
final Caller<KieModuleService> moduleService,
final Caller<ValidationService> validationService,
final PlaceManager placeManager,
final Event<NotificationEvent> notificationEvent,
final Event<NewResourceSuccessEvent> newResourceSuccessEvent,
final BusyIndicatorView busyIndicatorView); } | NewFormDefinitionlHandler extends DefaultNewResourceHandler { @Override public void validate(String baseFileName, ValidatorWithReasonCallback callback) { boolean isValid = formModelsPresenter.isValid(); if (!isValid) { callback.onFailure(); } else { super.validate(baseFileName, callback); } } @Inject NewFormDefinitionlHandler(final Caller<FormEditorService> modelerService,
final FormDefinitionResourceType resourceType,
final TranslationService translationService,
final FormModelsPresenter formModelsPresenter,
final WorkspaceProjectContext context,
final Caller<KieModuleService> moduleService,
final Caller<ValidationService> validationService,
final PlaceManager placeManager,
final Event<NotificationEvent> notificationEvent,
final Event<NewResourceSuccessEvent> newResourceSuccessEvent,
final BusyIndicatorView busyIndicatorView); @Override String getDescription(); @Override IsWidget getIcon(); @Override ResourceTypeDefinition getResourceType(); @Override List<Pair<String, ? extends IsWidget>> getExtensions(); @Override void validate(String baseFileName,
ValidatorWithReasonCallback callback); @Override void create(final org.guvnor.common.services.project.model.Package pkg,
final String baseFileName,
final NewResourcePresenter presenter); @Override List<Profile> getProfiles(); } | NewFormDefinitionlHandler extends DefaultNewResourceHandler { @Override public void validate(String baseFileName, ValidatorWithReasonCallback callback) { boolean isValid = formModelsPresenter.isValid(); if (!isValid) { callback.onFailure(); } else { super.validate(baseFileName, callback); } } @Inject NewFormDefinitionlHandler(final Caller<FormEditorService> modelerService,
final FormDefinitionResourceType resourceType,
final TranslationService translationService,
final FormModelsPresenter formModelsPresenter,
final WorkspaceProjectContext context,
final Caller<KieModuleService> moduleService,
final Caller<ValidationService> validationService,
final PlaceManager placeManager,
final Event<NotificationEvent> notificationEvent,
final Event<NewResourceSuccessEvent> newResourceSuccessEvent,
final BusyIndicatorView busyIndicatorView); @Override String getDescription(); @Override IsWidget getIcon(); @Override ResourceTypeDefinition getResourceType(); @Override List<Pair<String, ? extends IsWidget>> getExtensions(); @Override void validate(String baseFileName,
ValidatorWithReasonCallback callback); @Override void create(final org.guvnor.common.services.project.model.Package pkg,
final String baseFileName,
final NewResourcePresenter presenter); @Override List<Profile> getProfiles(); } |
@Test public void testAssetNameValidationWithValidationServiceFailure() { when(formModelsPresenter.isValid()).thenReturn(true); when(validationService.isFileNameValid(anyString())).thenReturn(false); handler.validate(NEW_FORM_NAME, validatorCallback); verify(formModelsPresenter, times(1)).isValid(); verify(validatorCallback, times(1)).onFailure(anyString()); } | @Override public void validate(String baseFileName, ValidatorWithReasonCallback callback) { boolean isValid = formModelsPresenter.isValid(); if (!isValid) { callback.onFailure(); } else { super.validate(baseFileName, callback); } } | NewFormDefinitionlHandler extends DefaultNewResourceHandler { @Override public void validate(String baseFileName, ValidatorWithReasonCallback callback) { boolean isValid = formModelsPresenter.isValid(); if (!isValid) { callback.onFailure(); } else { super.validate(baseFileName, callback); } } } | NewFormDefinitionlHandler extends DefaultNewResourceHandler { @Override public void validate(String baseFileName, ValidatorWithReasonCallback callback) { boolean isValid = formModelsPresenter.isValid(); if (!isValid) { callback.onFailure(); } else { super.validate(baseFileName, callback); } } @Inject NewFormDefinitionlHandler(final Caller<FormEditorService> modelerService,
final FormDefinitionResourceType resourceType,
final TranslationService translationService,
final FormModelsPresenter formModelsPresenter,
final WorkspaceProjectContext context,
final Caller<KieModuleService> moduleService,
final Caller<ValidationService> validationService,
final PlaceManager placeManager,
final Event<NotificationEvent> notificationEvent,
final Event<NewResourceSuccessEvent> newResourceSuccessEvent,
final BusyIndicatorView busyIndicatorView); } | NewFormDefinitionlHandler extends DefaultNewResourceHandler { @Override public void validate(String baseFileName, ValidatorWithReasonCallback callback) { boolean isValid = formModelsPresenter.isValid(); if (!isValid) { callback.onFailure(); } else { super.validate(baseFileName, callback); } } @Inject NewFormDefinitionlHandler(final Caller<FormEditorService> modelerService,
final FormDefinitionResourceType resourceType,
final TranslationService translationService,
final FormModelsPresenter formModelsPresenter,
final WorkspaceProjectContext context,
final Caller<KieModuleService> moduleService,
final Caller<ValidationService> validationService,
final PlaceManager placeManager,
final Event<NotificationEvent> notificationEvent,
final Event<NewResourceSuccessEvent> newResourceSuccessEvent,
final BusyIndicatorView busyIndicatorView); @Override String getDescription(); @Override IsWidget getIcon(); @Override ResourceTypeDefinition getResourceType(); @Override List<Pair<String, ? extends IsWidget>> getExtensions(); @Override void validate(String baseFileName,
ValidatorWithReasonCallback callback); @Override void create(final org.guvnor.common.services.project.model.Package pkg,
final String baseFileName,
final NewResourcePresenter presenter); @Override List<Profile> getProfiles(); } | NewFormDefinitionlHandler extends DefaultNewResourceHandler { @Override public void validate(String baseFileName, ValidatorWithReasonCallback callback) { boolean isValid = formModelsPresenter.isValid(); if (!isValid) { callback.onFailure(); } else { super.validate(baseFileName, callback); } } @Inject NewFormDefinitionlHandler(final Caller<FormEditorService> modelerService,
final FormDefinitionResourceType resourceType,
final TranslationService translationService,
final FormModelsPresenter formModelsPresenter,
final WorkspaceProjectContext context,
final Caller<KieModuleService> moduleService,
final Caller<ValidationService> validationService,
final PlaceManager placeManager,
final Event<NotificationEvent> notificationEvent,
final Event<NewResourceSuccessEvent> newResourceSuccessEvent,
final BusyIndicatorView busyIndicatorView); @Override String getDescription(); @Override IsWidget getIcon(); @Override ResourceTypeDefinition getResourceType(); @Override List<Pair<String, ? extends IsWidget>> getExtensions(); @Override void validate(String baseFileName,
ValidatorWithReasonCallback callback); @Override void create(final org.guvnor.common.services.project.model.Package pkg,
final String baseFileName,
final NewResourcePresenter presenter); @Override List<Profile> getProfiles(); } |
@Test public void testAssetNameValidationSuccessful() { when(formModelsPresenter.isValid()).thenReturn(true); when(validationService.isFileNameValid(anyString())).thenReturn(true); handler.validate(NEW_FORM_NAME, validatorCallback); verify(formModelsPresenter, times(1)).isValid(); verify(validatorCallback, times(1)).onSuccess(); } | @Override public void validate(String baseFileName, ValidatorWithReasonCallback callback) { boolean isValid = formModelsPresenter.isValid(); if (!isValid) { callback.onFailure(); } else { super.validate(baseFileName, callback); } } | NewFormDefinitionlHandler extends DefaultNewResourceHandler { @Override public void validate(String baseFileName, ValidatorWithReasonCallback callback) { boolean isValid = formModelsPresenter.isValid(); if (!isValid) { callback.onFailure(); } else { super.validate(baseFileName, callback); } } } | NewFormDefinitionlHandler extends DefaultNewResourceHandler { @Override public void validate(String baseFileName, ValidatorWithReasonCallback callback) { boolean isValid = formModelsPresenter.isValid(); if (!isValid) { callback.onFailure(); } else { super.validate(baseFileName, callback); } } @Inject NewFormDefinitionlHandler(final Caller<FormEditorService> modelerService,
final FormDefinitionResourceType resourceType,
final TranslationService translationService,
final FormModelsPresenter formModelsPresenter,
final WorkspaceProjectContext context,
final Caller<KieModuleService> moduleService,
final Caller<ValidationService> validationService,
final PlaceManager placeManager,
final Event<NotificationEvent> notificationEvent,
final Event<NewResourceSuccessEvent> newResourceSuccessEvent,
final BusyIndicatorView busyIndicatorView); } | NewFormDefinitionlHandler extends DefaultNewResourceHandler { @Override public void validate(String baseFileName, ValidatorWithReasonCallback callback) { boolean isValid = formModelsPresenter.isValid(); if (!isValid) { callback.onFailure(); } else { super.validate(baseFileName, callback); } } @Inject NewFormDefinitionlHandler(final Caller<FormEditorService> modelerService,
final FormDefinitionResourceType resourceType,
final TranslationService translationService,
final FormModelsPresenter formModelsPresenter,
final WorkspaceProjectContext context,
final Caller<KieModuleService> moduleService,
final Caller<ValidationService> validationService,
final PlaceManager placeManager,
final Event<NotificationEvent> notificationEvent,
final Event<NewResourceSuccessEvent> newResourceSuccessEvent,
final BusyIndicatorView busyIndicatorView); @Override String getDescription(); @Override IsWidget getIcon(); @Override ResourceTypeDefinition getResourceType(); @Override List<Pair<String, ? extends IsWidget>> getExtensions(); @Override void validate(String baseFileName,
ValidatorWithReasonCallback callback); @Override void create(final org.guvnor.common.services.project.model.Package pkg,
final String baseFileName,
final NewResourcePresenter presenter); @Override List<Profile> getProfiles(); } | NewFormDefinitionlHandler extends DefaultNewResourceHandler { @Override public void validate(String baseFileName, ValidatorWithReasonCallback callback) { boolean isValid = formModelsPresenter.isValid(); if (!isValid) { callback.onFailure(); } else { super.validate(baseFileName, callback); } } @Inject NewFormDefinitionlHandler(final Caller<FormEditorService> modelerService,
final FormDefinitionResourceType resourceType,
final TranslationService translationService,
final FormModelsPresenter formModelsPresenter,
final WorkspaceProjectContext context,
final Caller<KieModuleService> moduleService,
final Caller<ValidationService> validationService,
final PlaceManager placeManager,
final Event<NotificationEvent> notificationEvent,
final Event<NewResourceSuccessEvent> newResourceSuccessEvent,
final BusyIndicatorView busyIndicatorView); @Override String getDescription(); @Override IsWidget getIcon(); @Override ResourceTypeDefinition getResourceType(); @Override List<Pair<String, ? extends IsWidget>> getExtensions(); @Override void validate(String baseFileName,
ValidatorWithReasonCallback callback); @Override void create(final org.guvnor.common.services.project.model.Package pkg,
final String baseFileName,
final NewResourcePresenter presenter); @Override List<Profile> getProfiles(); } |
@Test public void testSuccessfulCreation() { handler.create(pkg, NEW_FORM_NAME, newResourcePresenter); verify(translationService).getTranslation(FormEditorConstants.NewFormDefinitionlHandlerSelectFormUse); verify(busyIndicatorView).showBusyIndicator(anyString()); verify(busyIndicatorView).hideBusyIndicator(); verify(newResourcePresenter).complete(); verify(notificationEvent).fire(any()); verify(newResourceSuccessEvent).fire(any()); verify(placeManager).goTo(any(Path.class)); } | @Override public void create(final org.guvnor.common.services.project.model.Package pkg, final String baseFileName, final NewResourcePresenter presenter) { busyIndicatorView.showBusyIndicator(translationService.getTranslation(FormEditorConstants.NewFormDefinitionlHandlerSelectFormUse)); modelerService.call(getSuccessCallback(presenter), getErrorCallback()).createForm(pkg.getPackageMainResourcesPath(), buildFileName(baseFileName, resourceType), formModelsPresenter.getFormModel()); } | NewFormDefinitionlHandler extends DefaultNewResourceHandler { @Override public void create(final org.guvnor.common.services.project.model.Package pkg, final String baseFileName, final NewResourcePresenter presenter) { busyIndicatorView.showBusyIndicator(translationService.getTranslation(FormEditorConstants.NewFormDefinitionlHandlerSelectFormUse)); modelerService.call(getSuccessCallback(presenter), getErrorCallback()).createForm(pkg.getPackageMainResourcesPath(), buildFileName(baseFileName, resourceType), formModelsPresenter.getFormModel()); } } | NewFormDefinitionlHandler extends DefaultNewResourceHandler { @Override public void create(final org.guvnor.common.services.project.model.Package pkg, final String baseFileName, final NewResourcePresenter presenter) { busyIndicatorView.showBusyIndicator(translationService.getTranslation(FormEditorConstants.NewFormDefinitionlHandlerSelectFormUse)); modelerService.call(getSuccessCallback(presenter), getErrorCallback()).createForm(pkg.getPackageMainResourcesPath(), buildFileName(baseFileName, resourceType), formModelsPresenter.getFormModel()); } @Inject NewFormDefinitionlHandler(final Caller<FormEditorService> modelerService,
final FormDefinitionResourceType resourceType,
final TranslationService translationService,
final FormModelsPresenter formModelsPresenter,
final WorkspaceProjectContext context,
final Caller<KieModuleService> moduleService,
final Caller<ValidationService> validationService,
final PlaceManager placeManager,
final Event<NotificationEvent> notificationEvent,
final Event<NewResourceSuccessEvent> newResourceSuccessEvent,
final BusyIndicatorView busyIndicatorView); } | NewFormDefinitionlHandler extends DefaultNewResourceHandler { @Override public void create(final org.guvnor.common.services.project.model.Package pkg, final String baseFileName, final NewResourcePresenter presenter) { busyIndicatorView.showBusyIndicator(translationService.getTranslation(FormEditorConstants.NewFormDefinitionlHandlerSelectFormUse)); modelerService.call(getSuccessCallback(presenter), getErrorCallback()).createForm(pkg.getPackageMainResourcesPath(), buildFileName(baseFileName, resourceType), formModelsPresenter.getFormModel()); } @Inject NewFormDefinitionlHandler(final Caller<FormEditorService> modelerService,
final FormDefinitionResourceType resourceType,
final TranslationService translationService,
final FormModelsPresenter formModelsPresenter,
final WorkspaceProjectContext context,
final Caller<KieModuleService> moduleService,
final Caller<ValidationService> validationService,
final PlaceManager placeManager,
final Event<NotificationEvent> notificationEvent,
final Event<NewResourceSuccessEvent> newResourceSuccessEvent,
final BusyIndicatorView busyIndicatorView); @Override String getDescription(); @Override IsWidget getIcon(); @Override ResourceTypeDefinition getResourceType(); @Override List<Pair<String, ? extends IsWidget>> getExtensions(); @Override void validate(String baseFileName,
ValidatorWithReasonCallback callback); @Override void create(final org.guvnor.common.services.project.model.Package pkg,
final String baseFileName,
final NewResourcePresenter presenter); @Override List<Profile> getProfiles(); } | NewFormDefinitionlHandler extends DefaultNewResourceHandler { @Override public void create(final org.guvnor.common.services.project.model.Package pkg, final String baseFileName, final NewResourcePresenter presenter) { busyIndicatorView.showBusyIndicator(translationService.getTranslation(FormEditorConstants.NewFormDefinitionlHandlerSelectFormUse)); modelerService.call(getSuccessCallback(presenter), getErrorCallback()).createForm(pkg.getPackageMainResourcesPath(), buildFileName(baseFileName, resourceType), formModelsPresenter.getFormModel()); } @Inject NewFormDefinitionlHandler(final Caller<FormEditorService> modelerService,
final FormDefinitionResourceType resourceType,
final TranslationService translationService,
final FormModelsPresenter formModelsPresenter,
final WorkspaceProjectContext context,
final Caller<KieModuleService> moduleService,
final Caller<ValidationService> validationService,
final PlaceManager placeManager,
final Event<NotificationEvent> notificationEvent,
final Event<NewResourceSuccessEvent> newResourceSuccessEvent,
final BusyIndicatorView busyIndicatorView); @Override String getDescription(); @Override IsWidget getIcon(); @Override ResourceTypeDefinition getResourceType(); @Override List<Pair<String, ? extends IsWidget>> getExtensions(); @Override void validate(String baseFileName,
ValidatorWithReasonCallback callback); @Override void create(final org.guvnor.common.services.project.model.Package pkg,
final String baseFileName,
final NewResourcePresenter presenter); @Override List<Profile> getProfiles(); } |
@Test public void testFailedCreation() { when(formEditorService.createForm(any(), anyString(), any())).thenThrow(new IllegalStateException("Something wrong happened")); handler.create(pkg, NEW_FORM_NAME, newResourcePresenter); verify(translationService).getTranslation(FormEditorConstants.NewFormDefinitionlHandlerSelectFormUse); verify(busyIndicatorView).showBusyIndicator(anyString()); verify(errorCallback).error(any(), any()); } | @Override public void create(final org.guvnor.common.services.project.model.Package pkg, final String baseFileName, final NewResourcePresenter presenter) { busyIndicatorView.showBusyIndicator(translationService.getTranslation(FormEditorConstants.NewFormDefinitionlHandlerSelectFormUse)); modelerService.call(getSuccessCallback(presenter), getErrorCallback()).createForm(pkg.getPackageMainResourcesPath(), buildFileName(baseFileName, resourceType), formModelsPresenter.getFormModel()); } | NewFormDefinitionlHandler extends DefaultNewResourceHandler { @Override public void create(final org.guvnor.common.services.project.model.Package pkg, final String baseFileName, final NewResourcePresenter presenter) { busyIndicatorView.showBusyIndicator(translationService.getTranslation(FormEditorConstants.NewFormDefinitionlHandlerSelectFormUse)); modelerService.call(getSuccessCallback(presenter), getErrorCallback()).createForm(pkg.getPackageMainResourcesPath(), buildFileName(baseFileName, resourceType), formModelsPresenter.getFormModel()); } } | NewFormDefinitionlHandler extends DefaultNewResourceHandler { @Override public void create(final org.guvnor.common.services.project.model.Package pkg, final String baseFileName, final NewResourcePresenter presenter) { busyIndicatorView.showBusyIndicator(translationService.getTranslation(FormEditorConstants.NewFormDefinitionlHandlerSelectFormUse)); modelerService.call(getSuccessCallback(presenter), getErrorCallback()).createForm(pkg.getPackageMainResourcesPath(), buildFileName(baseFileName, resourceType), formModelsPresenter.getFormModel()); } @Inject NewFormDefinitionlHandler(final Caller<FormEditorService> modelerService,
final FormDefinitionResourceType resourceType,
final TranslationService translationService,
final FormModelsPresenter formModelsPresenter,
final WorkspaceProjectContext context,
final Caller<KieModuleService> moduleService,
final Caller<ValidationService> validationService,
final PlaceManager placeManager,
final Event<NotificationEvent> notificationEvent,
final Event<NewResourceSuccessEvent> newResourceSuccessEvent,
final BusyIndicatorView busyIndicatorView); } | NewFormDefinitionlHandler extends DefaultNewResourceHandler { @Override public void create(final org.guvnor.common.services.project.model.Package pkg, final String baseFileName, final NewResourcePresenter presenter) { busyIndicatorView.showBusyIndicator(translationService.getTranslation(FormEditorConstants.NewFormDefinitionlHandlerSelectFormUse)); modelerService.call(getSuccessCallback(presenter), getErrorCallback()).createForm(pkg.getPackageMainResourcesPath(), buildFileName(baseFileName, resourceType), formModelsPresenter.getFormModel()); } @Inject NewFormDefinitionlHandler(final Caller<FormEditorService> modelerService,
final FormDefinitionResourceType resourceType,
final TranslationService translationService,
final FormModelsPresenter formModelsPresenter,
final WorkspaceProjectContext context,
final Caller<KieModuleService> moduleService,
final Caller<ValidationService> validationService,
final PlaceManager placeManager,
final Event<NotificationEvent> notificationEvent,
final Event<NewResourceSuccessEvent> newResourceSuccessEvent,
final BusyIndicatorView busyIndicatorView); @Override String getDescription(); @Override IsWidget getIcon(); @Override ResourceTypeDefinition getResourceType(); @Override List<Pair<String, ? extends IsWidget>> getExtensions(); @Override void validate(String baseFileName,
ValidatorWithReasonCallback callback); @Override void create(final org.guvnor.common.services.project.model.Package pkg,
final String baseFileName,
final NewResourcePresenter presenter); @Override List<Profile> getProfiles(); } | NewFormDefinitionlHandler extends DefaultNewResourceHandler { @Override public void create(final org.guvnor.common.services.project.model.Package pkg, final String baseFileName, final NewResourcePresenter presenter) { busyIndicatorView.showBusyIndicator(translationService.getTranslation(FormEditorConstants.NewFormDefinitionlHandlerSelectFormUse)); modelerService.call(getSuccessCallback(presenter), getErrorCallback()).createForm(pkg.getPackageMainResourcesPath(), buildFileName(baseFileName, resourceType), formModelsPresenter.getFormModel()); } @Inject NewFormDefinitionlHandler(final Caller<FormEditorService> modelerService,
final FormDefinitionResourceType resourceType,
final TranslationService translationService,
final FormModelsPresenter formModelsPresenter,
final WorkspaceProjectContext context,
final Caller<KieModuleService> moduleService,
final Caller<ValidationService> validationService,
final PlaceManager placeManager,
final Event<NotificationEvent> notificationEvent,
final Event<NewResourceSuccessEvent> newResourceSuccessEvent,
final BusyIndicatorView busyIndicatorView); @Override String getDescription(); @Override IsWidget getIcon(); @Override ResourceTypeDefinition getResourceType(); @Override List<Pair<String, ? extends IsWidget>> getExtensions(); @Override void validate(String baseFileName,
ValidatorWithReasonCallback callback); @Override void create(final org.guvnor.common.services.project.model.Package pkg,
final String baseFileName,
final NewResourcePresenter presenter); @Override List<Profile> getProfiles(); } |
@Test public void testGetAssociatedType() { assertThat(event.getAssociatedType()).isEqualTo(MoveDividerStartEvent.TYPE); } | @Override public Type<MoveDividerStartHandler> getAssociatedType() { return TYPE; } | MoveDividerStartEvent extends AbstractWiresDragEvent<MoveDividerStartHandler> { @Override public Type<MoveDividerStartHandler> getAssociatedType() { return TYPE; } } | MoveDividerStartEvent extends AbstractWiresDragEvent<MoveDividerStartHandler> { @Override public Type<MoveDividerStartHandler> getAssociatedType() { return TYPE; } MoveDividerStartEvent(final DecisionServiceSVGShapeView shape,
final AbstractNodeDragEvent<?> nodeDragEvent); } | MoveDividerStartEvent extends AbstractWiresDragEvent<MoveDividerStartHandler> { @Override public Type<MoveDividerStartHandler> getAssociatedType() { return TYPE; } MoveDividerStartEvent(final DecisionServiceSVGShapeView shape,
final AbstractNodeDragEvent<?> nodeDragEvent); @Override Type<MoveDividerStartHandler> getAssociatedType(); } | MoveDividerStartEvent extends AbstractWiresDragEvent<MoveDividerStartHandler> { @Override public Type<MoveDividerStartHandler> getAssociatedType() { return TYPE; } MoveDividerStartEvent(final DecisionServiceSVGShapeView shape,
final AbstractNodeDragEvent<?> nodeDragEvent); @Override Type<MoveDividerStartHandler> getAssociatedType(); static final Type<MoveDividerStartHandler> TYPE; } |
@Test public void testDroppingNewField() { editorFieldLayoutComponent.getShowWidget(ctx); verify(editorFieldLayoutComponent).init(context, fieldDefinition); verify(fieldRenderer).init(context, fieldDefinition); verify(fieldRenderer).renderWidget(); } | @Override public void init(FormRenderingContext renderingContext, FieldDefinition field) { super.init(renderingContext, field); initPropertiesConfig(); } | EditorFieldLayoutComponent extends FieldLayoutComponent implements HasDragAndDropSettings,
HasModalConfiguration { @Override public void init(FormRenderingContext renderingContext, FieldDefinition field) { super.init(renderingContext, field); initPropertiesConfig(); } } | EditorFieldLayoutComponent extends FieldLayoutComponent implements HasDragAndDropSettings,
HasModalConfiguration { @Override public void init(FormRenderingContext renderingContext, FieldDefinition field) { super.init(renderingContext, field); initPropertiesConfig(); } @Inject EditorFieldLayoutComponent(FieldRendererManager fieldRendererManager,
TranslationService translationService,
FieldPropertiesRenderer propertiesRenderer,
FieldManager fieldManager,
Event<FormEditorSyncPaletteEvent> syncPaletteEvent); } | EditorFieldLayoutComponent extends FieldLayoutComponent implements HasDragAndDropSettings,
HasModalConfiguration { @Override public void init(FormRenderingContext renderingContext, FieldDefinition field) { super.init(renderingContext, field); initPropertiesConfig(); } @Inject EditorFieldLayoutComponent(FieldRendererManager fieldRendererManager,
TranslationService translationService,
FieldPropertiesRenderer propertiesRenderer,
FieldManager fieldManager,
Event<FormEditorSyncPaletteEvent> syncPaletteEvent); @Override void init(FormRenderingContext renderingContext,
FieldDefinition field); @Override String[] getSettingsKeys(); @Override void setSettingValue(String key,
String value); @Override String getSettingValue(String key); @Override Map<String, String> getMapSettings(); @Override Modal getConfigurationModal(final ModalConfigurationContext ctx); } | EditorFieldLayoutComponent extends FieldLayoutComponent implements HasDragAndDropSettings,
HasModalConfiguration { @Override public void init(FormRenderingContext renderingContext, FieldDefinition field) { super.init(renderingContext, field); initPropertiesConfig(); } @Inject EditorFieldLayoutComponent(FieldRendererManager fieldRendererManager,
TranslationService translationService,
FieldPropertiesRenderer propertiesRenderer,
FieldManager fieldManager,
Event<FormEditorSyncPaletteEvent> syncPaletteEvent); @Override void init(FormRenderingContext renderingContext,
FieldDefinition field); @Override String[] getSettingsKeys(); @Override void setSettingValue(String key,
String value); @Override String getSettingValue(String key); @Override Map<String, String> getMapSettings(); @Override Modal getConfigurationModal(final ModalConfigurationContext ctx); final String[] SETTINGS_KEYS; } |
@Test public void testRenderingExistingField() { testDroppingNewField(); editorFieldLayoutComponent.getShowWidget(ctx); verify(editorFieldLayoutComponent, times(1)).init(context, fieldDefinition); verify(fieldRenderer, times(1)).init(context, fieldDefinition); verify(fieldRenderer, times(2)).renderWidget(); } | @Override public void init(FormRenderingContext renderingContext, FieldDefinition field) { super.init(renderingContext, field); initPropertiesConfig(); } | EditorFieldLayoutComponent extends FieldLayoutComponent implements HasDragAndDropSettings,
HasModalConfiguration { @Override public void init(FormRenderingContext renderingContext, FieldDefinition field) { super.init(renderingContext, field); initPropertiesConfig(); } } | EditorFieldLayoutComponent extends FieldLayoutComponent implements HasDragAndDropSettings,
HasModalConfiguration { @Override public void init(FormRenderingContext renderingContext, FieldDefinition field) { super.init(renderingContext, field); initPropertiesConfig(); } @Inject EditorFieldLayoutComponent(FieldRendererManager fieldRendererManager,
TranslationService translationService,
FieldPropertiesRenderer propertiesRenderer,
FieldManager fieldManager,
Event<FormEditorSyncPaletteEvent> syncPaletteEvent); } | EditorFieldLayoutComponent extends FieldLayoutComponent implements HasDragAndDropSettings,
HasModalConfiguration { @Override public void init(FormRenderingContext renderingContext, FieldDefinition field) { super.init(renderingContext, field); initPropertiesConfig(); } @Inject EditorFieldLayoutComponent(FieldRendererManager fieldRendererManager,
TranslationService translationService,
FieldPropertiesRenderer propertiesRenderer,
FieldManager fieldManager,
Event<FormEditorSyncPaletteEvent> syncPaletteEvent); @Override void init(FormRenderingContext renderingContext,
FieldDefinition field); @Override String[] getSettingsKeys(); @Override void setSettingValue(String key,
String value); @Override String getSettingValue(String key); @Override Map<String, String> getMapSettings(); @Override Modal getConfigurationModal(final ModalConfigurationContext ctx); } | EditorFieldLayoutComponent extends FieldLayoutComponent implements HasDragAndDropSettings,
HasModalConfiguration { @Override public void init(FormRenderingContext renderingContext, FieldDefinition field) { super.init(renderingContext, field); initPropertiesConfig(); } @Inject EditorFieldLayoutComponent(FieldRendererManager fieldRendererManager,
TranslationService translationService,
FieldPropertiesRenderer propertiesRenderer,
FieldManager fieldManager,
Event<FormEditorSyncPaletteEvent> syncPaletteEvent); @Override void init(FormRenderingContext renderingContext,
FieldDefinition field); @Override String[] getSettingsKeys(); @Override void setSettingValue(String key,
String value); @Override String getSettingValue(String key); @Override Map<String, String> getMapSettings(); @Override Modal getConfigurationModal(final ModalConfigurationContext ctx); final String[] SETTINGS_KEYS; } |
@Test public void testReceivingWrongContextResponses() { testDroppingNewField(); verify(editorFieldLayoutComponent, times(1)).init(context, fieldDefinition); verify(fieldRenderer, times(1)).init(context, fieldDefinition); verify(editorFieldLayoutComponent, times(1)).init(context, fieldDefinition); verify(fieldRenderer, times(1)).init(context, fieldDefinition); } | @Override public void init(FormRenderingContext renderingContext, FieldDefinition field) { super.init(renderingContext, field); initPropertiesConfig(); } | EditorFieldLayoutComponent extends FieldLayoutComponent implements HasDragAndDropSettings,
HasModalConfiguration { @Override public void init(FormRenderingContext renderingContext, FieldDefinition field) { super.init(renderingContext, field); initPropertiesConfig(); } } | EditorFieldLayoutComponent extends FieldLayoutComponent implements HasDragAndDropSettings,
HasModalConfiguration { @Override public void init(FormRenderingContext renderingContext, FieldDefinition field) { super.init(renderingContext, field); initPropertiesConfig(); } @Inject EditorFieldLayoutComponent(FieldRendererManager fieldRendererManager,
TranslationService translationService,
FieldPropertiesRenderer propertiesRenderer,
FieldManager fieldManager,
Event<FormEditorSyncPaletteEvent> syncPaletteEvent); } | EditorFieldLayoutComponent extends FieldLayoutComponent implements HasDragAndDropSettings,
HasModalConfiguration { @Override public void init(FormRenderingContext renderingContext, FieldDefinition field) { super.init(renderingContext, field); initPropertiesConfig(); } @Inject EditorFieldLayoutComponent(FieldRendererManager fieldRendererManager,
TranslationService translationService,
FieldPropertiesRenderer propertiesRenderer,
FieldManager fieldManager,
Event<FormEditorSyncPaletteEvent> syncPaletteEvent); @Override void init(FormRenderingContext renderingContext,
FieldDefinition field); @Override String[] getSettingsKeys(); @Override void setSettingValue(String key,
String value); @Override String getSettingValue(String key); @Override Map<String, String> getMapSettings(); @Override Modal getConfigurationModal(final ModalConfigurationContext ctx); } | EditorFieldLayoutComponent extends FieldLayoutComponent implements HasDragAndDropSettings,
HasModalConfiguration { @Override public void init(FormRenderingContext renderingContext, FieldDefinition field) { super.init(renderingContext, field); initPropertiesConfig(); } @Inject EditorFieldLayoutComponent(FieldRendererManager fieldRendererManager,
TranslationService translationService,
FieldPropertiesRenderer propertiesRenderer,
FieldManager fieldManager,
Event<FormEditorSyncPaletteEvent> syncPaletteEvent); @Override void init(FormRenderingContext renderingContext,
FieldDefinition field); @Override String[] getSettingsKeys(); @Override void setSettingValue(String key,
String value); @Override String getSettingValue(String key); @Override Map<String, String> getMapSettings(); @Override Modal getConfigurationModal(final ModalConfigurationContext ctx); final String[] SETTINGS_KEYS; } |
@Test public void testReceivingResponsesWhenDisabled() { verify(editorFieldLayoutComponent, never()).init(context, fieldDefinition); verify(fieldRenderer, never()).init(context, fieldDefinition); } | @Override public void init(FormRenderingContext renderingContext, FieldDefinition field) { super.init(renderingContext, field); initPropertiesConfig(); } | EditorFieldLayoutComponent extends FieldLayoutComponent implements HasDragAndDropSettings,
HasModalConfiguration { @Override public void init(FormRenderingContext renderingContext, FieldDefinition field) { super.init(renderingContext, field); initPropertiesConfig(); } } | EditorFieldLayoutComponent extends FieldLayoutComponent implements HasDragAndDropSettings,
HasModalConfiguration { @Override public void init(FormRenderingContext renderingContext, FieldDefinition field) { super.init(renderingContext, field); initPropertiesConfig(); } @Inject EditorFieldLayoutComponent(FieldRendererManager fieldRendererManager,
TranslationService translationService,
FieldPropertiesRenderer propertiesRenderer,
FieldManager fieldManager,
Event<FormEditorSyncPaletteEvent> syncPaletteEvent); } | EditorFieldLayoutComponent extends FieldLayoutComponent implements HasDragAndDropSettings,
HasModalConfiguration { @Override public void init(FormRenderingContext renderingContext, FieldDefinition field) { super.init(renderingContext, field); initPropertiesConfig(); } @Inject EditorFieldLayoutComponent(FieldRendererManager fieldRendererManager,
TranslationService translationService,
FieldPropertiesRenderer propertiesRenderer,
FieldManager fieldManager,
Event<FormEditorSyncPaletteEvent> syncPaletteEvent); @Override void init(FormRenderingContext renderingContext,
FieldDefinition field); @Override String[] getSettingsKeys(); @Override void setSettingValue(String key,
String value); @Override String getSettingValue(String key); @Override Map<String, String> getMapSettings(); @Override Modal getConfigurationModal(final ModalConfigurationContext ctx); } | EditorFieldLayoutComponent extends FieldLayoutComponent implements HasDragAndDropSettings,
HasModalConfiguration { @Override public void init(FormRenderingContext renderingContext, FieldDefinition field) { super.init(renderingContext, field); initPropertiesConfig(); } @Inject EditorFieldLayoutComponent(FieldRendererManager fieldRendererManager,
TranslationService translationService,
FieldPropertiesRenderer propertiesRenderer,
FieldManager fieldManager,
Event<FormEditorSyncPaletteEvent> syncPaletteEvent); @Override void init(FormRenderingContext renderingContext,
FieldDefinition field); @Override String[] getSettingsKeys(); @Override void setSettingValue(String key,
String value); @Override String getSettingValue(String key); @Override Map<String, String> getMapSettings(); @Override Modal getConfigurationModal(final ModalConfigurationContext ctx); final String[] SETTINGS_KEYS; } |
@Test public void testOpenFieldProperties() { testDroppingNewField(); ModalConfigurationContext modalConfigurationContext = mock(ModalConfigurationContext.class); when(modalConfigurationContext.getComponentProperties()).thenReturn(layoutComponent.getProperties()); editorFieldLayoutComponent.getConfigurationModal(modalConfigurationContext); verify(propertiesRenderer).render(any()); verify(propertiesRenderer).getView(); verify(fieldPropertiesRendererView).getPropertiesModal(); } | @Override public Modal getConfigurationModal(final ModalConfigurationContext ctx) { showProperties = true; configContext = ctx; if (field == null) { initContent(ctx.getComponentProperties()); } else { propertiesRenderer.render(propertiesRendererHelper); } return propertiesRenderer.getView().getPropertiesModal(); } | EditorFieldLayoutComponent extends FieldLayoutComponent implements HasDragAndDropSettings,
HasModalConfiguration { @Override public Modal getConfigurationModal(final ModalConfigurationContext ctx) { showProperties = true; configContext = ctx; if (field == null) { initContent(ctx.getComponentProperties()); } else { propertiesRenderer.render(propertiesRendererHelper); } return propertiesRenderer.getView().getPropertiesModal(); } } | EditorFieldLayoutComponent extends FieldLayoutComponent implements HasDragAndDropSettings,
HasModalConfiguration { @Override public Modal getConfigurationModal(final ModalConfigurationContext ctx) { showProperties = true; configContext = ctx; if (field == null) { initContent(ctx.getComponentProperties()); } else { propertiesRenderer.render(propertiesRendererHelper); } return propertiesRenderer.getView().getPropertiesModal(); } @Inject EditorFieldLayoutComponent(FieldRendererManager fieldRendererManager,
TranslationService translationService,
FieldPropertiesRenderer propertiesRenderer,
FieldManager fieldManager,
Event<FormEditorSyncPaletteEvent> syncPaletteEvent); } | EditorFieldLayoutComponent extends FieldLayoutComponent implements HasDragAndDropSettings,
HasModalConfiguration { @Override public Modal getConfigurationModal(final ModalConfigurationContext ctx) { showProperties = true; configContext = ctx; if (field == null) { initContent(ctx.getComponentProperties()); } else { propertiesRenderer.render(propertiesRendererHelper); } return propertiesRenderer.getView().getPropertiesModal(); } @Inject EditorFieldLayoutComponent(FieldRendererManager fieldRendererManager,
TranslationService translationService,
FieldPropertiesRenderer propertiesRenderer,
FieldManager fieldManager,
Event<FormEditorSyncPaletteEvent> syncPaletteEvent); @Override void init(FormRenderingContext renderingContext,
FieldDefinition field); @Override String[] getSettingsKeys(); @Override void setSettingValue(String key,
String value); @Override String getSettingValue(String key); @Override Map<String, String> getMapSettings(); @Override Modal getConfigurationModal(final ModalConfigurationContext ctx); } | EditorFieldLayoutComponent extends FieldLayoutComponent implements HasDragAndDropSettings,
HasModalConfiguration { @Override public Modal getConfigurationModal(final ModalConfigurationContext ctx) { showProperties = true; configContext = ctx; if (field == null) { initContent(ctx.getComponentProperties()); } else { propertiesRenderer.render(propertiesRendererHelper); } return propertiesRenderer.getView().getPropertiesModal(); } @Inject EditorFieldLayoutComponent(FieldRendererManager fieldRendererManager,
TranslationService translationService,
FieldPropertiesRenderer propertiesRenderer,
FieldManager fieldManager,
Event<FormEditorSyncPaletteEvent> syncPaletteEvent); @Override void init(FormRenderingContext renderingContext,
FieldDefinition field); @Override String[] getSettingsKeys(); @Override void setSettingValue(String key,
String value); @Override String getSettingValue(String key); @Override Map<String, String> getMapSettings(); @Override Modal getConfigurationModal(final ModalConfigurationContext ctx); final String[] SETTINGS_KEYS; } |
@Test public void testHardCodedDragAndDropMethods() { editorFieldLayoutComponent.setSettingValue(EditorFieldLayoutComponent.FORM_ID, formDefinition.getId()); editorFieldLayoutComponent.setSettingValue(EditorFieldLayoutComponent.FIELD_ID, fieldDefinition.getId()); verifyDragAndDropMethods(); } | @Override public void setSettingValue(String key, String value) { if (FORM_ID.equals(key)) { formId = Optional.of(value); } else if (FIELD_ID.equals(key)) { fieldId = Optional.of(value); } } | EditorFieldLayoutComponent extends FieldLayoutComponent implements HasDragAndDropSettings,
HasModalConfiguration { @Override public void setSettingValue(String key, String value) { if (FORM_ID.equals(key)) { formId = Optional.of(value); } else if (FIELD_ID.equals(key)) { fieldId = Optional.of(value); } } } | EditorFieldLayoutComponent extends FieldLayoutComponent implements HasDragAndDropSettings,
HasModalConfiguration { @Override public void setSettingValue(String key, String value) { if (FORM_ID.equals(key)) { formId = Optional.of(value); } else if (FIELD_ID.equals(key)) { fieldId = Optional.of(value); } } @Inject EditorFieldLayoutComponent(FieldRendererManager fieldRendererManager,
TranslationService translationService,
FieldPropertiesRenderer propertiesRenderer,
FieldManager fieldManager,
Event<FormEditorSyncPaletteEvent> syncPaletteEvent); } | EditorFieldLayoutComponent extends FieldLayoutComponent implements HasDragAndDropSettings,
HasModalConfiguration { @Override public void setSettingValue(String key, String value) { if (FORM_ID.equals(key)) { formId = Optional.of(value); } else if (FIELD_ID.equals(key)) { fieldId = Optional.of(value); } } @Inject EditorFieldLayoutComponent(FieldRendererManager fieldRendererManager,
TranslationService translationService,
FieldPropertiesRenderer propertiesRenderer,
FieldManager fieldManager,
Event<FormEditorSyncPaletteEvent> syncPaletteEvent); @Override void init(FormRenderingContext renderingContext,
FieldDefinition field); @Override String[] getSettingsKeys(); @Override void setSettingValue(String key,
String value); @Override String getSettingValue(String key); @Override Map<String, String> getMapSettings(); @Override Modal getConfigurationModal(final ModalConfigurationContext ctx); } | EditorFieldLayoutComponent extends FieldLayoutComponent implements HasDragAndDropSettings,
HasModalConfiguration { @Override public void setSettingValue(String key, String value) { if (FORM_ID.equals(key)) { formId = Optional.of(value); } else if (FIELD_ID.equals(key)) { fieldId = Optional.of(value); } } @Inject EditorFieldLayoutComponent(FieldRendererManager fieldRendererManager,
TranslationService translationService,
FieldPropertiesRenderer propertiesRenderer,
FieldManager fieldManager,
Event<FormEditorSyncPaletteEvent> syncPaletteEvent); @Override void init(FormRenderingContext renderingContext,
FieldDefinition field); @Override String[] getSettingsKeys(); @Override void setSettingValue(String key,
String value); @Override String getSettingValue(String key); @Override Map<String, String> getMapSettings(); @Override Modal getConfigurationModal(final ModalConfigurationContext ctx); final String[] SETTINGS_KEYS; } |
@Test public void testOnPressOk() { testOnPressOk(false, false); } | protected void onPressOk(FieldDefinition fieldCopy) { editorHelper.saveFormField(field, fieldCopy); this.field = fieldCopy; this.fieldId = Optional.of(fieldCopy.getId()); initComponent(); renderContent(); showProperties = false; if (configContext != null) { LayoutComponent layoutComponent = configContext.getLayoutComponent(); addComponentParts(layoutComponent); configContext.getComponentProperties().put(FORM_ID, getFormId()); configContext.getComponentProperties().put(FIELD_ID, field.getId()); configContext.configurationFinished(); configContext = null; } syncPaletteEvent.fire(new FormEditorSyncPaletteEvent(getFormId())); } | EditorFieldLayoutComponent extends FieldLayoutComponent implements HasDragAndDropSettings,
HasModalConfiguration { protected void onPressOk(FieldDefinition fieldCopy) { editorHelper.saveFormField(field, fieldCopy); this.field = fieldCopy; this.fieldId = Optional.of(fieldCopy.getId()); initComponent(); renderContent(); showProperties = false; if (configContext != null) { LayoutComponent layoutComponent = configContext.getLayoutComponent(); addComponentParts(layoutComponent); configContext.getComponentProperties().put(FORM_ID, getFormId()); configContext.getComponentProperties().put(FIELD_ID, field.getId()); configContext.configurationFinished(); configContext = null; } syncPaletteEvent.fire(new FormEditorSyncPaletteEvent(getFormId())); } } | EditorFieldLayoutComponent extends FieldLayoutComponent implements HasDragAndDropSettings,
HasModalConfiguration { protected void onPressOk(FieldDefinition fieldCopy) { editorHelper.saveFormField(field, fieldCopy); this.field = fieldCopy; this.fieldId = Optional.of(fieldCopy.getId()); initComponent(); renderContent(); showProperties = false; if (configContext != null) { LayoutComponent layoutComponent = configContext.getLayoutComponent(); addComponentParts(layoutComponent); configContext.getComponentProperties().put(FORM_ID, getFormId()); configContext.getComponentProperties().put(FIELD_ID, field.getId()); configContext.configurationFinished(); configContext = null; } syncPaletteEvent.fire(new FormEditorSyncPaletteEvent(getFormId())); } @Inject EditorFieldLayoutComponent(FieldRendererManager fieldRendererManager,
TranslationService translationService,
FieldPropertiesRenderer propertiesRenderer,
FieldManager fieldManager,
Event<FormEditorSyncPaletteEvent> syncPaletteEvent); } | EditorFieldLayoutComponent extends FieldLayoutComponent implements HasDragAndDropSettings,
HasModalConfiguration { protected void onPressOk(FieldDefinition fieldCopy) { editorHelper.saveFormField(field, fieldCopy); this.field = fieldCopy; this.fieldId = Optional.of(fieldCopy.getId()); initComponent(); renderContent(); showProperties = false; if (configContext != null) { LayoutComponent layoutComponent = configContext.getLayoutComponent(); addComponentParts(layoutComponent); configContext.getComponentProperties().put(FORM_ID, getFormId()); configContext.getComponentProperties().put(FIELD_ID, field.getId()); configContext.configurationFinished(); configContext = null; } syncPaletteEvent.fire(new FormEditorSyncPaletteEvent(getFormId())); } @Inject EditorFieldLayoutComponent(FieldRendererManager fieldRendererManager,
TranslationService translationService,
FieldPropertiesRenderer propertiesRenderer,
FieldManager fieldManager,
Event<FormEditorSyncPaletteEvent> syncPaletteEvent); @Override void init(FormRenderingContext renderingContext,
FieldDefinition field); @Override String[] getSettingsKeys(); @Override void setSettingValue(String key,
String value); @Override String getSettingValue(String key); @Override Map<String, String> getMapSettings(); @Override Modal getConfigurationModal(final ModalConfigurationContext ctx); } | EditorFieldLayoutComponent extends FieldLayoutComponent implements HasDragAndDropSettings,
HasModalConfiguration { protected void onPressOk(FieldDefinition fieldCopy) { editorHelper.saveFormField(field, fieldCopy); this.field = fieldCopy; this.fieldId = Optional.of(fieldCopy.getId()); initComponent(); renderContent(); showProperties = false; if (configContext != null) { LayoutComponent layoutComponent = configContext.getLayoutComponent(); addComponentParts(layoutComponent); configContext.getComponentProperties().put(FORM_ID, getFormId()); configContext.getComponentProperties().put(FIELD_ID, field.getId()); configContext.configurationFinished(); configContext = null; } syncPaletteEvent.fire(new FormEditorSyncPaletteEvent(getFormId())); } @Inject EditorFieldLayoutComponent(FieldRendererManager fieldRendererManager,
TranslationService translationService,
FieldPropertiesRenderer propertiesRenderer,
FieldManager fieldManager,
Event<FormEditorSyncPaletteEvent> syncPaletteEvent); @Override void init(FormRenderingContext renderingContext,
FieldDefinition field); @Override String[] getSettingsKeys(); @Override void setSettingValue(String key,
String value); @Override String getSettingValue(String key); @Override Map<String, String> getMapSettings(); @Override Modal getConfigurationModal(final ModalConfigurationContext ctx); final String[] SETTINGS_KEYS; } |
@Test public void testHelperOnPressOk() { FieldDefinition fieldCopy = setupFormEditorHelper(); propertiesRendererHelper.onPressOk(fieldCopy); verify(editorFieldLayoutComponent).onPressOk(fieldCopy); } | protected void onPressOk(FieldDefinition fieldCopy) { editorHelper.saveFormField(field, fieldCopy); this.field = fieldCopy; this.fieldId = Optional.of(fieldCopy.getId()); initComponent(); renderContent(); showProperties = false; if (configContext != null) { LayoutComponent layoutComponent = configContext.getLayoutComponent(); addComponentParts(layoutComponent); configContext.getComponentProperties().put(FORM_ID, getFormId()); configContext.getComponentProperties().put(FIELD_ID, field.getId()); configContext.configurationFinished(); configContext = null; } syncPaletteEvent.fire(new FormEditorSyncPaletteEvent(getFormId())); } | EditorFieldLayoutComponent extends FieldLayoutComponent implements HasDragAndDropSettings,
HasModalConfiguration { protected void onPressOk(FieldDefinition fieldCopy) { editorHelper.saveFormField(field, fieldCopy); this.field = fieldCopy; this.fieldId = Optional.of(fieldCopy.getId()); initComponent(); renderContent(); showProperties = false; if (configContext != null) { LayoutComponent layoutComponent = configContext.getLayoutComponent(); addComponentParts(layoutComponent); configContext.getComponentProperties().put(FORM_ID, getFormId()); configContext.getComponentProperties().put(FIELD_ID, field.getId()); configContext.configurationFinished(); configContext = null; } syncPaletteEvent.fire(new FormEditorSyncPaletteEvent(getFormId())); } } | EditorFieldLayoutComponent extends FieldLayoutComponent implements HasDragAndDropSettings,
HasModalConfiguration { protected void onPressOk(FieldDefinition fieldCopy) { editorHelper.saveFormField(field, fieldCopy); this.field = fieldCopy; this.fieldId = Optional.of(fieldCopy.getId()); initComponent(); renderContent(); showProperties = false; if (configContext != null) { LayoutComponent layoutComponent = configContext.getLayoutComponent(); addComponentParts(layoutComponent); configContext.getComponentProperties().put(FORM_ID, getFormId()); configContext.getComponentProperties().put(FIELD_ID, field.getId()); configContext.configurationFinished(); configContext = null; } syncPaletteEvent.fire(new FormEditorSyncPaletteEvent(getFormId())); } @Inject EditorFieldLayoutComponent(FieldRendererManager fieldRendererManager,
TranslationService translationService,
FieldPropertiesRenderer propertiesRenderer,
FieldManager fieldManager,
Event<FormEditorSyncPaletteEvent> syncPaletteEvent); } | EditorFieldLayoutComponent extends FieldLayoutComponent implements HasDragAndDropSettings,
HasModalConfiguration { protected void onPressOk(FieldDefinition fieldCopy) { editorHelper.saveFormField(field, fieldCopy); this.field = fieldCopy; this.fieldId = Optional.of(fieldCopy.getId()); initComponent(); renderContent(); showProperties = false; if (configContext != null) { LayoutComponent layoutComponent = configContext.getLayoutComponent(); addComponentParts(layoutComponent); configContext.getComponentProperties().put(FORM_ID, getFormId()); configContext.getComponentProperties().put(FIELD_ID, field.getId()); configContext.configurationFinished(); configContext = null; } syncPaletteEvent.fire(new FormEditorSyncPaletteEvent(getFormId())); } @Inject EditorFieldLayoutComponent(FieldRendererManager fieldRendererManager,
TranslationService translationService,
FieldPropertiesRenderer propertiesRenderer,
FieldManager fieldManager,
Event<FormEditorSyncPaletteEvent> syncPaletteEvent); @Override void init(FormRenderingContext renderingContext,
FieldDefinition field); @Override String[] getSettingsKeys(); @Override void setSettingValue(String key,
String value); @Override String getSettingValue(String key); @Override Map<String, String> getMapSettings(); @Override Modal getConfigurationModal(final ModalConfigurationContext ctx); } | EditorFieldLayoutComponent extends FieldLayoutComponent implements HasDragAndDropSettings,
HasModalConfiguration { protected void onPressOk(FieldDefinition fieldCopy) { editorHelper.saveFormField(field, fieldCopy); this.field = fieldCopy; this.fieldId = Optional.of(fieldCopy.getId()); initComponent(); renderContent(); showProperties = false; if (configContext != null) { LayoutComponent layoutComponent = configContext.getLayoutComponent(); addComponentParts(layoutComponent); configContext.getComponentProperties().put(FORM_ID, getFormId()); configContext.getComponentProperties().put(FIELD_ID, field.getId()); configContext.configurationFinished(); configContext = null; } syncPaletteEvent.fire(new FormEditorSyncPaletteEvent(getFormId())); } @Inject EditorFieldLayoutComponent(FieldRendererManager fieldRendererManager,
TranslationService translationService,
FieldPropertiesRenderer propertiesRenderer,
FieldManager fieldManager,
Event<FormEditorSyncPaletteEvent> syncPaletteEvent); @Override void init(FormRenderingContext renderingContext,
FieldDefinition field); @Override String[] getSettingsKeys(); @Override void setSettingValue(String key,
String value); @Override String getSettingValue(String key); @Override Map<String, String> getMapSettings(); @Override Modal getConfigurationModal(final ModalConfigurationContext ctx); final String[] SETTINGS_KEYS; } |
@Test public void testHelperOnCloseWithContext() { ModalConfigurationContext ctx = mock(ModalConfigurationContext.class); when(ctx.getComponentProperties()).thenReturn(mock(Map.class)); testDroppingNewField(); editorFieldLayoutComponent.getConfigurationModal(ctx); propertiesRendererHelper.onClose(); assertFalse(editorFieldLayoutComponent.showProperties); verify(ctx).configurationCancelled(); } | @Override public Modal getConfigurationModal(final ModalConfigurationContext ctx) { showProperties = true; configContext = ctx; if (field == null) { initContent(ctx.getComponentProperties()); } else { propertiesRenderer.render(propertiesRendererHelper); } return propertiesRenderer.getView().getPropertiesModal(); } | EditorFieldLayoutComponent extends FieldLayoutComponent implements HasDragAndDropSettings,
HasModalConfiguration { @Override public Modal getConfigurationModal(final ModalConfigurationContext ctx) { showProperties = true; configContext = ctx; if (field == null) { initContent(ctx.getComponentProperties()); } else { propertiesRenderer.render(propertiesRendererHelper); } return propertiesRenderer.getView().getPropertiesModal(); } } | EditorFieldLayoutComponent extends FieldLayoutComponent implements HasDragAndDropSettings,
HasModalConfiguration { @Override public Modal getConfigurationModal(final ModalConfigurationContext ctx) { showProperties = true; configContext = ctx; if (field == null) { initContent(ctx.getComponentProperties()); } else { propertiesRenderer.render(propertiesRendererHelper); } return propertiesRenderer.getView().getPropertiesModal(); } @Inject EditorFieldLayoutComponent(FieldRendererManager fieldRendererManager,
TranslationService translationService,
FieldPropertiesRenderer propertiesRenderer,
FieldManager fieldManager,
Event<FormEditorSyncPaletteEvent> syncPaletteEvent); } | EditorFieldLayoutComponent extends FieldLayoutComponent implements HasDragAndDropSettings,
HasModalConfiguration { @Override public Modal getConfigurationModal(final ModalConfigurationContext ctx) { showProperties = true; configContext = ctx; if (field == null) { initContent(ctx.getComponentProperties()); } else { propertiesRenderer.render(propertiesRendererHelper); } return propertiesRenderer.getView().getPropertiesModal(); } @Inject EditorFieldLayoutComponent(FieldRendererManager fieldRendererManager,
TranslationService translationService,
FieldPropertiesRenderer propertiesRenderer,
FieldManager fieldManager,
Event<FormEditorSyncPaletteEvent> syncPaletteEvent); @Override void init(FormRenderingContext renderingContext,
FieldDefinition field); @Override String[] getSettingsKeys(); @Override void setSettingValue(String key,
String value); @Override String getSettingValue(String key); @Override Map<String, String> getMapSettings(); @Override Modal getConfigurationModal(final ModalConfigurationContext ctx); } | EditorFieldLayoutComponent extends FieldLayoutComponent implements HasDragAndDropSettings,
HasModalConfiguration { @Override public Modal getConfigurationModal(final ModalConfigurationContext ctx) { showProperties = true; configContext = ctx; if (field == null) { initContent(ctx.getComponentProperties()); } else { propertiesRenderer.render(propertiesRendererHelper); } return propertiesRenderer.getView().getPropertiesModal(); } @Inject EditorFieldLayoutComponent(FieldRendererManager fieldRendererManager,
TranslationService translationService,
FieldPropertiesRenderer propertiesRenderer,
FieldManager fieldManager,
Event<FormEditorSyncPaletteEvent> syncPaletteEvent); @Override void init(FormRenderingContext renderingContext,
FieldDefinition field); @Override String[] getSettingsKeys(); @Override void setSettingValue(String key,
String value); @Override String getSettingValue(String key); @Override Map<String, String> getMapSettings(); @Override Modal getConfigurationModal(final ModalConfigurationContext ctx); final String[] SETTINGS_KEYS; } |
@Test public void testFieldPartsAdded() { Set<String> parts = Stream.of("p1", "p2").collect(Collectors.toSet()); when(fieldRenderer.getFieldParts()).thenReturn(parts); editorFieldLayoutComponent.generateContent(ctx); editorFieldLayoutComponent.addComponentParts(ctx.getComponent()); Set<String> expectedParts = layoutComponent.getParts().stream().map(p -> p.getPartId()).collect(Collectors.toSet()); parts = Stream.of("p1", "p3").collect(Collectors.toSet()); when(fieldRenderer.getFieldParts()).thenReturn(parts); editorFieldLayoutComponent.generateContent(ctx); editorFieldLayoutComponent.addComponentParts(ctx.getComponent()); expectedParts = layoutComponent.getParts().stream().map(p -> p.getPartId()).collect(Collectors.toSet()); assertEquals(parts, expectedParts); } | @Override protected IsWidget generateContent(RenderingContext ctx) { LayoutComponent component = ctx.getComponent(); if (fieldRenderer == null) { initContent(component.getProperties()); } else { renderContent(); } return content; } | EditorFieldLayoutComponent extends FieldLayoutComponent implements HasDragAndDropSettings,
HasModalConfiguration { @Override protected IsWidget generateContent(RenderingContext ctx) { LayoutComponent component = ctx.getComponent(); if (fieldRenderer == null) { initContent(component.getProperties()); } else { renderContent(); } return content; } } | EditorFieldLayoutComponent extends FieldLayoutComponent implements HasDragAndDropSettings,
HasModalConfiguration { @Override protected IsWidget generateContent(RenderingContext ctx) { LayoutComponent component = ctx.getComponent(); if (fieldRenderer == null) { initContent(component.getProperties()); } else { renderContent(); } return content; } @Inject EditorFieldLayoutComponent(FieldRendererManager fieldRendererManager,
TranslationService translationService,
FieldPropertiesRenderer propertiesRenderer,
FieldManager fieldManager,
Event<FormEditorSyncPaletteEvent> syncPaletteEvent); } | EditorFieldLayoutComponent extends FieldLayoutComponent implements HasDragAndDropSettings,
HasModalConfiguration { @Override protected IsWidget generateContent(RenderingContext ctx) { LayoutComponent component = ctx.getComponent(); if (fieldRenderer == null) { initContent(component.getProperties()); } else { renderContent(); } return content; } @Inject EditorFieldLayoutComponent(FieldRendererManager fieldRendererManager,
TranslationService translationService,
FieldPropertiesRenderer propertiesRenderer,
FieldManager fieldManager,
Event<FormEditorSyncPaletteEvent> syncPaletteEvent); @Override void init(FormRenderingContext renderingContext,
FieldDefinition field); @Override String[] getSettingsKeys(); @Override void setSettingValue(String key,
String value); @Override String getSettingValue(String key); @Override Map<String, String> getMapSettings(); @Override Modal getConfigurationModal(final ModalConfigurationContext ctx); } | EditorFieldLayoutComponent extends FieldLayoutComponent implements HasDragAndDropSettings,
HasModalConfiguration { @Override protected IsWidget generateContent(RenderingContext ctx) { LayoutComponent component = ctx.getComponent(); if (fieldRenderer == null) { initContent(component.getProperties()); } else { renderContent(); } return content; } @Inject EditorFieldLayoutComponent(FieldRendererManager fieldRendererManager,
TranslationService translationService,
FieldPropertiesRenderer propertiesRenderer,
FieldManager fieldManager,
Event<FormEditorSyncPaletteEvent> syncPaletteEvent); @Override void init(FormRenderingContext renderingContext,
FieldDefinition field); @Override String[] getSettingsKeys(); @Override void setSettingValue(String key,
String value); @Override String getSettingValue(String key); @Override Map<String, String> getMapSettings(); @Override Modal getConfigurationModal(final ModalConfigurationContext ctx); final String[] SETTINGS_KEYS; } |
@Test public void testDispatch() { event.dispatch(handler); verify(handler).onMoveDividerStart(eq(event)); } | @Override protected void dispatch(final MoveDividerStartHandler handler) { handler.onMoveDividerStart(this); } | MoveDividerStartEvent extends AbstractWiresDragEvent<MoveDividerStartHandler> { @Override protected void dispatch(final MoveDividerStartHandler handler) { handler.onMoveDividerStart(this); } } | MoveDividerStartEvent extends AbstractWiresDragEvent<MoveDividerStartHandler> { @Override protected void dispatch(final MoveDividerStartHandler handler) { handler.onMoveDividerStart(this); } MoveDividerStartEvent(final DecisionServiceSVGShapeView shape,
final AbstractNodeDragEvent<?> nodeDragEvent); } | MoveDividerStartEvent extends AbstractWiresDragEvent<MoveDividerStartHandler> { @Override protected void dispatch(final MoveDividerStartHandler handler) { handler.onMoveDividerStart(this); } MoveDividerStartEvent(final DecisionServiceSVGShapeView shape,
final AbstractNodeDragEvent<?> nodeDragEvent); @Override Type<MoveDividerStartHandler> getAssociatedType(); } | MoveDividerStartEvent extends AbstractWiresDragEvent<MoveDividerStartHandler> { @Override protected void dispatch(final MoveDividerStartHandler handler) { handler.onMoveDividerStart(this); } MoveDividerStartEvent(final DecisionServiceSVGShapeView shape,
final AbstractNodeDragEvent<?> nodeDragEvent); @Override Type<MoveDividerStartHandler> getAssociatedType(); static final Type<MoveDividerStartHandler> TYPE; } |
@Test public void listWithBindableTypesTest() { PowerMockito.when(BindableProxyFactory.getBindableProxy(Obj.class)).thenReturn(new BindableProxyImpl()); Obj obj = new Obj("test"); List<Obj> asList = Arrays.asList(obj); DeepCloneHelper.doDeepCloneList(asList); verifyStatic(BindableProxyFactory.class, times(1)); BindableProxyFactory.getBindableProxy(Obj.class); verifyStatic(BindableProxyFactory.class, times(1)); BindableProxyFactory.getBindableProxy(obj); } | protected static <T> List<Object> doDeepCloneList(List<T> values) { return values.stream() .map(DeepCloneHelper::doDeepCloneListValue) .collect(Collectors.toList()); } | DeepCloneHelper { protected static <T> List<Object> doDeepCloneList(List<T> values) { return values.stream() .map(DeepCloneHelper::doDeepCloneListValue) .collect(Collectors.toList()); } } | DeepCloneHelper { protected static <T> List<Object> doDeepCloneList(List<T> values) { return values.stream() .map(DeepCloneHelper::doDeepCloneListValue) .collect(Collectors.toList()); } } | DeepCloneHelper { protected static <T> List<Object> doDeepCloneList(List<T> values) { return values.stream() .map(DeepCloneHelper::doDeepCloneListValue) .collect(Collectors.toList()); } static T deepClone(T instance); } | DeepCloneHelper { protected static <T> List<Object> doDeepCloneList(List<T> values) { return values.stream() .map(DeepCloneHelper::doDeepCloneListValue) .collect(Collectors.toList()); } static T deepClone(T instance); } |
@Test public void listWithoutBindableTypesTest() { PowerMockito.when(BindableProxyFactory.getBindableProxy(any(String.class))).thenReturn(null); String test = "test"; List<String> asList = Arrays.asList(test); DeepCloneHelper.doDeepCloneList(asList); verifyStatic(BindableProxyFactory.class, times(1)); BindableProxyFactory.getBindableProxy(String.class); verifyStatic(BindableProxyFactory.class, times(0)); BindableProxyFactory.getBindableProxy(test); } | protected static <T> List<Object> doDeepCloneList(List<T> values) { return values.stream() .map(DeepCloneHelper::doDeepCloneListValue) .collect(Collectors.toList()); } | DeepCloneHelper { protected static <T> List<Object> doDeepCloneList(List<T> values) { return values.stream() .map(DeepCloneHelper::doDeepCloneListValue) .collect(Collectors.toList()); } } | DeepCloneHelper { protected static <T> List<Object> doDeepCloneList(List<T> values) { return values.stream() .map(DeepCloneHelper::doDeepCloneListValue) .collect(Collectors.toList()); } } | DeepCloneHelper { protected static <T> List<Object> doDeepCloneList(List<T> values) { return values.stream() .map(DeepCloneHelper::doDeepCloneListValue) .collect(Collectors.toList()); } static T deepClone(T instance); } | DeepCloneHelper { protected static <T> List<Object> doDeepCloneList(List<T> values) { return values.stream() .map(DeepCloneHelper::doDeepCloneListValue) .collect(Collectors.toList()); } static T deepClone(T instance); } |
@Test public void testRender() { loadContent(); renderer.render(helper); assertSame(helper, renderer.helper); assertNotNull(renderer.fieldCopy); verify(renderer, times(1)).doCopy(any()); verify(fieldManager).getFieldFromProvider(any(), any()); } | public void render(final FieldPropertiesRendererHelper helper) { this.helper = helper; this.originalField = helper.getCurrentField(); this.fieldCopy = doCopy(originalField); this.acceptChanges = false; render(); } | FieldPropertiesRenderer implements IsWidget { public void render(final FieldPropertiesRendererHelper helper) { this.helper = helper; this.originalField = helper.getCurrentField(); this.fieldCopy = doCopy(originalField); this.acceptChanges = false; render(); } } | FieldPropertiesRenderer implements IsWidget { public void render(final FieldPropertiesRendererHelper helper) { this.helper = helper; this.originalField = helper.getCurrentField(); this.fieldCopy = doCopy(originalField); this.acceptChanges = false; render(); } @Inject FieldPropertiesRenderer(FieldPropertiesRendererView view,
DynamicFormModelGenerator dynamicFormModelGenerator,
@StaticFormModel DataBindingEditor staticDataBindingEditor,
@DynamicFormModel DataBindingEditor dynamicDataBindingEditor); } | FieldPropertiesRenderer implements IsWidget { public void render(final FieldPropertiesRendererHelper helper) { this.helper = helper; this.originalField = helper.getCurrentField(); this.fieldCopy = doCopy(originalField); this.acceptChanges = false; render(); } @Inject FieldPropertiesRenderer(FieldPropertiesRendererView view,
DynamicFormModelGenerator dynamicFormModelGenerator,
@StaticFormModel DataBindingEditor staticDataBindingEditor,
@DynamicFormModel DataBindingEditor dynamicDataBindingEditor); void render(final FieldPropertiesRendererHelper helper); @SuppressWarnings("unchecked") FieldDefinition doCopy(final FieldDefinition originalField); void onPressOk(); void onClose(); void onFieldTypeChange(final String typeCode); void onFieldBindingChange(final String bindingExpression); FieldPropertiesRendererView getView(); FieldDefinition getCurrentField(); List<String> getCompatibleFieldTypes(); @Override Widget asWidget(); } | FieldPropertiesRenderer implements IsWidget { public void render(final FieldPropertiesRendererHelper helper) { this.helper = helper; this.originalField = helper.getCurrentField(); this.fieldCopy = doCopy(originalField); this.acceptChanges = false; render(); } @Inject FieldPropertiesRenderer(FieldPropertiesRendererView view,
DynamicFormModelGenerator dynamicFormModelGenerator,
@StaticFormModel DataBindingEditor staticDataBindingEditor,
@DynamicFormModel DataBindingEditor dynamicDataBindingEditor); void render(final FieldPropertiesRendererHelper helper); @SuppressWarnings("unchecked") FieldDefinition doCopy(final FieldDefinition originalField); void onPressOk(); void onClose(); void onFieldTypeChange(final String typeCode); void onFieldBindingChange(final String bindingExpression); FieldPropertiesRendererView getView(); FieldDefinition getCurrentField(); List<String> getCompatibleFieldTypes(); @Override Widget asWidget(); } |
@Test public void testOnFieldTypeChange() { testRender(); when(helper.onFieldTypeChange(any(), anyString())).thenReturn(lastNameField); renderer.onFieldTypeChange(TYPE_CODE); verify(helper).onFieldTypeChange(renderer.fieldCopy, TYPE_CODE); verify(renderer, atLeastOnce()).render(); } | public void onFieldTypeChange(final String typeCode) { fieldCopy = helper.onFieldTypeChange(unwrap(fieldCopy), typeCode); render(); } | FieldPropertiesRenderer implements IsWidget { public void onFieldTypeChange(final String typeCode) { fieldCopy = helper.onFieldTypeChange(unwrap(fieldCopy), typeCode); render(); } } | FieldPropertiesRenderer implements IsWidget { public void onFieldTypeChange(final String typeCode) { fieldCopy = helper.onFieldTypeChange(unwrap(fieldCopy), typeCode); render(); } @Inject FieldPropertiesRenderer(FieldPropertiesRendererView view,
DynamicFormModelGenerator dynamicFormModelGenerator,
@StaticFormModel DataBindingEditor staticDataBindingEditor,
@DynamicFormModel DataBindingEditor dynamicDataBindingEditor); } | FieldPropertiesRenderer implements IsWidget { public void onFieldTypeChange(final String typeCode) { fieldCopy = helper.onFieldTypeChange(unwrap(fieldCopy), typeCode); render(); } @Inject FieldPropertiesRenderer(FieldPropertiesRendererView view,
DynamicFormModelGenerator dynamicFormModelGenerator,
@StaticFormModel DataBindingEditor staticDataBindingEditor,
@DynamicFormModel DataBindingEditor dynamicDataBindingEditor); void render(final FieldPropertiesRendererHelper helper); @SuppressWarnings("unchecked") FieldDefinition doCopy(final FieldDefinition originalField); void onPressOk(); void onClose(); void onFieldTypeChange(final String typeCode); void onFieldBindingChange(final String bindingExpression); FieldPropertiesRendererView getView(); FieldDefinition getCurrentField(); List<String> getCompatibleFieldTypes(); @Override Widget asWidget(); } | FieldPropertiesRenderer implements IsWidget { public void onFieldTypeChange(final String typeCode) { fieldCopy = helper.onFieldTypeChange(unwrap(fieldCopy), typeCode); render(); } @Inject FieldPropertiesRenderer(FieldPropertiesRendererView view,
DynamicFormModelGenerator dynamicFormModelGenerator,
@StaticFormModel DataBindingEditor staticDataBindingEditor,
@DynamicFormModel DataBindingEditor dynamicDataBindingEditor); void render(final FieldPropertiesRendererHelper helper); @SuppressWarnings("unchecked") FieldDefinition doCopy(final FieldDefinition originalField); void onPressOk(); void onClose(); void onFieldTypeChange(final String typeCode); void onFieldBindingChange(final String bindingExpression); FieldPropertiesRendererView getView(); FieldDefinition getCurrentField(); List<String> getCompatibleFieldTypes(); @Override Widget asWidget(); } |
@Test public void testOnFieldBindingChange() { testRender(); when(helper.onFieldBindingChange(any(), anyString())).thenReturn(lastNameField); renderer.onFieldBindingChange(lastNameField.getId()); verify(helper).onFieldBindingChange(renderer.fieldCopy, lastNameField.getId()); verify(renderer, atLeastOnce()).render(); } | public void onFieldBindingChange(final String bindingExpression) { fieldCopy = helper.onFieldBindingChange(fieldCopy, bindingExpression); render(); } | FieldPropertiesRenderer implements IsWidget { public void onFieldBindingChange(final String bindingExpression) { fieldCopy = helper.onFieldBindingChange(fieldCopy, bindingExpression); render(); } } | FieldPropertiesRenderer implements IsWidget { public void onFieldBindingChange(final String bindingExpression) { fieldCopy = helper.onFieldBindingChange(fieldCopy, bindingExpression); render(); } @Inject FieldPropertiesRenderer(FieldPropertiesRendererView view,
DynamicFormModelGenerator dynamicFormModelGenerator,
@StaticFormModel DataBindingEditor staticDataBindingEditor,
@DynamicFormModel DataBindingEditor dynamicDataBindingEditor); } | FieldPropertiesRenderer implements IsWidget { public void onFieldBindingChange(final String bindingExpression) { fieldCopy = helper.onFieldBindingChange(fieldCopy, bindingExpression); render(); } @Inject FieldPropertiesRenderer(FieldPropertiesRendererView view,
DynamicFormModelGenerator dynamicFormModelGenerator,
@StaticFormModel DataBindingEditor staticDataBindingEditor,
@DynamicFormModel DataBindingEditor dynamicDataBindingEditor); void render(final FieldPropertiesRendererHelper helper); @SuppressWarnings("unchecked") FieldDefinition doCopy(final FieldDefinition originalField); void onPressOk(); void onClose(); void onFieldTypeChange(final String typeCode); void onFieldBindingChange(final String bindingExpression); FieldPropertiesRendererView getView(); FieldDefinition getCurrentField(); List<String> getCompatibleFieldTypes(); @Override Widget asWidget(); } | FieldPropertiesRenderer implements IsWidget { public void onFieldBindingChange(final String bindingExpression) { fieldCopy = helper.onFieldBindingChange(fieldCopy, bindingExpression); render(); } @Inject FieldPropertiesRenderer(FieldPropertiesRendererView view,
DynamicFormModelGenerator dynamicFormModelGenerator,
@StaticFormModel DataBindingEditor staticDataBindingEditor,
@DynamicFormModel DataBindingEditor dynamicDataBindingEditor); void render(final FieldPropertiesRendererHelper helper); @SuppressWarnings("unchecked") FieldDefinition doCopy(final FieldDefinition originalField); void onPressOk(); void onClose(); void onFieldTypeChange(final String typeCode); void onFieldBindingChange(final String bindingExpression); FieldPropertiesRendererView getView(); FieldDefinition getCurrentField(); List<String> getCompatibleFieldTypes(); @Override Widget asWidget(); } |
@Test public void testGetView() { loadContent(); assertSame(view, renderer.getView()); } | public FieldPropertiesRendererView getView() { return view; } | FieldPropertiesRenderer implements IsWidget { public FieldPropertiesRendererView getView() { return view; } } | FieldPropertiesRenderer implements IsWidget { public FieldPropertiesRendererView getView() { return view; } @Inject FieldPropertiesRenderer(FieldPropertiesRendererView view,
DynamicFormModelGenerator dynamicFormModelGenerator,
@StaticFormModel DataBindingEditor staticDataBindingEditor,
@DynamicFormModel DataBindingEditor dynamicDataBindingEditor); } | FieldPropertiesRenderer implements IsWidget { public FieldPropertiesRendererView getView() { return view; } @Inject FieldPropertiesRenderer(FieldPropertiesRendererView view,
DynamicFormModelGenerator dynamicFormModelGenerator,
@StaticFormModel DataBindingEditor staticDataBindingEditor,
@DynamicFormModel DataBindingEditor dynamicDataBindingEditor); void render(final FieldPropertiesRendererHelper helper); @SuppressWarnings("unchecked") FieldDefinition doCopy(final FieldDefinition originalField); void onPressOk(); void onClose(); void onFieldTypeChange(final String typeCode); void onFieldBindingChange(final String bindingExpression); FieldPropertiesRendererView getView(); FieldDefinition getCurrentField(); List<String> getCompatibleFieldTypes(); @Override Widget asWidget(); } | FieldPropertiesRenderer implements IsWidget { public FieldPropertiesRendererView getView() { return view; } @Inject FieldPropertiesRenderer(FieldPropertiesRendererView view,
DynamicFormModelGenerator dynamicFormModelGenerator,
@StaticFormModel DataBindingEditor staticDataBindingEditor,
@DynamicFormModel DataBindingEditor dynamicDataBindingEditor); void render(final FieldPropertiesRendererHelper helper); @SuppressWarnings("unchecked") FieldDefinition doCopy(final FieldDefinition originalField); void onPressOk(); void onClose(); void onFieldTypeChange(final String typeCode); void onFieldBindingChange(final String bindingExpression); FieldPropertiesRendererView getView(); FieldDefinition getCurrentField(); List<String> getCompatibleFieldTypes(); @Override Widget asWidget(); } |
@Test public void testAsWidget() { loadContent(); renderer.asWidget(); verify(view).asWidget(); } | @Override public Widget asWidget() { return view.asWidget(); } | FieldPropertiesRenderer implements IsWidget { @Override public Widget asWidget() { return view.asWidget(); } } | FieldPropertiesRenderer implements IsWidget { @Override public Widget asWidget() { return view.asWidget(); } @Inject FieldPropertiesRenderer(FieldPropertiesRendererView view,
DynamicFormModelGenerator dynamicFormModelGenerator,
@StaticFormModel DataBindingEditor staticDataBindingEditor,
@DynamicFormModel DataBindingEditor dynamicDataBindingEditor); } | FieldPropertiesRenderer implements IsWidget { @Override public Widget asWidget() { return view.asWidget(); } @Inject FieldPropertiesRenderer(FieldPropertiesRendererView view,
DynamicFormModelGenerator dynamicFormModelGenerator,
@StaticFormModel DataBindingEditor staticDataBindingEditor,
@DynamicFormModel DataBindingEditor dynamicDataBindingEditor); void render(final FieldPropertiesRendererHelper helper); @SuppressWarnings("unchecked") FieldDefinition doCopy(final FieldDefinition originalField); void onPressOk(); void onClose(); void onFieldTypeChange(final String typeCode); void onFieldBindingChange(final String bindingExpression); FieldPropertiesRendererView getView(); FieldDefinition getCurrentField(); List<String> getCompatibleFieldTypes(); @Override Widget asWidget(); } | FieldPropertiesRenderer implements IsWidget { @Override public Widget asWidget() { return view.asWidget(); } @Inject FieldPropertiesRenderer(FieldPropertiesRendererView view,
DynamicFormModelGenerator dynamicFormModelGenerator,
@StaticFormModel DataBindingEditor staticDataBindingEditor,
@DynamicFormModel DataBindingEditor dynamicDataBindingEditor); void render(final FieldPropertiesRendererHelper helper); @SuppressWarnings("unchecked") FieldDefinition doCopy(final FieldDefinition originalField); void onPressOk(); void onClose(); void onFieldTypeChange(final String typeCode); void onFieldBindingChange(final String bindingExpression); FieldPropertiesRendererView getView(); FieldDefinition getCurrentField(); List<String> getCompatibleFieldTypes(); @Override Widget asWidget(); } |
@Test public void testGenerateUnboundFieldName() { String fieldName = formEditorHelper.generateUnboundFieldName(nameField); assertEquals(fieldName, FormEditorHelper.UNBOUND_FIELD_NAME_PREFFIX + nameField.getId()); } | public String generateUnboundFieldName(FieldDefinition field) { return UNBOUND_FIELD_NAME_PREFFIX + field.getId(); } | FormEditorHelper { public String generateUnboundFieldName(FieldDefinition field) { return UNBOUND_FIELD_NAME_PREFFIX + field.getId(); } } | FormEditorHelper { public String generateUnboundFieldName(FieldDefinition field) { return UNBOUND_FIELD_NAME_PREFFIX + field.getId(); } @Inject FormEditorHelper(FieldManager fieldManager,
ManagedInstance<EditorFieldLayoutComponent> editorFieldLayoutComponents,
SyncBeanManager beanManager); } | FormEditorHelper { public String generateUnboundFieldName(FieldDefinition field) { return UNBOUND_FIELD_NAME_PREFFIX + field.getId(); } @Inject FormEditorHelper(FieldManager fieldManager,
ManagedInstance<EditorFieldLayoutComponent> editorFieldLayoutComponents,
SyncBeanManager beanManager); FormModelerContent getContent(); void initHelper(FormModelerContent content); FormDefinition getFormDefinition(); FormModel getFormModel(); void addAvailableFields(); void addAvailableField(FieldDefinition field); void removeAvailableField(FieldDefinition field); FieldDefinition getFormField(String fieldId); void removeField(String fieldId,
boolean addToAvailables); boolean modelContainsField(FieldDefinition fieldDefinition); List<String> getCompatibleModelFields(FieldDefinition field); List<String> getCompatibleFieldTypes(FieldDefinition field); FieldDefinition switchToField(FieldDefinition originalField,
String newBinding); FieldDefinition switchToFieldType(FieldDefinition field,
String fieldCode); void saveFormField(FieldDefinition originalField,
FieldDefinition fieldCopy); String generateUnboundFieldName(FieldDefinition field); Collection<EditorFieldLayoutComponent> getBaseFieldsDraggables(); Map<String, FieldDefinition> getAvailableFields(); FormEditorRenderingContext getRenderingContext(); @PreDestroy void destroy(); } | FormEditorHelper { public String generateUnboundFieldName(FieldDefinition field) { return UNBOUND_FIELD_NAME_PREFFIX + field.getId(); } @Inject FormEditorHelper(FieldManager fieldManager,
ManagedInstance<EditorFieldLayoutComponent> editorFieldLayoutComponents,
SyncBeanManager beanManager); FormModelerContent getContent(); void initHelper(FormModelerContent content); FormDefinition getFormDefinition(); FormModel getFormModel(); void addAvailableFields(); void addAvailableField(FieldDefinition field); void removeAvailableField(FieldDefinition field); FieldDefinition getFormField(String fieldId); void removeField(String fieldId,
boolean addToAvailables); boolean modelContainsField(FieldDefinition fieldDefinition); List<String> getCompatibleModelFields(FieldDefinition field); List<String> getCompatibleFieldTypes(FieldDefinition field); FieldDefinition switchToField(FieldDefinition originalField,
String newBinding); FieldDefinition switchToFieldType(FieldDefinition field,
String fieldCode); void saveFormField(FieldDefinition originalField,
FieldDefinition fieldCopy); String generateUnboundFieldName(FieldDefinition field); Collection<EditorFieldLayoutComponent> getBaseFieldsDraggables(); Map<String, FieldDefinition> getAvailableFields(); FormEditorRenderingContext getRenderingContext(); @PreDestroy void destroy(); static final String UNBOUND_FIELD_NAME_PREFFIX; } |
@Test public void testGetContent() { FormModelerContent resContent = formEditorHelper.getContent(); assertEquals(resContent, content); } | public FormModelerContent getContent() { return content; } | FormEditorHelper { public FormModelerContent getContent() { return content; } } | FormEditorHelper { public FormModelerContent getContent() { return content; } @Inject FormEditorHelper(FieldManager fieldManager,
ManagedInstance<EditorFieldLayoutComponent> editorFieldLayoutComponents,
SyncBeanManager beanManager); } | FormEditorHelper { public FormModelerContent getContent() { return content; } @Inject FormEditorHelper(FieldManager fieldManager,
ManagedInstance<EditorFieldLayoutComponent> editorFieldLayoutComponents,
SyncBeanManager beanManager); FormModelerContent getContent(); void initHelper(FormModelerContent content); FormDefinition getFormDefinition(); FormModel getFormModel(); void addAvailableFields(); void addAvailableField(FieldDefinition field); void removeAvailableField(FieldDefinition field); FieldDefinition getFormField(String fieldId); void removeField(String fieldId,
boolean addToAvailables); boolean modelContainsField(FieldDefinition fieldDefinition); List<String> getCompatibleModelFields(FieldDefinition field); List<String> getCompatibleFieldTypes(FieldDefinition field); FieldDefinition switchToField(FieldDefinition originalField,
String newBinding); FieldDefinition switchToFieldType(FieldDefinition field,
String fieldCode); void saveFormField(FieldDefinition originalField,
FieldDefinition fieldCopy); String generateUnboundFieldName(FieldDefinition field); Collection<EditorFieldLayoutComponent> getBaseFieldsDraggables(); Map<String, FieldDefinition> getAvailableFields(); FormEditorRenderingContext getRenderingContext(); @PreDestroy void destroy(); } | FormEditorHelper { public FormModelerContent getContent() { return content; } @Inject FormEditorHelper(FieldManager fieldManager,
ManagedInstance<EditorFieldLayoutComponent> editorFieldLayoutComponents,
SyncBeanManager beanManager); FormModelerContent getContent(); void initHelper(FormModelerContent content); FormDefinition getFormDefinition(); FormModel getFormModel(); void addAvailableFields(); void addAvailableField(FieldDefinition field); void removeAvailableField(FieldDefinition field); FieldDefinition getFormField(String fieldId); void removeField(String fieldId,
boolean addToAvailables); boolean modelContainsField(FieldDefinition fieldDefinition); List<String> getCompatibleModelFields(FieldDefinition field); List<String> getCompatibleFieldTypes(FieldDefinition field); FieldDefinition switchToField(FieldDefinition originalField,
String newBinding); FieldDefinition switchToFieldType(FieldDefinition field,
String fieldCode); void saveFormField(FieldDefinition originalField,
FieldDefinition fieldCopy); String generateUnboundFieldName(FieldDefinition field); Collection<EditorFieldLayoutComponent> getBaseFieldsDraggables(); Map<String, FieldDefinition> getAvailableFields(); FormEditorRenderingContext getRenderingContext(); @PreDestroy void destroy(); static final String UNBOUND_FIELD_NAME_PREFFIX; } |
@Test public void testGetFormDefinition() { FormDefinition formDefinition = formEditorHelper.getFormDefinition(); assertEquals(formDefinition, content.getDefinition()); } | public FormDefinition getFormDefinition() { return content.getDefinition(); } | FormEditorHelper { public FormDefinition getFormDefinition() { return content.getDefinition(); } } | FormEditorHelper { public FormDefinition getFormDefinition() { return content.getDefinition(); } @Inject FormEditorHelper(FieldManager fieldManager,
ManagedInstance<EditorFieldLayoutComponent> editorFieldLayoutComponents,
SyncBeanManager beanManager); } | FormEditorHelper { public FormDefinition getFormDefinition() { return content.getDefinition(); } @Inject FormEditorHelper(FieldManager fieldManager,
ManagedInstance<EditorFieldLayoutComponent> editorFieldLayoutComponents,
SyncBeanManager beanManager); FormModelerContent getContent(); void initHelper(FormModelerContent content); FormDefinition getFormDefinition(); FormModel getFormModel(); void addAvailableFields(); void addAvailableField(FieldDefinition field); void removeAvailableField(FieldDefinition field); FieldDefinition getFormField(String fieldId); void removeField(String fieldId,
boolean addToAvailables); boolean modelContainsField(FieldDefinition fieldDefinition); List<String> getCompatibleModelFields(FieldDefinition field); List<String> getCompatibleFieldTypes(FieldDefinition field); FieldDefinition switchToField(FieldDefinition originalField,
String newBinding); FieldDefinition switchToFieldType(FieldDefinition field,
String fieldCode); void saveFormField(FieldDefinition originalField,
FieldDefinition fieldCopy); String generateUnboundFieldName(FieldDefinition field); Collection<EditorFieldLayoutComponent> getBaseFieldsDraggables(); Map<String, FieldDefinition> getAvailableFields(); FormEditorRenderingContext getRenderingContext(); @PreDestroy void destroy(); } | FormEditorHelper { public FormDefinition getFormDefinition() { return content.getDefinition(); } @Inject FormEditorHelper(FieldManager fieldManager,
ManagedInstance<EditorFieldLayoutComponent> editorFieldLayoutComponents,
SyncBeanManager beanManager); FormModelerContent getContent(); void initHelper(FormModelerContent content); FormDefinition getFormDefinition(); FormModel getFormModel(); void addAvailableFields(); void addAvailableField(FieldDefinition field); void removeAvailableField(FieldDefinition field); FieldDefinition getFormField(String fieldId); void removeField(String fieldId,
boolean addToAvailables); boolean modelContainsField(FieldDefinition fieldDefinition); List<String> getCompatibleModelFields(FieldDefinition field); List<String> getCompatibleFieldTypes(FieldDefinition field); FieldDefinition switchToField(FieldDefinition originalField,
String newBinding); FieldDefinition switchToFieldType(FieldDefinition field,
String fieldCode); void saveFormField(FieldDefinition originalField,
FieldDefinition fieldCopy); String generateUnboundFieldName(FieldDefinition field); Collection<EditorFieldLayoutComponent> getBaseFieldsDraggables(); Map<String, FieldDefinition> getAvailableFields(); FormEditorRenderingContext getRenderingContext(); @PreDestroy void destroy(); static final String UNBOUND_FIELD_NAME_PREFFIX; } |
@Test public void testGetAssociatedType() { assertThat(event.getAssociatedType()).isEqualTo(MoveDividerStepEvent.TYPE); } | @Override public Type<MoveDividerStepHandler> getAssociatedType() { return TYPE; } | MoveDividerStepEvent extends AbstractWiresDragEvent<MoveDividerStepHandler> { @Override public Type<MoveDividerStepHandler> getAssociatedType() { return TYPE; } } | MoveDividerStepEvent extends AbstractWiresDragEvent<MoveDividerStepHandler> { @Override public Type<MoveDividerStepHandler> getAssociatedType() { return TYPE; } MoveDividerStepEvent(final DecisionServiceSVGShapeView shape,
final AbstractNodeDragEvent<?> nodeDragEvent); } | MoveDividerStepEvent extends AbstractWiresDragEvent<MoveDividerStepHandler> { @Override public Type<MoveDividerStepHandler> getAssociatedType() { return TYPE; } MoveDividerStepEvent(final DecisionServiceSVGShapeView shape,
final AbstractNodeDragEvent<?> nodeDragEvent); @Override Type<MoveDividerStepHandler> getAssociatedType(); } | MoveDividerStepEvent extends AbstractWiresDragEvent<MoveDividerStepHandler> { @Override public Type<MoveDividerStepHandler> getAssociatedType() { return TYPE; } MoveDividerStepEvent(final DecisionServiceSVGShapeView shape,
final AbstractNodeDragEvent<?> nodeDragEvent); @Override Type<MoveDividerStepHandler> getAssociatedType(); static final Type<MoveDividerStepHandler> TYPE; } |
@Test public void testGetRenderingContext() { FormEditorRenderingContext renderingContext = formEditorHelper.getRenderingContext(); assertEquals(renderingContext, content.getRenderingContext()); } | public FormEditorRenderingContext getRenderingContext() { return content.getRenderingContext(); } | FormEditorHelper { public FormEditorRenderingContext getRenderingContext() { return content.getRenderingContext(); } } | FormEditorHelper { public FormEditorRenderingContext getRenderingContext() { return content.getRenderingContext(); } @Inject FormEditorHelper(FieldManager fieldManager,
ManagedInstance<EditorFieldLayoutComponent> editorFieldLayoutComponents,
SyncBeanManager beanManager); } | FormEditorHelper { public FormEditorRenderingContext getRenderingContext() { return content.getRenderingContext(); } @Inject FormEditorHelper(FieldManager fieldManager,
ManagedInstance<EditorFieldLayoutComponent> editorFieldLayoutComponents,
SyncBeanManager beanManager); FormModelerContent getContent(); void initHelper(FormModelerContent content); FormDefinition getFormDefinition(); FormModel getFormModel(); void addAvailableFields(); void addAvailableField(FieldDefinition field); void removeAvailableField(FieldDefinition field); FieldDefinition getFormField(String fieldId); void removeField(String fieldId,
boolean addToAvailables); boolean modelContainsField(FieldDefinition fieldDefinition); List<String> getCompatibleModelFields(FieldDefinition field); List<String> getCompatibleFieldTypes(FieldDefinition field); FieldDefinition switchToField(FieldDefinition originalField,
String newBinding); FieldDefinition switchToFieldType(FieldDefinition field,
String fieldCode); void saveFormField(FieldDefinition originalField,
FieldDefinition fieldCopy); String generateUnboundFieldName(FieldDefinition field); Collection<EditorFieldLayoutComponent> getBaseFieldsDraggables(); Map<String, FieldDefinition> getAvailableFields(); FormEditorRenderingContext getRenderingContext(); @PreDestroy void destroy(); } | FormEditorHelper { public FormEditorRenderingContext getRenderingContext() { return content.getRenderingContext(); } @Inject FormEditorHelper(FieldManager fieldManager,
ManagedInstance<EditorFieldLayoutComponent> editorFieldLayoutComponents,
SyncBeanManager beanManager); FormModelerContent getContent(); void initHelper(FormModelerContent content); FormDefinition getFormDefinition(); FormModel getFormModel(); void addAvailableFields(); void addAvailableField(FieldDefinition field); void removeAvailableField(FieldDefinition field); FieldDefinition getFormField(String fieldId); void removeField(String fieldId,
boolean addToAvailables); boolean modelContainsField(FieldDefinition fieldDefinition); List<String> getCompatibleModelFields(FieldDefinition field); List<String> getCompatibleFieldTypes(FieldDefinition field); FieldDefinition switchToField(FieldDefinition originalField,
String newBinding); FieldDefinition switchToFieldType(FieldDefinition field,
String fieldCode); void saveFormField(FieldDefinition originalField,
FieldDefinition fieldCopy); String generateUnboundFieldName(FieldDefinition field); Collection<EditorFieldLayoutComponent> getBaseFieldsDraggables(); Map<String, FieldDefinition> getAvailableFields(); FormEditorRenderingContext getRenderingContext(); @PreDestroy void destroy(); static final String UNBOUND_FIELD_NAME_PREFFIX; } |
@Test public void testGetAvailableFields() { Map<String, FieldDefinition> availableFields = formEditorHelper.getAvailableFields(); assertEquals("There should be no available field", employeeFields.size(), availableFields.size()); } | public Map<String, FieldDefinition> getAvailableFields() { return availableFields; } | FormEditorHelper { public Map<String, FieldDefinition> getAvailableFields() { return availableFields; } } | FormEditorHelper { public Map<String, FieldDefinition> getAvailableFields() { return availableFields; } @Inject FormEditorHelper(FieldManager fieldManager,
ManagedInstance<EditorFieldLayoutComponent> editorFieldLayoutComponents,
SyncBeanManager beanManager); } | FormEditorHelper { public Map<String, FieldDefinition> getAvailableFields() { return availableFields; } @Inject FormEditorHelper(FieldManager fieldManager,
ManagedInstance<EditorFieldLayoutComponent> editorFieldLayoutComponents,
SyncBeanManager beanManager); FormModelerContent getContent(); void initHelper(FormModelerContent content); FormDefinition getFormDefinition(); FormModel getFormModel(); void addAvailableFields(); void addAvailableField(FieldDefinition field); void removeAvailableField(FieldDefinition field); FieldDefinition getFormField(String fieldId); void removeField(String fieldId,
boolean addToAvailables); boolean modelContainsField(FieldDefinition fieldDefinition); List<String> getCompatibleModelFields(FieldDefinition field); List<String> getCompatibleFieldTypes(FieldDefinition field); FieldDefinition switchToField(FieldDefinition originalField,
String newBinding); FieldDefinition switchToFieldType(FieldDefinition field,
String fieldCode); void saveFormField(FieldDefinition originalField,
FieldDefinition fieldCopy); String generateUnboundFieldName(FieldDefinition field); Collection<EditorFieldLayoutComponent> getBaseFieldsDraggables(); Map<String, FieldDefinition> getAvailableFields(); FormEditorRenderingContext getRenderingContext(); @PreDestroy void destroy(); } | FormEditorHelper { public Map<String, FieldDefinition> getAvailableFields() { return availableFields; } @Inject FormEditorHelper(FieldManager fieldManager,
ManagedInstance<EditorFieldLayoutComponent> editorFieldLayoutComponents,
SyncBeanManager beanManager); FormModelerContent getContent(); void initHelper(FormModelerContent content); FormDefinition getFormDefinition(); FormModel getFormModel(); void addAvailableFields(); void addAvailableField(FieldDefinition field); void removeAvailableField(FieldDefinition field); FieldDefinition getFormField(String fieldId); void removeField(String fieldId,
boolean addToAvailables); boolean modelContainsField(FieldDefinition fieldDefinition); List<String> getCompatibleModelFields(FieldDefinition field); List<String> getCompatibleFieldTypes(FieldDefinition field); FieldDefinition switchToField(FieldDefinition originalField,
String newBinding); FieldDefinition switchToFieldType(FieldDefinition field,
String fieldCode); void saveFormField(FieldDefinition originalField,
FieldDefinition fieldCopy); String generateUnboundFieldName(FieldDefinition field); Collection<EditorFieldLayoutComponent> getBaseFieldsDraggables(); Map<String, FieldDefinition> getAvailableFields(); FormEditorRenderingContext getRenderingContext(); @PreDestroy void destroy(); static final String UNBOUND_FIELD_NAME_PREFFIX; } |
@Test public void testGetFormField() { when(formDefinition.getFieldById(anyString())).thenReturn(nameField); content.setDefinition(formDefinition); FieldDefinition formField = formEditorHelper.getFormField(nameField.getId()); assertEquals(formField, nameField); } | public FieldDefinition getFormField(String fieldId) { FieldDefinition result = content.getDefinition().getFieldById(fieldId); if (result == null) { result = availableFields.get(fieldId); if (result == null) { if (unbindedFields.containsKey(fieldId)) { Pair<EditorFieldLayoutComponent, FieldDefinition> pair = unbindedFields.get(fieldId); result = pair.getK2(); result.setLabel(result.getFieldType().getTypeName()); if (result instanceof HasPlaceHolder) { ((HasPlaceHolder) result).setPlaceHolder(result.getFieldType().getTypeName()); } unbindedFields.remove(result.getId()); FieldDefinition newField = fieldManager.getDefinitionByFieldType(result.getFieldType()); newField.setName(generateUnboundFieldName(newField)); EditorFieldLayoutComponent component = pair.getK1(); component.init(content.getRenderingContext(), newField); unbindedFields.put(newField.getId(), new Pair<>(component, newField)); } } } return result; } | FormEditorHelper { public FieldDefinition getFormField(String fieldId) { FieldDefinition result = content.getDefinition().getFieldById(fieldId); if (result == null) { result = availableFields.get(fieldId); if (result == null) { if (unbindedFields.containsKey(fieldId)) { Pair<EditorFieldLayoutComponent, FieldDefinition> pair = unbindedFields.get(fieldId); result = pair.getK2(); result.setLabel(result.getFieldType().getTypeName()); if (result instanceof HasPlaceHolder) { ((HasPlaceHolder) result).setPlaceHolder(result.getFieldType().getTypeName()); } unbindedFields.remove(result.getId()); FieldDefinition newField = fieldManager.getDefinitionByFieldType(result.getFieldType()); newField.setName(generateUnboundFieldName(newField)); EditorFieldLayoutComponent component = pair.getK1(); component.init(content.getRenderingContext(), newField); unbindedFields.put(newField.getId(), new Pair<>(component, newField)); } } } return result; } } | FormEditorHelper { public FieldDefinition getFormField(String fieldId) { FieldDefinition result = content.getDefinition().getFieldById(fieldId); if (result == null) { result = availableFields.get(fieldId); if (result == null) { if (unbindedFields.containsKey(fieldId)) { Pair<EditorFieldLayoutComponent, FieldDefinition> pair = unbindedFields.get(fieldId); result = pair.getK2(); result.setLabel(result.getFieldType().getTypeName()); if (result instanceof HasPlaceHolder) { ((HasPlaceHolder) result).setPlaceHolder(result.getFieldType().getTypeName()); } unbindedFields.remove(result.getId()); FieldDefinition newField = fieldManager.getDefinitionByFieldType(result.getFieldType()); newField.setName(generateUnboundFieldName(newField)); EditorFieldLayoutComponent component = pair.getK1(); component.init(content.getRenderingContext(), newField); unbindedFields.put(newField.getId(), new Pair<>(component, newField)); } } } return result; } @Inject FormEditorHelper(FieldManager fieldManager,
ManagedInstance<EditorFieldLayoutComponent> editorFieldLayoutComponents,
SyncBeanManager beanManager); } | FormEditorHelper { public FieldDefinition getFormField(String fieldId) { FieldDefinition result = content.getDefinition().getFieldById(fieldId); if (result == null) { result = availableFields.get(fieldId); if (result == null) { if (unbindedFields.containsKey(fieldId)) { Pair<EditorFieldLayoutComponent, FieldDefinition> pair = unbindedFields.get(fieldId); result = pair.getK2(); result.setLabel(result.getFieldType().getTypeName()); if (result instanceof HasPlaceHolder) { ((HasPlaceHolder) result).setPlaceHolder(result.getFieldType().getTypeName()); } unbindedFields.remove(result.getId()); FieldDefinition newField = fieldManager.getDefinitionByFieldType(result.getFieldType()); newField.setName(generateUnboundFieldName(newField)); EditorFieldLayoutComponent component = pair.getK1(); component.init(content.getRenderingContext(), newField); unbindedFields.put(newField.getId(), new Pair<>(component, newField)); } } } return result; } @Inject FormEditorHelper(FieldManager fieldManager,
ManagedInstance<EditorFieldLayoutComponent> editorFieldLayoutComponents,
SyncBeanManager beanManager); FormModelerContent getContent(); void initHelper(FormModelerContent content); FormDefinition getFormDefinition(); FormModel getFormModel(); void addAvailableFields(); void addAvailableField(FieldDefinition field); void removeAvailableField(FieldDefinition field); FieldDefinition getFormField(String fieldId); void removeField(String fieldId,
boolean addToAvailables); boolean modelContainsField(FieldDefinition fieldDefinition); List<String> getCompatibleModelFields(FieldDefinition field); List<String> getCompatibleFieldTypes(FieldDefinition field); FieldDefinition switchToField(FieldDefinition originalField,
String newBinding); FieldDefinition switchToFieldType(FieldDefinition field,
String fieldCode); void saveFormField(FieldDefinition originalField,
FieldDefinition fieldCopy); String generateUnboundFieldName(FieldDefinition field); Collection<EditorFieldLayoutComponent> getBaseFieldsDraggables(); Map<String, FieldDefinition> getAvailableFields(); FormEditorRenderingContext getRenderingContext(); @PreDestroy void destroy(); } | FormEditorHelper { public FieldDefinition getFormField(String fieldId) { FieldDefinition result = content.getDefinition().getFieldById(fieldId); if (result == null) { result = availableFields.get(fieldId); if (result == null) { if (unbindedFields.containsKey(fieldId)) { Pair<EditorFieldLayoutComponent, FieldDefinition> pair = unbindedFields.get(fieldId); result = pair.getK2(); result.setLabel(result.getFieldType().getTypeName()); if (result instanceof HasPlaceHolder) { ((HasPlaceHolder) result).setPlaceHolder(result.getFieldType().getTypeName()); } unbindedFields.remove(result.getId()); FieldDefinition newField = fieldManager.getDefinitionByFieldType(result.getFieldType()); newField.setName(generateUnboundFieldName(newField)); EditorFieldLayoutComponent component = pair.getK1(); component.init(content.getRenderingContext(), newField); unbindedFields.put(newField.getId(), new Pair<>(component, newField)); } } } return result; } @Inject FormEditorHelper(FieldManager fieldManager,
ManagedInstance<EditorFieldLayoutComponent> editorFieldLayoutComponents,
SyncBeanManager beanManager); FormModelerContent getContent(); void initHelper(FormModelerContent content); FormDefinition getFormDefinition(); FormModel getFormModel(); void addAvailableFields(); void addAvailableField(FieldDefinition field); void removeAvailableField(FieldDefinition field); FieldDefinition getFormField(String fieldId); void removeField(String fieldId,
boolean addToAvailables); boolean modelContainsField(FieldDefinition fieldDefinition); List<String> getCompatibleModelFields(FieldDefinition field); List<String> getCompatibleFieldTypes(FieldDefinition field); FieldDefinition switchToField(FieldDefinition originalField,
String newBinding); FieldDefinition switchToFieldType(FieldDefinition field,
String fieldCode); void saveFormField(FieldDefinition originalField,
FieldDefinition fieldCopy); String generateUnboundFieldName(FieldDefinition field); Collection<EditorFieldLayoutComponent> getBaseFieldsDraggables(); Map<String, FieldDefinition> getAvailableFields(); FormEditorRenderingContext getRenderingContext(); @PreDestroy void destroy(); static final String UNBOUND_FIELD_NAME_PREFFIX; } |
@Test public void testGetBaseFieldsDraggables() { Collection<EditorFieldLayoutComponent> draggables = formEditorHelper.getBaseFieldsDraggables(); assertNotNull(draggables); assertFalse(draggables.isEmpty()); } | public Collection<EditorFieldLayoutComponent> getBaseFieldsDraggables() { return unbindedFields.values().stream().map(Pair::getK1).collect(Collectors.toList()); } | FormEditorHelper { public Collection<EditorFieldLayoutComponent> getBaseFieldsDraggables() { return unbindedFields.values().stream().map(Pair::getK1).collect(Collectors.toList()); } } | FormEditorHelper { public Collection<EditorFieldLayoutComponent> getBaseFieldsDraggables() { return unbindedFields.values().stream().map(Pair::getK1).collect(Collectors.toList()); } @Inject FormEditorHelper(FieldManager fieldManager,
ManagedInstance<EditorFieldLayoutComponent> editorFieldLayoutComponents,
SyncBeanManager beanManager); } | FormEditorHelper { public Collection<EditorFieldLayoutComponent> getBaseFieldsDraggables() { return unbindedFields.values().stream().map(Pair::getK1).collect(Collectors.toList()); } @Inject FormEditorHelper(FieldManager fieldManager,
ManagedInstance<EditorFieldLayoutComponent> editorFieldLayoutComponents,
SyncBeanManager beanManager); FormModelerContent getContent(); void initHelper(FormModelerContent content); FormDefinition getFormDefinition(); FormModel getFormModel(); void addAvailableFields(); void addAvailableField(FieldDefinition field); void removeAvailableField(FieldDefinition field); FieldDefinition getFormField(String fieldId); void removeField(String fieldId,
boolean addToAvailables); boolean modelContainsField(FieldDefinition fieldDefinition); List<String> getCompatibleModelFields(FieldDefinition field); List<String> getCompatibleFieldTypes(FieldDefinition field); FieldDefinition switchToField(FieldDefinition originalField,
String newBinding); FieldDefinition switchToFieldType(FieldDefinition field,
String fieldCode); void saveFormField(FieldDefinition originalField,
FieldDefinition fieldCopy); String generateUnboundFieldName(FieldDefinition field); Collection<EditorFieldLayoutComponent> getBaseFieldsDraggables(); Map<String, FieldDefinition> getAvailableFields(); FormEditorRenderingContext getRenderingContext(); @PreDestroy void destroy(); } | FormEditorHelper { public Collection<EditorFieldLayoutComponent> getBaseFieldsDraggables() { return unbindedFields.values().stream().map(Pair::getK1).collect(Collectors.toList()); } @Inject FormEditorHelper(FieldManager fieldManager,
ManagedInstance<EditorFieldLayoutComponent> editorFieldLayoutComponents,
SyncBeanManager beanManager); FormModelerContent getContent(); void initHelper(FormModelerContent content); FormDefinition getFormDefinition(); FormModel getFormModel(); void addAvailableFields(); void addAvailableField(FieldDefinition field); void removeAvailableField(FieldDefinition field); FieldDefinition getFormField(String fieldId); void removeField(String fieldId,
boolean addToAvailables); boolean modelContainsField(FieldDefinition fieldDefinition); List<String> getCompatibleModelFields(FieldDefinition field); List<String> getCompatibleFieldTypes(FieldDefinition field); FieldDefinition switchToField(FieldDefinition originalField,
String newBinding); FieldDefinition switchToFieldType(FieldDefinition field,
String fieldCode); void saveFormField(FieldDefinition originalField,
FieldDefinition fieldCopy); String generateUnboundFieldName(FieldDefinition field); Collection<EditorFieldLayoutComponent> getBaseFieldsDraggables(); Map<String, FieldDefinition> getAvailableFields(); FormEditorRenderingContext getRenderingContext(); @PreDestroy void destroy(); static final String UNBOUND_FIELD_NAME_PREFFIX; } |
@Test public void testAddAvailableField() { formEditorHelper.addAvailableField(employeeFields.get(0)); Map<String, FieldDefinition> availableFields = formEditorHelper.getAvailableFields(); assertEquals("The added field should be returned in available fields", employeeFields.size() + 1, availableFields.size()); } | public void addAvailableField(FieldDefinition field) { if (modelContainsField(field)) { availableFields.put(field.getId(), field); } } | FormEditorHelper { public void addAvailableField(FieldDefinition field) { if (modelContainsField(field)) { availableFields.put(field.getId(), field); } } } | FormEditorHelper { public void addAvailableField(FieldDefinition field) { if (modelContainsField(field)) { availableFields.put(field.getId(), field); } } @Inject FormEditorHelper(FieldManager fieldManager,
ManagedInstance<EditorFieldLayoutComponent> editorFieldLayoutComponents,
SyncBeanManager beanManager); } | FormEditorHelper { public void addAvailableField(FieldDefinition field) { if (modelContainsField(field)) { availableFields.put(field.getId(), field); } } @Inject FormEditorHelper(FieldManager fieldManager,
ManagedInstance<EditorFieldLayoutComponent> editorFieldLayoutComponents,
SyncBeanManager beanManager); FormModelerContent getContent(); void initHelper(FormModelerContent content); FormDefinition getFormDefinition(); FormModel getFormModel(); void addAvailableFields(); void addAvailableField(FieldDefinition field); void removeAvailableField(FieldDefinition field); FieldDefinition getFormField(String fieldId); void removeField(String fieldId,
boolean addToAvailables); boolean modelContainsField(FieldDefinition fieldDefinition); List<String> getCompatibleModelFields(FieldDefinition field); List<String> getCompatibleFieldTypes(FieldDefinition field); FieldDefinition switchToField(FieldDefinition originalField,
String newBinding); FieldDefinition switchToFieldType(FieldDefinition field,
String fieldCode); void saveFormField(FieldDefinition originalField,
FieldDefinition fieldCopy); String generateUnboundFieldName(FieldDefinition field); Collection<EditorFieldLayoutComponent> getBaseFieldsDraggables(); Map<String, FieldDefinition> getAvailableFields(); FormEditorRenderingContext getRenderingContext(); @PreDestroy void destroy(); } | FormEditorHelper { public void addAvailableField(FieldDefinition field) { if (modelContainsField(field)) { availableFields.put(field.getId(), field); } } @Inject FormEditorHelper(FieldManager fieldManager,
ManagedInstance<EditorFieldLayoutComponent> editorFieldLayoutComponents,
SyncBeanManager beanManager); FormModelerContent getContent(); void initHelper(FormModelerContent content); FormDefinition getFormDefinition(); FormModel getFormModel(); void addAvailableFields(); void addAvailableField(FieldDefinition field); void removeAvailableField(FieldDefinition field); FieldDefinition getFormField(String fieldId); void removeField(String fieldId,
boolean addToAvailables); boolean modelContainsField(FieldDefinition fieldDefinition); List<String> getCompatibleModelFields(FieldDefinition field); List<String> getCompatibleFieldTypes(FieldDefinition field); FieldDefinition switchToField(FieldDefinition originalField,
String newBinding); FieldDefinition switchToFieldType(FieldDefinition field,
String fieldCode); void saveFormField(FieldDefinition originalField,
FieldDefinition fieldCopy); String generateUnboundFieldName(FieldDefinition field); Collection<EditorFieldLayoutComponent> getBaseFieldsDraggables(); Map<String, FieldDefinition> getAvailableFields(); FormEditorRenderingContext getRenderingContext(); @PreDestroy void destroy(); static final String UNBOUND_FIELD_NAME_PREFFIX; } |
@Test public void testGetCompatibleModelFields() { List<String> compatibleModelFields = formEditorHelper.getCompatibleModelFields(nameField); Assertions.assertThat(compatibleModelFields) .hasSize(2) .contains(lastNameField.getId(), nameField.getId()); compatibleModelFields = formEditorHelper.getCompatibleModelFields(ageField); Assertions.assertThat(compatibleModelFields).containsOnly(ageField.getId()); compatibleModelFields = formEditorHelper.getCompatibleModelFields(weightField); Assertions.assertThat(compatibleModelFields) .hasSize(1) .containsOnly(weightField.getId()); IntegerSliderDefinition slider = new IntegerSliderDefinition(); slider.setId("slider"); slider.setName("slider"); slider.setLabel("slider"); slider.setBinding("slider"); compatibleModelFields = formEditorHelper.getCompatibleModelFields(slider); Assertions.assertThat(compatibleModelFields) .hasSize(1) .containsOnly(ageField.getId()); } | public List<String> getCompatibleModelFields(FieldDefinition field) { return availableFields.values() .stream() .filter(availableField -> availableField.getFieldTypeInfo().equals(field.getFieldTypeInfo())) .map(FieldDefinition::getBinding) .collect(Collectors.toList()); } | FormEditorHelper { public List<String> getCompatibleModelFields(FieldDefinition field) { return availableFields.values() .stream() .filter(availableField -> availableField.getFieldTypeInfo().equals(field.getFieldTypeInfo())) .map(FieldDefinition::getBinding) .collect(Collectors.toList()); } } | FormEditorHelper { public List<String> getCompatibleModelFields(FieldDefinition field) { return availableFields.values() .stream() .filter(availableField -> availableField.getFieldTypeInfo().equals(field.getFieldTypeInfo())) .map(FieldDefinition::getBinding) .collect(Collectors.toList()); } @Inject FormEditorHelper(FieldManager fieldManager,
ManagedInstance<EditorFieldLayoutComponent> editorFieldLayoutComponents,
SyncBeanManager beanManager); } | FormEditorHelper { public List<String> getCompatibleModelFields(FieldDefinition field) { return availableFields.values() .stream() .filter(availableField -> availableField.getFieldTypeInfo().equals(field.getFieldTypeInfo())) .map(FieldDefinition::getBinding) .collect(Collectors.toList()); } @Inject FormEditorHelper(FieldManager fieldManager,
ManagedInstance<EditorFieldLayoutComponent> editorFieldLayoutComponents,
SyncBeanManager beanManager); FormModelerContent getContent(); void initHelper(FormModelerContent content); FormDefinition getFormDefinition(); FormModel getFormModel(); void addAvailableFields(); void addAvailableField(FieldDefinition field); void removeAvailableField(FieldDefinition field); FieldDefinition getFormField(String fieldId); void removeField(String fieldId,
boolean addToAvailables); boolean modelContainsField(FieldDefinition fieldDefinition); List<String> getCompatibleModelFields(FieldDefinition field); List<String> getCompatibleFieldTypes(FieldDefinition field); FieldDefinition switchToField(FieldDefinition originalField,
String newBinding); FieldDefinition switchToFieldType(FieldDefinition field,
String fieldCode); void saveFormField(FieldDefinition originalField,
FieldDefinition fieldCopy); String generateUnboundFieldName(FieldDefinition field); Collection<EditorFieldLayoutComponent> getBaseFieldsDraggables(); Map<String, FieldDefinition> getAvailableFields(); FormEditorRenderingContext getRenderingContext(); @PreDestroy void destroy(); } | FormEditorHelper { public List<String> getCompatibleModelFields(FieldDefinition field) { return availableFields.values() .stream() .filter(availableField -> availableField.getFieldTypeInfo().equals(field.getFieldTypeInfo())) .map(FieldDefinition::getBinding) .collect(Collectors.toList()); } @Inject FormEditorHelper(FieldManager fieldManager,
ManagedInstance<EditorFieldLayoutComponent> editorFieldLayoutComponents,
SyncBeanManager beanManager); FormModelerContent getContent(); void initHelper(FormModelerContent content); FormDefinition getFormDefinition(); FormModel getFormModel(); void addAvailableFields(); void addAvailableField(FieldDefinition field); void removeAvailableField(FieldDefinition field); FieldDefinition getFormField(String fieldId); void removeField(String fieldId,
boolean addToAvailables); boolean modelContainsField(FieldDefinition fieldDefinition); List<String> getCompatibleModelFields(FieldDefinition field); List<String> getCompatibleFieldTypes(FieldDefinition field); FieldDefinition switchToField(FieldDefinition originalField,
String newBinding); FieldDefinition switchToFieldType(FieldDefinition field,
String fieldCode); void saveFormField(FieldDefinition originalField,
FieldDefinition fieldCopy); String generateUnboundFieldName(FieldDefinition field); Collection<EditorFieldLayoutComponent> getBaseFieldsDraggables(); Map<String, FieldDefinition> getAvailableFields(); FormEditorRenderingContext getRenderingContext(); @PreDestroy void destroy(); static final String UNBOUND_FIELD_NAME_PREFFIX; } |
@Test public void testGetCompatibleFieldTypes() { Collection<String> fieldCodes = formEditorHelper.getCompatibleFieldTypes(nameField); assertFalse(fieldCodes.isEmpty()); } | public List<String> getCompatibleFieldTypes(FieldDefinition field) { List<String> editorFieldTypeCodes = enabledFieldPropertiesFieldTypes.stream().map(FieldType::getTypeName).collect(Collectors.toList()); return fieldManager.getCompatibleFields(field).stream().filter((fieldCode) -> editorFieldTypeCodes.contains(fieldCode)) .collect(Collectors.toList()); } | FormEditorHelper { public List<String> getCompatibleFieldTypes(FieldDefinition field) { List<String> editorFieldTypeCodes = enabledFieldPropertiesFieldTypes.stream().map(FieldType::getTypeName).collect(Collectors.toList()); return fieldManager.getCompatibleFields(field).stream().filter((fieldCode) -> editorFieldTypeCodes.contains(fieldCode)) .collect(Collectors.toList()); } } | FormEditorHelper { public List<String> getCompatibleFieldTypes(FieldDefinition field) { List<String> editorFieldTypeCodes = enabledFieldPropertiesFieldTypes.stream().map(FieldType::getTypeName).collect(Collectors.toList()); return fieldManager.getCompatibleFields(field).stream().filter((fieldCode) -> editorFieldTypeCodes.contains(fieldCode)) .collect(Collectors.toList()); } @Inject FormEditorHelper(FieldManager fieldManager,
ManagedInstance<EditorFieldLayoutComponent> editorFieldLayoutComponents,
SyncBeanManager beanManager); } | FormEditorHelper { public List<String> getCompatibleFieldTypes(FieldDefinition field) { List<String> editorFieldTypeCodes = enabledFieldPropertiesFieldTypes.stream().map(FieldType::getTypeName).collect(Collectors.toList()); return fieldManager.getCompatibleFields(field).stream().filter((fieldCode) -> editorFieldTypeCodes.contains(fieldCode)) .collect(Collectors.toList()); } @Inject FormEditorHelper(FieldManager fieldManager,
ManagedInstance<EditorFieldLayoutComponent> editorFieldLayoutComponents,
SyncBeanManager beanManager); FormModelerContent getContent(); void initHelper(FormModelerContent content); FormDefinition getFormDefinition(); FormModel getFormModel(); void addAvailableFields(); void addAvailableField(FieldDefinition field); void removeAvailableField(FieldDefinition field); FieldDefinition getFormField(String fieldId); void removeField(String fieldId,
boolean addToAvailables); boolean modelContainsField(FieldDefinition fieldDefinition); List<String> getCompatibleModelFields(FieldDefinition field); List<String> getCompatibleFieldTypes(FieldDefinition field); FieldDefinition switchToField(FieldDefinition originalField,
String newBinding); FieldDefinition switchToFieldType(FieldDefinition field,
String fieldCode); void saveFormField(FieldDefinition originalField,
FieldDefinition fieldCopy); String generateUnboundFieldName(FieldDefinition field); Collection<EditorFieldLayoutComponent> getBaseFieldsDraggables(); Map<String, FieldDefinition> getAvailableFields(); FormEditorRenderingContext getRenderingContext(); @PreDestroy void destroy(); } | FormEditorHelper { public List<String> getCompatibleFieldTypes(FieldDefinition field) { List<String> editorFieldTypeCodes = enabledFieldPropertiesFieldTypes.stream().map(FieldType::getTypeName).collect(Collectors.toList()); return fieldManager.getCompatibleFields(field).stream().filter((fieldCode) -> editorFieldTypeCodes.contains(fieldCode)) .collect(Collectors.toList()); } @Inject FormEditorHelper(FieldManager fieldManager,
ManagedInstance<EditorFieldLayoutComponent> editorFieldLayoutComponents,
SyncBeanManager beanManager); FormModelerContent getContent(); void initHelper(FormModelerContent content); FormDefinition getFormDefinition(); FormModel getFormModel(); void addAvailableFields(); void addAvailableField(FieldDefinition field); void removeAvailableField(FieldDefinition field); FieldDefinition getFormField(String fieldId); void removeField(String fieldId,
boolean addToAvailables); boolean modelContainsField(FieldDefinition fieldDefinition); List<String> getCompatibleModelFields(FieldDefinition field); List<String> getCompatibleFieldTypes(FieldDefinition field); FieldDefinition switchToField(FieldDefinition originalField,
String newBinding); FieldDefinition switchToFieldType(FieldDefinition field,
String fieldCode); void saveFormField(FieldDefinition originalField,
FieldDefinition fieldCopy); String generateUnboundFieldName(FieldDefinition field); Collection<EditorFieldLayoutComponent> getBaseFieldsDraggables(); Map<String, FieldDefinition> getAvailableFields(); FormEditorRenderingContext getRenderingContext(); @PreDestroy void destroy(); static final String UNBOUND_FIELD_NAME_PREFFIX; } |
@Test public void testSwitchToNullBinding() { FieldDefinition result = formEditorHelper.switchToField(nameField, null); Assertions.assertThat(result.getId()).isNotEqualTo(nameField.getId()); Assertions.assertThat(result.getName()).isNotEqualTo(nameField.getName()); Assertions.assertThat(result.getBinding()).isNullOrEmpty(); Assertions.assertThat(result.getBinding()).isNotEqualTo(nameField.getBinding()); Assertions.assertThat(result.getStandaloneClassName()).isEqualTo(nameField.getStandaloneClassName()); } | public FieldDefinition switchToField(FieldDefinition originalField, String newBinding) { if (newBinding != null && !"".equals(newBinding)) { Optional<FieldDefinition> availableFieldOptional = availableFields.values() .stream() .filter(availableField -> availableField.getBinding().equals(newBinding)).findFirst(); if (availableFieldOptional.isPresent()) { FieldDefinition availableField = availableFieldOptional.get(); FieldDefinition resultField = fieldManager.getFieldFromProvider(originalField.getFieldType().getTypeName(), availableField.getFieldTypeInfo()); if (resultField == null) { resultField = fieldManager.getFieldFromProvider(availableField.getFieldType().getTypeName(), availableField.getFieldTypeInfo()); } resultField.copyFrom(originalField); resultField.setId(availableField.getId()); resultField.setName(availableField.getName()); resultField.setStandaloneClassName(availableField.getStandaloneClassName()); resultField.setBinding(newBinding); return resultField; } } FieldDefinition resultField = fieldManager.getFieldFromProvider(originalField.getFieldType().getTypeName(), originalField.getFieldTypeInfo()); if (newBinding == null || newBinding.equals("")) { resultField.setName(generateUnboundFieldName(resultField)); resultField.setBinding(""); } resultField.copyFrom(originalField); resultField.setBinding(newBinding); if (resultField.getName() == null) { resultField.setName(newBinding); } return resultField; } | FormEditorHelper { public FieldDefinition switchToField(FieldDefinition originalField, String newBinding) { if (newBinding != null && !"".equals(newBinding)) { Optional<FieldDefinition> availableFieldOptional = availableFields.values() .stream() .filter(availableField -> availableField.getBinding().equals(newBinding)).findFirst(); if (availableFieldOptional.isPresent()) { FieldDefinition availableField = availableFieldOptional.get(); FieldDefinition resultField = fieldManager.getFieldFromProvider(originalField.getFieldType().getTypeName(), availableField.getFieldTypeInfo()); if (resultField == null) { resultField = fieldManager.getFieldFromProvider(availableField.getFieldType().getTypeName(), availableField.getFieldTypeInfo()); } resultField.copyFrom(originalField); resultField.setId(availableField.getId()); resultField.setName(availableField.getName()); resultField.setStandaloneClassName(availableField.getStandaloneClassName()); resultField.setBinding(newBinding); return resultField; } } FieldDefinition resultField = fieldManager.getFieldFromProvider(originalField.getFieldType().getTypeName(), originalField.getFieldTypeInfo()); if (newBinding == null || newBinding.equals("")) { resultField.setName(generateUnboundFieldName(resultField)); resultField.setBinding(""); } resultField.copyFrom(originalField); resultField.setBinding(newBinding); if (resultField.getName() == null) { resultField.setName(newBinding); } return resultField; } } | FormEditorHelper { public FieldDefinition switchToField(FieldDefinition originalField, String newBinding) { if (newBinding != null && !"".equals(newBinding)) { Optional<FieldDefinition> availableFieldOptional = availableFields.values() .stream() .filter(availableField -> availableField.getBinding().equals(newBinding)).findFirst(); if (availableFieldOptional.isPresent()) { FieldDefinition availableField = availableFieldOptional.get(); FieldDefinition resultField = fieldManager.getFieldFromProvider(originalField.getFieldType().getTypeName(), availableField.getFieldTypeInfo()); if (resultField == null) { resultField = fieldManager.getFieldFromProvider(availableField.getFieldType().getTypeName(), availableField.getFieldTypeInfo()); } resultField.copyFrom(originalField); resultField.setId(availableField.getId()); resultField.setName(availableField.getName()); resultField.setStandaloneClassName(availableField.getStandaloneClassName()); resultField.setBinding(newBinding); return resultField; } } FieldDefinition resultField = fieldManager.getFieldFromProvider(originalField.getFieldType().getTypeName(), originalField.getFieldTypeInfo()); if (newBinding == null || newBinding.equals("")) { resultField.setName(generateUnboundFieldName(resultField)); resultField.setBinding(""); } resultField.copyFrom(originalField); resultField.setBinding(newBinding); if (resultField.getName() == null) { resultField.setName(newBinding); } return resultField; } @Inject FormEditorHelper(FieldManager fieldManager,
ManagedInstance<EditorFieldLayoutComponent> editorFieldLayoutComponents,
SyncBeanManager beanManager); } | FormEditorHelper { public FieldDefinition switchToField(FieldDefinition originalField, String newBinding) { if (newBinding != null && !"".equals(newBinding)) { Optional<FieldDefinition> availableFieldOptional = availableFields.values() .stream() .filter(availableField -> availableField.getBinding().equals(newBinding)).findFirst(); if (availableFieldOptional.isPresent()) { FieldDefinition availableField = availableFieldOptional.get(); FieldDefinition resultField = fieldManager.getFieldFromProvider(originalField.getFieldType().getTypeName(), availableField.getFieldTypeInfo()); if (resultField == null) { resultField = fieldManager.getFieldFromProvider(availableField.getFieldType().getTypeName(), availableField.getFieldTypeInfo()); } resultField.copyFrom(originalField); resultField.setId(availableField.getId()); resultField.setName(availableField.getName()); resultField.setStandaloneClassName(availableField.getStandaloneClassName()); resultField.setBinding(newBinding); return resultField; } } FieldDefinition resultField = fieldManager.getFieldFromProvider(originalField.getFieldType().getTypeName(), originalField.getFieldTypeInfo()); if (newBinding == null || newBinding.equals("")) { resultField.setName(generateUnboundFieldName(resultField)); resultField.setBinding(""); } resultField.copyFrom(originalField); resultField.setBinding(newBinding); if (resultField.getName() == null) { resultField.setName(newBinding); } return resultField; } @Inject FormEditorHelper(FieldManager fieldManager,
ManagedInstance<EditorFieldLayoutComponent> editorFieldLayoutComponents,
SyncBeanManager beanManager); FormModelerContent getContent(); void initHelper(FormModelerContent content); FormDefinition getFormDefinition(); FormModel getFormModel(); void addAvailableFields(); void addAvailableField(FieldDefinition field); void removeAvailableField(FieldDefinition field); FieldDefinition getFormField(String fieldId); void removeField(String fieldId,
boolean addToAvailables); boolean modelContainsField(FieldDefinition fieldDefinition); List<String> getCompatibleModelFields(FieldDefinition field); List<String> getCompatibleFieldTypes(FieldDefinition field); FieldDefinition switchToField(FieldDefinition originalField,
String newBinding); FieldDefinition switchToFieldType(FieldDefinition field,
String fieldCode); void saveFormField(FieldDefinition originalField,
FieldDefinition fieldCopy); String generateUnboundFieldName(FieldDefinition field); Collection<EditorFieldLayoutComponent> getBaseFieldsDraggables(); Map<String, FieldDefinition> getAvailableFields(); FormEditorRenderingContext getRenderingContext(); @PreDestroy void destroy(); } | FormEditorHelper { public FieldDefinition switchToField(FieldDefinition originalField, String newBinding) { if (newBinding != null && !"".equals(newBinding)) { Optional<FieldDefinition> availableFieldOptional = availableFields.values() .stream() .filter(availableField -> availableField.getBinding().equals(newBinding)).findFirst(); if (availableFieldOptional.isPresent()) { FieldDefinition availableField = availableFieldOptional.get(); FieldDefinition resultField = fieldManager.getFieldFromProvider(originalField.getFieldType().getTypeName(), availableField.getFieldTypeInfo()); if (resultField == null) { resultField = fieldManager.getFieldFromProvider(availableField.getFieldType().getTypeName(), availableField.getFieldTypeInfo()); } resultField.copyFrom(originalField); resultField.setId(availableField.getId()); resultField.setName(availableField.getName()); resultField.setStandaloneClassName(availableField.getStandaloneClassName()); resultField.setBinding(newBinding); return resultField; } } FieldDefinition resultField = fieldManager.getFieldFromProvider(originalField.getFieldType().getTypeName(), originalField.getFieldTypeInfo()); if (newBinding == null || newBinding.equals("")) { resultField.setName(generateUnboundFieldName(resultField)); resultField.setBinding(""); } resultField.copyFrom(originalField); resultField.setBinding(newBinding); if (resultField.getName() == null) { resultField.setName(newBinding); } return resultField; } @Inject FormEditorHelper(FieldManager fieldManager,
ManagedInstance<EditorFieldLayoutComponent> editorFieldLayoutComponents,
SyncBeanManager beanManager); FormModelerContent getContent(); void initHelper(FormModelerContent content); FormDefinition getFormDefinition(); FormModel getFormModel(); void addAvailableFields(); void addAvailableField(FieldDefinition field); void removeAvailableField(FieldDefinition field); FieldDefinition getFormField(String fieldId); void removeField(String fieldId,
boolean addToAvailables); boolean modelContainsField(FieldDefinition fieldDefinition); List<String> getCompatibleModelFields(FieldDefinition field); List<String> getCompatibleFieldTypes(FieldDefinition field); FieldDefinition switchToField(FieldDefinition originalField,
String newBinding); FieldDefinition switchToFieldType(FieldDefinition field,
String fieldCode); void saveFormField(FieldDefinition originalField,
FieldDefinition fieldCopy); String generateUnboundFieldName(FieldDefinition field); Collection<EditorFieldLayoutComponent> getBaseFieldsDraggables(); Map<String, FieldDefinition> getAvailableFields(); FormEditorRenderingContext getRenderingContext(); @PreDestroy void destroy(); static final String UNBOUND_FIELD_NAME_PREFFIX; } |
@Test public void testSwitchToDynamicBinding() { FieldDefinition result = formEditorHelper.switchToField(nameField, DYNAMIC_BINDING); Assertions.assertThat(result.getId()).isNotEqualTo(nameField.getId()); Assertions.assertThat(result.getName()).isEqualTo(DYNAMIC_BINDING); Assertions.assertThat(result.getBinding()).isEqualTo(DYNAMIC_BINDING); Assertions.assertThat(result.getStandaloneClassName()).isEqualTo(nameField.getStandaloneClassName()); } | public FieldDefinition switchToField(FieldDefinition originalField, String newBinding) { if (newBinding != null && !"".equals(newBinding)) { Optional<FieldDefinition> availableFieldOptional = availableFields.values() .stream() .filter(availableField -> availableField.getBinding().equals(newBinding)).findFirst(); if (availableFieldOptional.isPresent()) { FieldDefinition availableField = availableFieldOptional.get(); FieldDefinition resultField = fieldManager.getFieldFromProvider(originalField.getFieldType().getTypeName(), availableField.getFieldTypeInfo()); if (resultField == null) { resultField = fieldManager.getFieldFromProvider(availableField.getFieldType().getTypeName(), availableField.getFieldTypeInfo()); } resultField.copyFrom(originalField); resultField.setId(availableField.getId()); resultField.setName(availableField.getName()); resultField.setStandaloneClassName(availableField.getStandaloneClassName()); resultField.setBinding(newBinding); return resultField; } } FieldDefinition resultField = fieldManager.getFieldFromProvider(originalField.getFieldType().getTypeName(), originalField.getFieldTypeInfo()); if (newBinding == null || newBinding.equals("")) { resultField.setName(generateUnboundFieldName(resultField)); resultField.setBinding(""); } resultField.copyFrom(originalField); resultField.setBinding(newBinding); if (resultField.getName() == null) { resultField.setName(newBinding); } return resultField; } | FormEditorHelper { public FieldDefinition switchToField(FieldDefinition originalField, String newBinding) { if (newBinding != null && !"".equals(newBinding)) { Optional<FieldDefinition> availableFieldOptional = availableFields.values() .stream() .filter(availableField -> availableField.getBinding().equals(newBinding)).findFirst(); if (availableFieldOptional.isPresent()) { FieldDefinition availableField = availableFieldOptional.get(); FieldDefinition resultField = fieldManager.getFieldFromProvider(originalField.getFieldType().getTypeName(), availableField.getFieldTypeInfo()); if (resultField == null) { resultField = fieldManager.getFieldFromProvider(availableField.getFieldType().getTypeName(), availableField.getFieldTypeInfo()); } resultField.copyFrom(originalField); resultField.setId(availableField.getId()); resultField.setName(availableField.getName()); resultField.setStandaloneClassName(availableField.getStandaloneClassName()); resultField.setBinding(newBinding); return resultField; } } FieldDefinition resultField = fieldManager.getFieldFromProvider(originalField.getFieldType().getTypeName(), originalField.getFieldTypeInfo()); if (newBinding == null || newBinding.equals("")) { resultField.setName(generateUnboundFieldName(resultField)); resultField.setBinding(""); } resultField.copyFrom(originalField); resultField.setBinding(newBinding); if (resultField.getName() == null) { resultField.setName(newBinding); } return resultField; } } | FormEditorHelper { public FieldDefinition switchToField(FieldDefinition originalField, String newBinding) { if (newBinding != null && !"".equals(newBinding)) { Optional<FieldDefinition> availableFieldOptional = availableFields.values() .stream() .filter(availableField -> availableField.getBinding().equals(newBinding)).findFirst(); if (availableFieldOptional.isPresent()) { FieldDefinition availableField = availableFieldOptional.get(); FieldDefinition resultField = fieldManager.getFieldFromProvider(originalField.getFieldType().getTypeName(), availableField.getFieldTypeInfo()); if (resultField == null) { resultField = fieldManager.getFieldFromProvider(availableField.getFieldType().getTypeName(), availableField.getFieldTypeInfo()); } resultField.copyFrom(originalField); resultField.setId(availableField.getId()); resultField.setName(availableField.getName()); resultField.setStandaloneClassName(availableField.getStandaloneClassName()); resultField.setBinding(newBinding); return resultField; } } FieldDefinition resultField = fieldManager.getFieldFromProvider(originalField.getFieldType().getTypeName(), originalField.getFieldTypeInfo()); if (newBinding == null || newBinding.equals("")) { resultField.setName(generateUnboundFieldName(resultField)); resultField.setBinding(""); } resultField.copyFrom(originalField); resultField.setBinding(newBinding); if (resultField.getName() == null) { resultField.setName(newBinding); } return resultField; } @Inject FormEditorHelper(FieldManager fieldManager,
ManagedInstance<EditorFieldLayoutComponent> editorFieldLayoutComponents,
SyncBeanManager beanManager); } | FormEditorHelper { public FieldDefinition switchToField(FieldDefinition originalField, String newBinding) { if (newBinding != null && !"".equals(newBinding)) { Optional<FieldDefinition> availableFieldOptional = availableFields.values() .stream() .filter(availableField -> availableField.getBinding().equals(newBinding)).findFirst(); if (availableFieldOptional.isPresent()) { FieldDefinition availableField = availableFieldOptional.get(); FieldDefinition resultField = fieldManager.getFieldFromProvider(originalField.getFieldType().getTypeName(), availableField.getFieldTypeInfo()); if (resultField == null) { resultField = fieldManager.getFieldFromProvider(availableField.getFieldType().getTypeName(), availableField.getFieldTypeInfo()); } resultField.copyFrom(originalField); resultField.setId(availableField.getId()); resultField.setName(availableField.getName()); resultField.setStandaloneClassName(availableField.getStandaloneClassName()); resultField.setBinding(newBinding); return resultField; } } FieldDefinition resultField = fieldManager.getFieldFromProvider(originalField.getFieldType().getTypeName(), originalField.getFieldTypeInfo()); if (newBinding == null || newBinding.equals("")) { resultField.setName(generateUnboundFieldName(resultField)); resultField.setBinding(""); } resultField.copyFrom(originalField); resultField.setBinding(newBinding); if (resultField.getName() == null) { resultField.setName(newBinding); } return resultField; } @Inject FormEditorHelper(FieldManager fieldManager,
ManagedInstance<EditorFieldLayoutComponent> editorFieldLayoutComponents,
SyncBeanManager beanManager); FormModelerContent getContent(); void initHelper(FormModelerContent content); FormDefinition getFormDefinition(); FormModel getFormModel(); void addAvailableFields(); void addAvailableField(FieldDefinition field); void removeAvailableField(FieldDefinition field); FieldDefinition getFormField(String fieldId); void removeField(String fieldId,
boolean addToAvailables); boolean modelContainsField(FieldDefinition fieldDefinition); List<String> getCompatibleModelFields(FieldDefinition field); List<String> getCompatibleFieldTypes(FieldDefinition field); FieldDefinition switchToField(FieldDefinition originalField,
String newBinding); FieldDefinition switchToFieldType(FieldDefinition field,
String fieldCode); void saveFormField(FieldDefinition originalField,
FieldDefinition fieldCopy); String generateUnboundFieldName(FieldDefinition field); Collection<EditorFieldLayoutComponent> getBaseFieldsDraggables(); Map<String, FieldDefinition> getAvailableFields(); FormEditorRenderingContext getRenderingContext(); @PreDestroy void destroy(); } | FormEditorHelper { public FieldDefinition switchToField(FieldDefinition originalField, String newBinding) { if (newBinding != null && !"".equals(newBinding)) { Optional<FieldDefinition> availableFieldOptional = availableFields.values() .stream() .filter(availableField -> availableField.getBinding().equals(newBinding)).findFirst(); if (availableFieldOptional.isPresent()) { FieldDefinition availableField = availableFieldOptional.get(); FieldDefinition resultField = fieldManager.getFieldFromProvider(originalField.getFieldType().getTypeName(), availableField.getFieldTypeInfo()); if (resultField == null) { resultField = fieldManager.getFieldFromProvider(availableField.getFieldType().getTypeName(), availableField.getFieldTypeInfo()); } resultField.copyFrom(originalField); resultField.setId(availableField.getId()); resultField.setName(availableField.getName()); resultField.setStandaloneClassName(availableField.getStandaloneClassName()); resultField.setBinding(newBinding); return resultField; } } FieldDefinition resultField = fieldManager.getFieldFromProvider(originalField.getFieldType().getTypeName(), originalField.getFieldTypeInfo()); if (newBinding == null || newBinding.equals("")) { resultField.setName(generateUnboundFieldName(resultField)); resultField.setBinding(""); } resultField.copyFrom(originalField); resultField.setBinding(newBinding); if (resultField.getName() == null) { resultField.setName(newBinding); } return resultField; } @Inject FormEditorHelper(FieldManager fieldManager,
ManagedInstance<EditorFieldLayoutComponent> editorFieldLayoutComponents,
SyncBeanManager beanManager); FormModelerContent getContent(); void initHelper(FormModelerContent content); FormDefinition getFormDefinition(); FormModel getFormModel(); void addAvailableFields(); void addAvailableField(FieldDefinition field); void removeAvailableField(FieldDefinition field); FieldDefinition getFormField(String fieldId); void removeField(String fieldId,
boolean addToAvailables); boolean modelContainsField(FieldDefinition fieldDefinition); List<String> getCompatibleModelFields(FieldDefinition field); List<String> getCompatibleFieldTypes(FieldDefinition field); FieldDefinition switchToField(FieldDefinition originalField,
String newBinding); FieldDefinition switchToFieldType(FieldDefinition field,
String fieldCode); void saveFormField(FieldDefinition originalField,
FieldDefinition fieldCopy); String generateUnboundFieldName(FieldDefinition field); Collection<EditorFieldLayoutComponent> getBaseFieldsDraggables(); Map<String, FieldDefinition> getAvailableFields(); FormEditorRenderingContext getRenderingContext(); @PreDestroy void destroy(); static final String UNBOUND_FIELD_NAME_PREFFIX; } |
@Test public void testSwitchToFieldType() { content.getDefinition().getFields().addAll(employeeFields); formEditorHelper.getAvailableFields().clear(); FieldDefinition fieldDefinition = formEditorHelper.switchToFieldType(nameField, TextAreaFieldDefinition.FIELD_TYPE.getTypeName()); assertEquals(TextAreaFieldDefinition.class, fieldDefinition.getClass()); } | public FieldDefinition switchToFieldType(FieldDefinition field, String fieldCode) { FieldDefinition resultDefinition = fieldManager.getFieldFromProvider(fieldCode, field.getFieldTypeInfo()); resultDefinition.copyFrom(field); resultDefinition.setId(field.getId()); resultDefinition.setName(field.getName()); removeField(field.getId(), false); return resultDefinition; } | FormEditorHelper { public FieldDefinition switchToFieldType(FieldDefinition field, String fieldCode) { FieldDefinition resultDefinition = fieldManager.getFieldFromProvider(fieldCode, field.getFieldTypeInfo()); resultDefinition.copyFrom(field); resultDefinition.setId(field.getId()); resultDefinition.setName(field.getName()); removeField(field.getId(), false); return resultDefinition; } } | FormEditorHelper { public FieldDefinition switchToFieldType(FieldDefinition field, String fieldCode) { FieldDefinition resultDefinition = fieldManager.getFieldFromProvider(fieldCode, field.getFieldTypeInfo()); resultDefinition.copyFrom(field); resultDefinition.setId(field.getId()); resultDefinition.setName(field.getName()); removeField(field.getId(), false); return resultDefinition; } @Inject FormEditorHelper(FieldManager fieldManager,
ManagedInstance<EditorFieldLayoutComponent> editorFieldLayoutComponents,
SyncBeanManager beanManager); } | FormEditorHelper { public FieldDefinition switchToFieldType(FieldDefinition field, String fieldCode) { FieldDefinition resultDefinition = fieldManager.getFieldFromProvider(fieldCode, field.getFieldTypeInfo()); resultDefinition.copyFrom(field); resultDefinition.setId(field.getId()); resultDefinition.setName(field.getName()); removeField(field.getId(), false); return resultDefinition; } @Inject FormEditorHelper(FieldManager fieldManager,
ManagedInstance<EditorFieldLayoutComponent> editorFieldLayoutComponents,
SyncBeanManager beanManager); FormModelerContent getContent(); void initHelper(FormModelerContent content); FormDefinition getFormDefinition(); FormModel getFormModel(); void addAvailableFields(); void addAvailableField(FieldDefinition field); void removeAvailableField(FieldDefinition field); FieldDefinition getFormField(String fieldId); void removeField(String fieldId,
boolean addToAvailables); boolean modelContainsField(FieldDefinition fieldDefinition); List<String> getCompatibleModelFields(FieldDefinition field); List<String> getCompatibleFieldTypes(FieldDefinition field); FieldDefinition switchToField(FieldDefinition originalField,
String newBinding); FieldDefinition switchToFieldType(FieldDefinition field,
String fieldCode); void saveFormField(FieldDefinition originalField,
FieldDefinition fieldCopy); String generateUnboundFieldName(FieldDefinition field); Collection<EditorFieldLayoutComponent> getBaseFieldsDraggables(); Map<String, FieldDefinition> getAvailableFields(); FormEditorRenderingContext getRenderingContext(); @PreDestroy void destroy(); } | FormEditorHelper { public FieldDefinition switchToFieldType(FieldDefinition field, String fieldCode) { FieldDefinition resultDefinition = fieldManager.getFieldFromProvider(fieldCode, field.getFieldTypeInfo()); resultDefinition.copyFrom(field); resultDefinition.setId(field.getId()); resultDefinition.setName(field.getName()); removeField(field.getId(), false); return resultDefinition; } @Inject FormEditorHelper(FieldManager fieldManager,
ManagedInstance<EditorFieldLayoutComponent> editorFieldLayoutComponents,
SyncBeanManager beanManager); FormModelerContent getContent(); void initHelper(FormModelerContent content); FormDefinition getFormDefinition(); FormModel getFormModel(); void addAvailableFields(); void addAvailableField(FieldDefinition field); void removeAvailableField(FieldDefinition field); FieldDefinition getFormField(String fieldId); void removeField(String fieldId,
boolean addToAvailables); boolean modelContainsField(FieldDefinition fieldDefinition); List<String> getCompatibleModelFields(FieldDefinition field); List<String> getCompatibleFieldTypes(FieldDefinition field); FieldDefinition switchToField(FieldDefinition originalField,
String newBinding); FieldDefinition switchToFieldType(FieldDefinition field,
String fieldCode); void saveFormField(FieldDefinition originalField,
FieldDefinition fieldCopy); String generateUnboundFieldName(FieldDefinition field); Collection<EditorFieldLayoutComponent> getBaseFieldsDraggables(); Map<String, FieldDefinition> getAvailableFields(); FormEditorRenderingContext getRenderingContext(); @PreDestroy void destroy(); static final String UNBOUND_FIELD_NAME_PREFFIX; } |
@Test public void testDispatch() { event.dispatch(handler); verify(handler).onMoveDividerStep(eq(event)); } | @Override protected void dispatch(final MoveDividerStepHandler handler) { handler.onMoveDividerStep(this); } | MoveDividerStepEvent extends AbstractWiresDragEvent<MoveDividerStepHandler> { @Override protected void dispatch(final MoveDividerStepHandler handler) { handler.onMoveDividerStep(this); } } | MoveDividerStepEvent extends AbstractWiresDragEvent<MoveDividerStepHandler> { @Override protected void dispatch(final MoveDividerStepHandler handler) { handler.onMoveDividerStep(this); } MoveDividerStepEvent(final DecisionServiceSVGShapeView shape,
final AbstractNodeDragEvent<?> nodeDragEvent); } | MoveDividerStepEvent extends AbstractWiresDragEvent<MoveDividerStepHandler> { @Override protected void dispatch(final MoveDividerStepHandler handler) { handler.onMoveDividerStep(this); } MoveDividerStepEvent(final DecisionServiceSVGShapeView shape,
final AbstractNodeDragEvent<?> nodeDragEvent); @Override Type<MoveDividerStepHandler> getAssociatedType(); } | MoveDividerStepEvent extends AbstractWiresDragEvent<MoveDividerStepHandler> { @Override protected void dispatch(final MoveDividerStepHandler handler) { handler.onMoveDividerStep(this); } MoveDividerStepEvent(final DecisionServiceSVGShapeView shape,
final AbstractNodeDragEvent<?> nodeDragEvent); @Override Type<MoveDividerStepHandler> getAssociatedType(); static final Type<MoveDividerStepHandler> TYPE; } |
@Test public void testRemoveAvailableField() { formEditorHelper.addAvailableField(nameField); assertTrue(formEditorHelper.getAvailableFields().containsKey(nameField.getId())); formEditorHelper.removeAvailableField(nameField); assertFalse(formEditorHelper.getAvailableFields().containsKey(nameField.getId())); } | public void removeAvailableField(FieldDefinition field) { availableFields.remove(field.getId()); } | FormEditorHelper { public void removeAvailableField(FieldDefinition field) { availableFields.remove(field.getId()); } } | FormEditorHelper { public void removeAvailableField(FieldDefinition field) { availableFields.remove(field.getId()); } @Inject FormEditorHelper(FieldManager fieldManager,
ManagedInstance<EditorFieldLayoutComponent> editorFieldLayoutComponents,
SyncBeanManager beanManager); } | FormEditorHelper { public void removeAvailableField(FieldDefinition field) { availableFields.remove(field.getId()); } @Inject FormEditorHelper(FieldManager fieldManager,
ManagedInstance<EditorFieldLayoutComponent> editorFieldLayoutComponents,
SyncBeanManager beanManager); FormModelerContent getContent(); void initHelper(FormModelerContent content); FormDefinition getFormDefinition(); FormModel getFormModel(); void addAvailableFields(); void addAvailableField(FieldDefinition field); void removeAvailableField(FieldDefinition field); FieldDefinition getFormField(String fieldId); void removeField(String fieldId,
boolean addToAvailables); boolean modelContainsField(FieldDefinition fieldDefinition); List<String> getCompatibleModelFields(FieldDefinition field); List<String> getCompatibleFieldTypes(FieldDefinition field); FieldDefinition switchToField(FieldDefinition originalField,
String newBinding); FieldDefinition switchToFieldType(FieldDefinition field,
String fieldCode); void saveFormField(FieldDefinition originalField,
FieldDefinition fieldCopy); String generateUnboundFieldName(FieldDefinition field); Collection<EditorFieldLayoutComponent> getBaseFieldsDraggables(); Map<String, FieldDefinition> getAvailableFields(); FormEditorRenderingContext getRenderingContext(); @PreDestroy void destroy(); } | FormEditorHelper { public void removeAvailableField(FieldDefinition field) { availableFields.remove(field.getId()); } @Inject FormEditorHelper(FieldManager fieldManager,
ManagedInstance<EditorFieldLayoutComponent> editorFieldLayoutComponents,
SyncBeanManager beanManager); FormModelerContent getContent(); void initHelper(FormModelerContent content); FormDefinition getFormDefinition(); FormModel getFormModel(); void addAvailableFields(); void addAvailableField(FieldDefinition field); void removeAvailableField(FieldDefinition field); FieldDefinition getFormField(String fieldId); void removeField(String fieldId,
boolean addToAvailables); boolean modelContainsField(FieldDefinition fieldDefinition); List<String> getCompatibleModelFields(FieldDefinition field); List<String> getCompatibleFieldTypes(FieldDefinition field); FieldDefinition switchToField(FieldDefinition originalField,
String newBinding); FieldDefinition switchToFieldType(FieldDefinition field,
String fieldCode); void saveFormField(FieldDefinition originalField,
FieldDefinition fieldCopy); String generateUnboundFieldName(FieldDefinition field); Collection<EditorFieldLayoutComponent> getBaseFieldsDraggables(); Map<String, FieldDefinition> getAvailableFields(); FormEditorRenderingContext getRenderingContext(); @PreDestroy void destroy(); static final String UNBOUND_FIELD_NAME_PREFFIX; } |
@Test public void testDestroy() { formEditorHelper.destroy(); verify(editorFieldLayoutComponents).destroyAll(); } | @PreDestroy public void destroy() { editorFieldLayoutComponents.destroyAll(); } | FormEditorHelper { @PreDestroy public void destroy() { editorFieldLayoutComponents.destroyAll(); } } | FormEditorHelper { @PreDestroy public void destroy() { editorFieldLayoutComponents.destroyAll(); } @Inject FormEditorHelper(FieldManager fieldManager,
ManagedInstance<EditorFieldLayoutComponent> editorFieldLayoutComponents,
SyncBeanManager beanManager); } | FormEditorHelper { @PreDestroy public void destroy() { editorFieldLayoutComponents.destroyAll(); } @Inject FormEditorHelper(FieldManager fieldManager,
ManagedInstance<EditorFieldLayoutComponent> editorFieldLayoutComponents,
SyncBeanManager beanManager); FormModelerContent getContent(); void initHelper(FormModelerContent content); FormDefinition getFormDefinition(); FormModel getFormModel(); void addAvailableFields(); void addAvailableField(FieldDefinition field); void removeAvailableField(FieldDefinition field); FieldDefinition getFormField(String fieldId); void removeField(String fieldId,
boolean addToAvailables); boolean modelContainsField(FieldDefinition fieldDefinition); List<String> getCompatibleModelFields(FieldDefinition field); List<String> getCompatibleFieldTypes(FieldDefinition field); FieldDefinition switchToField(FieldDefinition originalField,
String newBinding); FieldDefinition switchToFieldType(FieldDefinition field,
String fieldCode); void saveFormField(FieldDefinition originalField,
FieldDefinition fieldCopy); String generateUnboundFieldName(FieldDefinition field); Collection<EditorFieldLayoutComponent> getBaseFieldsDraggables(); Map<String, FieldDefinition> getAvailableFields(); FormEditorRenderingContext getRenderingContext(); @PreDestroy void destroy(); } | FormEditorHelper { @PreDestroy public void destroy() { editorFieldLayoutComponents.destroyAll(); } @Inject FormEditorHelper(FieldManager fieldManager,
ManagedInstance<EditorFieldLayoutComponent> editorFieldLayoutComponents,
SyncBeanManager beanManager); FormModelerContent getContent(); void initHelper(FormModelerContent content); FormDefinition getFormDefinition(); FormModel getFormModel(); void addAvailableFields(); void addAvailableField(FieldDefinition field); void removeAvailableField(FieldDefinition field); FieldDefinition getFormField(String fieldId); void removeField(String fieldId,
boolean addToAvailables); boolean modelContainsField(FieldDefinition fieldDefinition); List<String> getCompatibleModelFields(FieldDefinition field); List<String> getCompatibleFieldTypes(FieldDefinition field); FieldDefinition switchToField(FieldDefinition originalField,
String newBinding); FieldDefinition switchToFieldType(FieldDefinition field,
String fieldCode); void saveFormField(FieldDefinition originalField,
FieldDefinition fieldCopy); String generateUnboundFieldName(FieldDefinition field); Collection<EditorFieldLayoutComponent> getBaseFieldsDraggables(); Map<String, FieldDefinition> getAvailableFields(); FormEditorRenderingContext getRenderingContext(); @PreDestroy void destroy(); static final String UNBOUND_FIELD_NAME_PREFFIX; } |
@Test public void testShowWithModelError() { content.setError(mock(FormModelerContentError.class)); presenter.show(content, command); } | public void show(FormModelerContent content, Command onClose) { PortablePreconditions.checkNotNull("content", content); PortablePreconditions.checkNotNull("onClose", onClose); if(content.getError() != null) { return; } this.content = content; this.onClose = onClose; this.canDisplay = false; checkNewModelFields(); checkContentConflicts(); if (canDisplay) { view.show(); } } | ChangesNotificationDisplayer implements ChangesNotificationDisplayerView.Presenter { public void show(FormModelerContent content, Command onClose) { PortablePreconditions.checkNotNull("content", content); PortablePreconditions.checkNotNull("onClose", onClose); if(content.getError() != null) { return; } this.content = content; this.onClose = onClose; this.canDisplay = false; checkNewModelFields(); checkContentConflicts(); if (canDisplay) { view.show(); } } } | ChangesNotificationDisplayer implements ChangesNotificationDisplayerView.Presenter { public void show(FormModelerContent content, Command onClose) { PortablePreconditions.checkNotNull("content", content); PortablePreconditions.checkNotNull("onClose", onClose); if(content.getError() != null) { return; } this.content = content; this.onClose = onClose; this.canDisplay = false; checkNewModelFields(); checkContentConflicts(); if (canDisplay) { view.show(); } } @Inject ChangesNotificationDisplayer(ChangesNotificationDisplayerView view,
ConflictsDisplayer conflictsDisplayer,
NewPropertiesDisplayer newPropertiesDisplayer,
FieldManager fieldManager); } | ChangesNotificationDisplayer implements ChangesNotificationDisplayerView.Presenter { public void show(FormModelerContent content, Command onClose) { PortablePreconditions.checkNotNull("content", content); PortablePreconditions.checkNotNull("onClose", onClose); if(content.getError() != null) { return; } this.content = content; this.onClose = onClose; this.canDisplay = false; checkNewModelFields(); checkContentConflicts(); if (canDisplay) { view.show(); } } @Inject ChangesNotificationDisplayer(ChangesNotificationDisplayerView view,
ConflictsDisplayer conflictsDisplayer,
NewPropertiesDisplayer newPropertiesDisplayer,
FieldManager fieldManager); void show(FormModelerContent content, Command onClose); @Override FormModel getFormModel(); @Override void close(); } | ChangesNotificationDisplayer implements ChangesNotificationDisplayerView.Presenter { public void show(FormModelerContent content, Command onClose) { PortablePreconditions.checkNotNull("content", content); PortablePreconditions.checkNotNull("onClose", onClose); if(content.getError() != null) { return; } this.content = content; this.onClose = onClose; this.canDisplay = false; checkNewModelFields(); checkContentConflicts(); if (canDisplay) { view.show(); } } @Inject ChangesNotificationDisplayer(ChangesNotificationDisplayerView view,
ConflictsDisplayer conflictsDisplayer,
NewPropertiesDisplayer newPropertiesDisplayer,
FieldManager fieldManager); void show(FormModelerContent content, Command onClose); @Override FormModel getFormModel(); @Override void close(); } |
@Test public void testShowEmptySynchronization() { presenter.show(content, command); verify(view, never()).show(); } | public void show(FormModelerContent content, Command onClose) { PortablePreconditions.checkNotNull("content", content); PortablePreconditions.checkNotNull("onClose", onClose); if(content.getError() != null) { return; } this.content = content; this.onClose = onClose; this.canDisplay = false; checkNewModelFields(); checkContentConflicts(); if (canDisplay) { view.show(); } } | ChangesNotificationDisplayer implements ChangesNotificationDisplayerView.Presenter { public void show(FormModelerContent content, Command onClose) { PortablePreconditions.checkNotNull("content", content); PortablePreconditions.checkNotNull("onClose", onClose); if(content.getError() != null) { return; } this.content = content; this.onClose = onClose; this.canDisplay = false; checkNewModelFields(); checkContentConflicts(); if (canDisplay) { view.show(); } } } | ChangesNotificationDisplayer implements ChangesNotificationDisplayerView.Presenter { public void show(FormModelerContent content, Command onClose) { PortablePreconditions.checkNotNull("content", content); PortablePreconditions.checkNotNull("onClose", onClose); if(content.getError() != null) { return; } this.content = content; this.onClose = onClose; this.canDisplay = false; checkNewModelFields(); checkContentConflicts(); if (canDisplay) { view.show(); } } @Inject ChangesNotificationDisplayer(ChangesNotificationDisplayerView view,
ConflictsDisplayer conflictsDisplayer,
NewPropertiesDisplayer newPropertiesDisplayer,
FieldManager fieldManager); } | ChangesNotificationDisplayer implements ChangesNotificationDisplayerView.Presenter { public void show(FormModelerContent content, Command onClose) { PortablePreconditions.checkNotNull("content", content); PortablePreconditions.checkNotNull("onClose", onClose); if(content.getError() != null) { return; } this.content = content; this.onClose = onClose; this.canDisplay = false; checkNewModelFields(); checkContentConflicts(); if (canDisplay) { view.show(); } } @Inject ChangesNotificationDisplayer(ChangesNotificationDisplayerView view,
ConflictsDisplayer conflictsDisplayer,
NewPropertiesDisplayer newPropertiesDisplayer,
FieldManager fieldManager); void show(FormModelerContent content, Command onClose); @Override FormModel getFormModel(); @Override void close(); } | ChangesNotificationDisplayer implements ChangesNotificationDisplayerView.Presenter { public void show(FormModelerContent content, Command onClose) { PortablePreconditions.checkNotNull("content", content); PortablePreconditions.checkNotNull("onClose", onClose); if(content.getError() != null) { return; } this.content = content; this.onClose = onClose; this.canDisplay = false; checkNewModelFields(); checkContentConflicts(); if (canDisplay) { view.show(); } } @Inject ChangesNotificationDisplayer(ChangesNotificationDisplayerView view,
ConflictsDisplayer conflictsDisplayer,
NewPropertiesDisplayer newPropertiesDisplayer,
FieldManager fieldManager); void show(FormModelerContent content, Command onClose); @Override FormModel getFormModel(); @Override void close(); } |
@Test public void testListBoxWithExistingDefaultValue() { when(field.getDefaultValue()).thenReturn(VAL_2); SelectorData<String> data = provider.getSelectorData(context); doTestVerifications(data); assertNotNull(data.getSelectedValue()); assertEquals(VAL_2, data.getSelectedValue()); } | @Override public SelectorData getSelectorData(FormRenderingContext context) { SelectorData data = new SelectorData<>(); Map<Object, String> values = new HashMap<>(); Object selectedValue = null; if (context.getModel() instanceof SelectorFieldBaseDefinition) { SelectorFieldBaseDefinition selector = (SelectorFieldBaseDefinition) context.getModel(); selectedValue = selector.getDefaultValue(); List<SelectorOption> options = selector.getOptions(); options.forEach(option -> values.put(option.getValue(), option.getText())); if (!values.containsKey(selectedValue)) { selectedValue = null; selector.setDefaultValue(null); } } data.setValues(values); data.setSelectedValue(selectedValue); return data; } | SelectorOptionsProvider implements SystemSelectorDataProvider { @Override public SelectorData getSelectorData(FormRenderingContext context) { SelectorData data = new SelectorData<>(); Map<Object, String> values = new HashMap<>(); Object selectedValue = null; if (context.getModel() instanceof SelectorFieldBaseDefinition) { SelectorFieldBaseDefinition selector = (SelectorFieldBaseDefinition) context.getModel(); selectedValue = selector.getDefaultValue(); List<SelectorOption> options = selector.getOptions(); options.forEach(option -> values.put(option.getValue(), option.getText())); if (!values.containsKey(selectedValue)) { selectedValue = null; selector.setDefaultValue(null); } } data.setValues(values); data.setSelectedValue(selectedValue); return data; } } | SelectorOptionsProvider implements SystemSelectorDataProvider { @Override public SelectorData getSelectorData(FormRenderingContext context) { SelectorData data = new SelectorData<>(); Map<Object, String> values = new HashMap<>(); Object selectedValue = null; if (context.getModel() instanceof SelectorFieldBaseDefinition) { SelectorFieldBaseDefinition selector = (SelectorFieldBaseDefinition) context.getModel(); selectedValue = selector.getDefaultValue(); List<SelectorOption> options = selector.getOptions(); options.forEach(option -> values.put(option.getValue(), option.getText())); if (!values.containsKey(selectedValue)) { selectedValue = null; selector.setDefaultValue(null); } } data.setValues(values); data.setSelectedValue(selectedValue); return data; } } | SelectorOptionsProvider implements SystemSelectorDataProvider { @Override public SelectorData getSelectorData(FormRenderingContext context) { SelectorData data = new SelectorData<>(); Map<Object, String> values = new HashMap<>(); Object selectedValue = null; if (context.getModel() instanceof SelectorFieldBaseDefinition) { SelectorFieldBaseDefinition selector = (SelectorFieldBaseDefinition) context.getModel(); selectedValue = selector.getDefaultValue(); List<SelectorOption> options = selector.getOptions(); options.forEach(option -> values.put(option.getValue(), option.getText())); if (!values.containsKey(selectedValue)) { selectedValue = null; selector.setDefaultValue(null); } } data.setValues(values); data.setSelectedValue(selectedValue); return data; } @Override String getProviderName(); @Override SelectorData getSelectorData(FormRenderingContext context); } | SelectorOptionsProvider implements SystemSelectorDataProvider { @Override public SelectorData getSelectorData(FormRenderingContext context) { SelectorData data = new SelectorData<>(); Map<Object, String> values = new HashMap<>(); Object selectedValue = null; if (context.getModel() instanceof SelectorFieldBaseDefinition) { SelectorFieldBaseDefinition selector = (SelectorFieldBaseDefinition) context.getModel(); selectedValue = selector.getDefaultValue(); List<SelectorOption> options = selector.getOptions(); options.forEach(option -> values.put(option.getValue(), option.getText())); if (!values.containsKey(selectedValue)) { selectedValue = null; selector.setDefaultValue(null); } } data.setValues(values); data.setSelectedValue(selectedValue); return data; } @Override String getProviderName(); @Override SelectorData getSelectorData(FormRenderingContext context); } |
@Test public void testListBoxWithoutDefaultValue() { SelectorData<String> data = provider.getSelectorData(context); doTestVerifications(data); assertNull(data.getSelectedValue()); } | @Override public SelectorData getSelectorData(FormRenderingContext context) { SelectorData data = new SelectorData<>(); Map<Object, String> values = new HashMap<>(); Object selectedValue = null; if (context.getModel() instanceof SelectorFieldBaseDefinition) { SelectorFieldBaseDefinition selector = (SelectorFieldBaseDefinition) context.getModel(); selectedValue = selector.getDefaultValue(); List<SelectorOption> options = selector.getOptions(); options.forEach(option -> values.put(option.getValue(), option.getText())); if (!values.containsKey(selectedValue)) { selectedValue = null; selector.setDefaultValue(null); } } data.setValues(values); data.setSelectedValue(selectedValue); return data; } | SelectorOptionsProvider implements SystemSelectorDataProvider { @Override public SelectorData getSelectorData(FormRenderingContext context) { SelectorData data = new SelectorData<>(); Map<Object, String> values = new HashMap<>(); Object selectedValue = null; if (context.getModel() instanceof SelectorFieldBaseDefinition) { SelectorFieldBaseDefinition selector = (SelectorFieldBaseDefinition) context.getModel(); selectedValue = selector.getDefaultValue(); List<SelectorOption> options = selector.getOptions(); options.forEach(option -> values.put(option.getValue(), option.getText())); if (!values.containsKey(selectedValue)) { selectedValue = null; selector.setDefaultValue(null); } } data.setValues(values); data.setSelectedValue(selectedValue); return data; } } | SelectorOptionsProvider implements SystemSelectorDataProvider { @Override public SelectorData getSelectorData(FormRenderingContext context) { SelectorData data = new SelectorData<>(); Map<Object, String> values = new HashMap<>(); Object selectedValue = null; if (context.getModel() instanceof SelectorFieldBaseDefinition) { SelectorFieldBaseDefinition selector = (SelectorFieldBaseDefinition) context.getModel(); selectedValue = selector.getDefaultValue(); List<SelectorOption> options = selector.getOptions(); options.forEach(option -> values.put(option.getValue(), option.getText())); if (!values.containsKey(selectedValue)) { selectedValue = null; selector.setDefaultValue(null); } } data.setValues(values); data.setSelectedValue(selectedValue); return data; } } | SelectorOptionsProvider implements SystemSelectorDataProvider { @Override public SelectorData getSelectorData(FormRenderingContext context) { SelectorData data = new SelectorData<>(); Map<Object, String> values = new HashMap<>(); Object selectedValue = null; if (context.getModel() instanceof SelectorFieldBaseDefinition) { SelectorFieldBaseDefinition selector = (SelectorFieldBaseDefinition) context.getModel(); selectedValue = selector.getDefaultValue(); List<SelectorOption> options = selector.getOptions(); options.forEach(option -> values.put(option.getValue(), option.getText())); if (!values.containsKey(selectedValue)) { selectedValue = null; selector.setDefaultValue(null); } } data.setValues(values); data.setSelectedValue(selectedValue); return data; } @Override String getProviderName(); @Override SelectorData getSelectorData(FormRenderingContext context); } | SelectorOptionsProvider implements SystemSelectorDataProvider { @Override public SelectorData getSelectorData(FormRenderingContext context) { SelectorData data = new SelectorData<>(); Map<Object, String> values = new HashMap<>(); Object selectedValue = null; if (context.getModel() instanceof SelectorFieldBaseDefinition) { SelectorFieldBaseDefinition selector = (SelectorFieldBaseDefinition) context.getModel(); selectedValue = selector.getDefaultValue(); List<SelectorOption> options = selector.getOptions(); options.forEach(option -> values.put(option.getValue(), option.getText())); if (!values.containsKey(selectedValue)) { selectedValue = null; selector.setDefaultValue(null); } } data.setValues(values); data.setSelectedValue(selectedValue); return data; } @Override String getProviderName(); @Override SelectorData getSelectorData(FormRenderingContext context); } |
@Test public void testLoad() { loadContent(); verify(layoutEditorMock).loadLayout(content.getDefinition().getLayoutTemplate()); verify(view).init(presenter); verify(view).setupLayoutEditor(layoutEditorMock); } | @Override protected void loadContent() { editorService.call((RemoteCallback<FormModelerContent>) content -> doLoadContent(content), getNoSuchFileExceptionErrorCallback()).loadContent(versionRecordManager.getCurrentPath()); } | FormEditorPresenter extends KieEditor<FormModelerContent> { @Override protected void loadContent() { editorService.call((RemoteCallback<FormModelerContent>) content -> doLoadContent(content), getNoSuchFileExceptionErrorCallback()).loadContent(versionRecordManager.getCurrentPath()); } } | FormEditorPresenter extends KieEditor<FormModelerContent> { @Override protected void loadContent() { editorService.call((RemoteCallback<FormModelerContent>) content -> doLoadContent(content), getNoSuchFileExceptionErrorCallback()).loadContent(versionRecordManager.getCurrentPath()); } @Inject FormEditorPresenter(FormEditorView view,
ChangesNotificationDisplayer changesNotificationDisplayer,
FormDefinitionResourceType resourceType,
Caller<FormEditorService> editorService,
TranslationService translationService,
ManagedInstance<EditorFieldLayoutComponent> editorFieldLayoutComponents,
ShowAssetUsagesDisplayer showAssetUsagesDisplayer,
ErrorMessageDisplayer errorMessageDisplayer,
LayoutEditorPropertiesPresenter layoutEditorPropertiesPresenter); } | FormEditorPresenter extends KieEditor<FormModelerContent> { @Override protected void loadContent() { editorService.call((RemoteCallback<FormModelerContent>) content -> doLoadContent(content), getNoSuchFileExceptionErrorCallback()).loadContent(versionRecordManager.getCurrentPath()); } @Inject FormEditorPresenter(FormEditorView view,
ChangesNotificationDisplayer changesNotificationDisplayer,
FormDefinitionResourceType resourceType,
Caller<FormEditorService> editorService,
TranslationService translationService,
ManagedInstance<EditorFieldLayoutComponent> editorFieldLayoutComponents,
ShowAssetUsagesDisplayer showAssetUsagesDisplayer,
ErrorMessageDisplayer errorMessageDisplayer,
LayoutEditorPropertiesPresenter layoutEditorPropertiesPresenter); @OnStartup void onStartup(final ObservablePath path,
final PlaceRequest place); @OnFocus void onFocus(); @Override void hideDocks(); void doLoadContent(final FormModelerContent content); @Override @WorkbenchPartTitle String getTitleText(); @WorkbenchMenu void getMenus(final Consumer<Menus> menusConsumer); @Override @WorkbenchPartView IsWidget getWidget(); void copy(boolean save); void rename(boolean save); LayoutTemplate getFormTemplate(); FormDefinition getFormDefinition(); void onRemoveComponent(@Observes ComponentRemovedEvent event); void onLayoutEditorElementSelectEvent(@Observes LayoutEditorElementSelectEvent event); void onSyncPalette(@Observes FormEditorSyncPaletteEvent event); void onSyncPalette(String formId); void safeDelete(); @OnMayClose Boolean onMayClose(); @PreDestroy void destroy(); void onLockStatusChange(@Observes UpdatedLockStatusEvent updatedLockStatusEvent); } | FormEditorPresenter extends KieEditor<FormModelerContent> { @Override protected void loadContent() { editorService.call((RemoteCallback<FormModelerContent>) content -> doLoadContent(content), getNoSuchFileExceptionErrorCallback()).loadContent(versionRecordManager.getCurrentPath()); } @Inject FormEditorPresenter(FormEditorView view,
ChangesNotificationDisplayer changesNotificationDisplayer,
FormDefinitionResourceType resourceType,
Caller<FormEditorService> editorService,
TranslationService translationService,
ManagedInstance<EditorFieldLayoutComponent> editorFieldLayoutComponents,
ShowAssetUsagesDisplayer showAssetUsagesDisplayer,
ErrorMessageDisplayer errorMessageDisplayer,
LayoutEditorPropertiesPresenter layoutEditorPropertiesPresenter); @OnStartup void onStartup(final ObservablePath path,
final PlaceRequest place); @OnFocus void onFocus(); @Override void hideDocks(); void doLoadContent(final FormModelerContent content); @Override @WorkbenchPartTitle String getTitleText(); @WorkbenchMenu void getMenus(final Consumer<Menus> menusConsumer); @Override @WorkbenchPartView IsWidget getWidget(); void copy(boolean save); void rename(boolean save); LayoutTemplate getFormTemplate(); FormDefinition getFormDefinition(); void onRemoveComponent(@Observes ComponentRemovedEvent event); void onLayoutEditorElementSelectEvent(@Observes LayoutEditorElementSelectEvent event); void onSyncPalette(@Observes FormEditorSyncPaletteEvent event); void onSyncPalette(String formId); void safeDelete(); @OnMayClose Boolean onMayClose(); @PreDestroy void destroy(); void onLockStatusChange(@Observes UpdatedLockStatusEvent updatedLockStatusEvent); static final String ID; } |
@Test public void testMayClose() { testLoad(); assertTrue(presenter.onMayClose()); verify(view, never()).confirmClose(); testOnRemoveComponentWithContext(); assertFalse(presenter.onMayClose()); } | @OnMayClose public Boolean onMayClose() { return mayClose(editorHelper.getContent().getDefinition().hashCode()); } | FormEditorPresenter extends KieEditor<FormModelerContent> { @OnMayClose public Boolean onMayClose() { return mayClose(editorHelper.getContent().getDefinition().hashCode()); } } | FormEditorPresenter extends KieEditor<FormModelerContent> { @OnMayClose public Boolean onMayClose() { return mayClose(editorHelper.getContent().getDefinition().hashCode()); } @Inject FormEditorPresenter(FormEditorView view,
ChangesNotificationDisplayer changesNotificationDisplayer,
FormDefinitionResourceType resourceType,
Caller<FormEditorService> editorService,
TranslationService translationService,
ManagedInstance<EditorFieldLayoutComponent> editorFieldLayoutComponents,
ShowAssetUsagesDisplayer showAssetUsagesDisplayer,
ErrorMessageDisplayer errorMessageDisplayer,
LayoutEditorPropertiesPresenter layoutEditorPropertiesPresenter); } | FormEditorPresenter extends KieEditor<FormModelerContent> { @OnMayClose public Boolean onMayClose() { return mayClose(editorHelper.getContent().getDefinition().hashCode()); } @Inject FormEditorPresenter(FormEditorView view,
ChangesNotificationDisplayer changesNotificationDisplayer,
FormDefinitionResourceType resourceType,
Caller<FormEditorService> editorService,
TranslationService translationService,
ManagedInstance<EditorFieldLayoutComponent> editorFieldLayoutComponents,
ShowAssetUsagesDisplayer showAssetUsagesDisplayer,
ErrorMessageDisplayer errorMessageDisplayer,
LayoutEditorPropertiesPresenter layoutEditorPropertiesPresenter); @OnStartup void onStartup(final ObservablePath path,
final PlaceRequest place); @OnFocus void onFocus(); @Override void hideDocks(); void doLoadContent(final FormModelerContent content); @Override @WorkbenchPartTitle String getTitleText(); @WorkbenchMenu void getMenus(final Consumer<Menus> menusConsumer); @Override @WorkbenchPartView IsWidget getWidget(); void copy(boolean save); void rename(boolean save); LayoutTemplate getFormTemplate(); FormDefinition getFormDefinition(); void onRemoveComponent(@Observes ComponentRemovedEvent event); void onLayoutEditorElementSelectEvent(@Observes LayoutEditorElementSelectEvent event); void onSyncPalette(@Observes FormEditorSyncPaletteEvent event); void onSyncPalette(String formId); void safeDelete(); @OnMayClose Boolean onMayClose(); @PreDestroy void destroy(); void onLockStatusChange(@Observes UpdatedLockStatusEvent updatedLockStatusEvent); } | FormEditorPresenter extends KieEditor<FormModelerContent> { @OnMayClose public Boolean onMayClose() { return mayClose(editorHelper.getContent().getDefinition().hashCode()); } @Inject FormEditorPresenter(FormEditorView view,
ChangesNotificationDisplayer changesNotificationDisplayer,
FormDefinitionResourceType resourceType,
Caller<FormEditorService> editorService,
TranslationService translationService,
ManagedInstance<EditorFieldLayoutComponent> editorFieldLayoutComponents,
ShowAssetUsagesDisplayer showAssetUsagesDisplayer,
ErrorMessageDisplayer errorMessageDisplayer,
LayoutEditorPropertiesPresenter layoutEditorPropertiesPresenter); @OnStartup void onStartup(final ObservablePath path,
final PlaceRequest place); @OnFocus void onFocus(); @Override void hideDocks(); void doLoadContent(final FormModelerContent content); @Override @WorkbenchPartTitle String getTitleText(); @WorkbenchMenu void getMenus(final Consumer<Menus> menusConsumer); @Override @WorkbenchPartView IsWidget getWidget(); void copy(boolean save); void rename(boolean save); LayoutTemplate getFormTemplate(); FormDefinition getFormDefinition(); void onRemoveComponent(@Observes ComponentRemovedEvent event); void onLayoutEditorElementSelectEvent(@Observes LayoutEditorElementSelectEvent event); void onSyncPalette(@Observes FormEditorSyncPaletteEvent event); void onSyncPalette(String formId); void safeDelete(); @OnMayClose Boolean onMayClose(); @PreDestroy void destroy(); void onLockStatusChange(@Observes UpdatedLockStatusEvent updatedLockStatusEvent); static final String ID; } |
@Test public void testDataObjectsFields() { loadContent(); testAddRemoveDataTypeFields(); testDataTypeFieldProperties(); } | @Override protected void loadContent() { editorService.call((RemoteCallback<FormModelerContent>) content -> doLoadContent(content), getNoSuchFileExceptionErrorCallback()).loadContent(versionRecordManager.getCurrentPath()); } | FormEditorPresenter extends KieEditor<FormModelerContent> { @Override protected void loadContent() { editorService.call((RemoteCallback<FormModelerContent>) content -> doLoadContent(content), getNoSuchFileExceptionErrorCallback()).loadContent(versionRecordManager.getCurrentPath()); } } | FormEditorPresenter extends KieEditor<FormModelerContent> { @Override protected void loadContent() { editorService.call((RemoteCallback<FormModelerContent>) content -> doLoadContent(content), getNoSuchFileExceptionErrorCallback()).loadContent(versionRecordManager.getCurrentPath()); } @Inject FormEditorPresenter(FormEditorView view,
ChangesNotificationDisplayer changesNotificationDisplayer,
FormDefinitionResourceType resourceType,
Caller<FormEditorService> editorService,
TranslationService translationService,
ManagedInstance<EditorFieldLayoutComponent> editorFieldLayoutComponents,
ShowAssetUsagesDisplayer showAssetUsagesDisplayer,
ErrorMessageDisplayer errorMessageDisplayer,
LayoutEditorPropertiesPresenter layoutEditorPropertiesPresenter); } | FormEditorPresenter extends KieEditor<FormModelerContent> { @Override protected void loadContent() { editorService.call((RemoteCallback<FormModelerContent>) content -> doLoadContent(content), getNoSuchFileExceptionErrorCallback()).loadContent(versionRecordManager.getCurrentPath()); } @Inject FormEditorPresenter(FormEditorView view,
ChangesNotificationDisplayer changesNotificationDisplayer,
FormDefinitionResourceType resourceType,
Caller<FormEditorService> editorService,
TranslationService translationService,
ManagedInstance<EditorFieldLayoutComponent> editorFieldLayoutComponents,
ShowAssetUsagesDisplayer showAssetUsagesDisplayer,
ErrorMessageDisplayer errorMessageDisplayer,
LayoutEditorPropertiesPresenter layoutEditorPropertiesPresenter); @OnStartup void onStartup(final ObservablePath path,
final PlaceRequest place); @OnFocus void onFocus(); @Override void hideDocks(); void doLoadContent(final FormModelerContent content); @Override @WorkbenchPartTitle String getTitleText(); @WorkbenchMenu void getMenus(final Consumer<Menus> menusConsumer); @Override @WorkbenchPartView IsWidget getWidget(); void copy(boolean save); void rename(boolean save); LayoutTemplate getFormTemplate(); FormDefinition getFormDefinition(); void onRemoveComponent(@Observes ComponentRemovedEvent event); void onLayoutEditorElementSelectEvent(@Observes LayoutEditorElementSelectEvent event); void onSyncPalette(@Observes FormEditorSyncPaletteEvent event); void onSyncPalette(String formId); void safeDelete(); @OnMayClose Boolean onMayClose(); @PreDestroy void destroy(); void onLockStatusChange(@Observes UpdatedLockStatusEvent updatedLockStatusEvent); } | FormEditorPresenter extends KieEditor<FormModelerContent> { @Override protected void loadContent() { editorService.call((RemoteCallback<FormModelerContent>) content -> doLoadContent(content), getNoSuchFileExceptionErrorCallback()).loadContent(versionRecordManager.getCurrentPath()); } @Inject FormEditorPresenter(FormEditorView view,
ChangesNotificationDisplayer changesNotificationDisplayer,
FormDefinitionResourceType resourceType,
Caller<FormEditorService> editorService,
TranslationService translationService,
ManagedInstance<EditorFieldLayoutComponent> editorFieldLayoutComponents,
ShowAssetUsagesDisplayer showAssetUsagesDisplayer,
ErrorMessageDisplayer errorMessageDisplayer,
LayoutEditorPropertiesPresenter layoutEditorPropertiesPresenter); @OnStartup void onStartup(final ObservablePath path,
final PlaceRequest place); @OnFocus void onFocus(); @Override void hideDocks(); void doLoadContent(final FormModelerContent content); @Override @WorkbenchPartTitle String getTitleText(); @WorkbenchMenu void getMenus(final Consumer<Menus> menusConsumer); @Override @WorkbenchPartView IsWidget getWidget(); void copy(boolean save); void rename(boolean save); LayoutTemplate getFormTemplate(); FormDefinition getFormDefinition(); void onRemoveComponent(@Observes ComponentRemovedEvent event); void onLayoutEditorElementSelectEvent(@Observes LayoutEditorElementSelectEvent event); void onSyncPalette(@Observes FormEditorSyncPaletteEvent event); void onSyncPalette(String formId); void safeDelete(); @OnMayClose Boolean onMayClose(); @PreDestroy void destroy(); void onLockStatusChange(@Observes UpdatedLockStatusEvent updatedLockStatusEvent); static final String ID; } |
@Test public void testRemoveAllDraggableGroupComponent() { loadContent(); addAllFields(); when(layoutDragComponentPaletteMock.hasDraggableComponent(anyString(), anyString())).thenReturn(true); List<FieldDefinition> fieldList = presenter.getFormDefinition().getFields(); presenter.removeAllDraggableGroupComponent(fieldList); verify(translationService, times(1)).getTranslation(FormEditorConstants.FormEditorPresenterModelFields); verify(layoutDragComponentPaletteMock, times(fieldList.size())).removeDraggableComponent(anyString(), anyString()); } | protected void removeAllDraggableGroupComponent(Collection<FieldDefinition> fields) { String groupId = translationService.getTranslation(FormEditorConstants.FormEditorPresenterModelFields); Iterator<FieldDefinition> it = fields.iterator(); while (it.hasNext()) { FieldDefinition field = it.next(); if (layoutDragComponentPalette.hasDraggableComponent(groupId, field.getId())) { layoutDragComponentPalette.removeDraggableComponent(groupId, field.getId()); } } } | FormEditorPresenter extends KieEditor<FormModelerContent> { protected void removeAllDraggableGroupComponent(Collection<FieldDefinition> fields) { String groupId = translationService.getTranslation(FormEditorConstants.FormEditorPresenterModelFields); Iterator<FieldDefinition> it = fields.iterator(); while (it.hasNext()) { FieldDefinition field = it.next(); if (layoutDragComponentPalette.hasDraggableComponent(groupId, field.getId())) { layoutDragComponentPalette.removeDraggableComponent(groupId, field.getId()); } } } } | FormEditorPresenter extends KieEditor<FormModelerContent> { protected void removeAllDraggableGroupComponent(Collection<FieldDefinition> fields) { String groupId = translationService.getTranslation(FormEditorConstants.FormEditorPresenterModelFields); Iterator<FieldDefinition> it = fields.iterator(); while (it.hasNext()) { FieldDefinition field = it.next(); if (layoutDragComponentPalette.hasDraggableComponent(groupId, field.getId())) { layoutDragComponentPalette.removeDraggableComponent(groupId, field.getId()); } } } @Inject FormEditorPresenter(FormEditorView view,
ChangesNotificationDisplayer changesNotificationDisplayer,
FormDefinitionResourceType resourceType,
Caller<FormEditorService> editorService,
TranslationService translationService,
ManagedInstance<EditorFieldLayoutComponent> editorFieldLayoutComponents,
ShowAssetUsagesDisplayer showAssetUsagesDisplayer,
ErrorMessageDisplayer errorMessageDisplayer,
LayoutEditorPropertiesPresenter layoutEditorPropertiesPresenter); } | FormEditorPresenter extends KieEditor<FormModelerContent> { protected void removeAllDraggableGroupComponent(Collection<FieldDefinition> fields) { String groupId = translationService.getTranslation(FormEditorConstants.FormEditorPresenterModelFields); Iterator<FieldDefinition> it = fields.iterator(); while (it.hasNext()) { FieldDefinition field = it.next(); if (layoutDragComponentPalette.hasDraggableComponent(groupId, field.getId())) { layoutDragComponentPalette.removeDraggableComponent(groupId, field.getId()); } } } @Inject FormEditorPresenter(FormEditorView view,
ChangesNotificationDisplayer changesNotificationDisplayer,
FormDefinitionResourceType resourceType,
Caller<FormEditorService> editorService,
TranslationService translationService,
ManagedInstance<EditorFieldLayoutComponent> editorFieldLayoutComponents,
ShowAssetUsagesDisplayer showAssetUsagesDisplayer,
ErrorMessageDisplayer errorMessageDisplayer,
LayoutEditorPropertiesPresenter layoutEditorPropertiesPresenter); @OnStartup void onStartup(final ObservablePath path,
final PlaceRequest place); @OnFocus void onFocus(); @Override void hideDocks(); void doLoadContent(final FormModelerContent content); @Override @WorkbenchPartTitle String getTitleText(); @WorkbenchMenu void getMenus(final Consumer<Menus> menusConsumer); @Override @WorkbenchPartView IsWidget getWidget(); void copy(boolean save); void rename(boolean save); LayoutTemplate getFormTemplate(); FormDefinition getFormDefinition(); void onRemoveComponent(@Observes ComponentRemovedEvent event); void onLayoutEditorElementSelectEvent(@Observes LayoutEditorElementSelectEvent event); void onSyncPalette(@Observes FormEditorSyncPaletteEvent event); void onSyncPalette(String formId); void safeDelete(); @OnMayClose Boolean onMayClose(); @PreDestroy void destroy(); void onLockStatusChange(@Observes UpdatedLockStatusEvent updatedLockStatusEvent); } | FormEditorPresenter extends KieEditor<FormModelerContent> { protected void removeAllDraggableGroupComponent(Collection<FieldDefinition> fields) { String groupId = translationService.getTranslation(FormEditorConstants.FormEditorPresenterModelFields); Iterator<FieldDefinition> it = fields.iterator(); while (it.hasNext()) { FieldDefinition field = it.next(); if (layoutDragComponentPalette.hasDraggableComponent(groupId, field.getId())) { layoutDragComponentPalette.removeDraggableComponent(groupId, field.getId()); } } } @Inject FormEditorPresenter(FormEditorView view,
ChangesNotificationDisplayer changesNotificationDisplayer,
FormDefinitionResourceType resourceType,
Caller<FormEditorService> editorService,
TranslationService translationService,
ManagedInstance<EditorFieldLayoutComponent> editorFieldLayoutComponents,
ShowAssetUsagesDisplayer showAssetUsagesDisplayer,
ErrorMessageDisplayer errorMessageDisplayer,
LayoutEditorPropertiesPresenter layoutEditorPropertiesPresenter); @OnStartup void onStartup(final ObservablePath path,
final PlaceRequest place); @OnFocus void onFocus(); @Override void hideDocks(); void doLoadContent(final FormModelerContent content); @Override @WorkbenchPartTitle String getTitleText(); @WorkbenchMenu void getMenus(final Consumer<Menus> menusConsumer); @Override @WorkbenchPartView IsWidget getWidget(); void copy(boolean save); void rename(boolean save); LayoutTemplate getFormTemplate(); FormDefinition getFormDefinition(); void onRemoveComponent(@Observes ComponentRemovedEvent event); void onLayoutEditorElementSelectEvent(@Observes LayoutEditorElementSelectEvent event); void onSyncPalette(@Observes FormEditorSyncPaletteEvent event); void onSyncPalette(String formId); void safeDelete(); @OnMayClose Boolean onMayClose(); @PreDestroy void destroy(); void onLockStatusChange(@Observes UpdatedLockStatusEvent updatedLockStatusEvent); static final String ID; } |
@Test public void testGetDividerLineY() { assertThat(view.getDividerLineY()).isEqualTo(0.0); } | public double getDividerLineY() { return divider.getY(); } | DecisionServiceSVGShapeView extends SVGShapeViewImpl { public double getDividerLineY() { return divider.getY(); } } | DecisionServiceSVGShapeView extends SVGShapeViewImpl { public double getDividerLineY() { return divider.getY(); } DecisionServiceSVGShapeView(final String name,
final SVGPrimitiveShape svgPrimitive,
final double width,
final double height,
final boolean resizable); } | DecisionServiceSVGShapeView extends SVGShapeViewImpl { public double getDividerLineY() { return divider.getY(); } DecisionServiceSVGShapeView(final String name,
final SVGPrimitiveShape svgPrimitive,
final double width,
final double height,
final boolean resizable); DecisionServiceSVGShapeView addDividerDragHandler(final DragHandler dragHandler); double getDividerLineY(); void setDividerLineY(final double y); @Override //Override to increase visibility for Unit Tests HandlerManager getHandlerManager(); @Override void destroy(); } | DecisionServiceSVGShapeView extends SVGShapeViewImpl { public double getDividerLineY() { return divider.getY(); } DecisionServiceSVGShapeView(final String name,
final SVGPrimitiveShape svgPrimitive,
final double width,
final double height,
final boolean resizable); DecisionServiceSVGShapeView addDividerDragHandler(final DragHandler dragHandler); double getDividerLineY(); void setDividerLineY(final double y); @Override //Override to increase visibility for Unit Tests HandlerManager getHandlerManager(); @Override void destroy(); } |
@Test public void testAddAllDraggableGroupComponent() { loadContent(); List<FieldDefinition> fieldList = presenter.getFormDefinition().getFields(); presenter.addAllDraggableGroupComponent(fieldList); verify(layoutDragComponentPaletteMock, times(fieldList.size())).addDraggableComponent(anyString(), anyString(), any()); } | protected void addAllDraggableGroupComponent(Collection<FieldDefinition> fields) { String groupId = translationService.getTranslation(FormEditorConstants.FormEditorPresenterModelFields); Iterator<FieldDefinition> it = fields.iterator(); while (it.hasNext()) { FieldDefinition field = it.next(); EditorFieldLayoutComponent layoutFieldComponent = editorFieldLayoutComponents.get(); if (layoutFieldComponent != null) { layoutFieldComponent.init(editorHelper.getRenderingContext(), field); layoutDragComponentPalette.addDraggableComponent(groupId, field.getId(), layoutFieldComponent); } } } | FormEditorPresenter extends KieEditor<FormModelerContent> { protected void addAllDraggableGroupComponent(Collection<FieldDefinition> fields) { String groupId = translationService.getTranslation(FormEditorConstants.FormEditorPresenterModelFields); Iterator<FieldDefinition> it = fields.iterator(); while (it.hasNext()) { FieldDefinition field = it.next(); EditorFieldLayoutComponent layoutFieldComponent = editorFieldLayoutComponents.get(); if (layoutFieldComponent != null) { layoutFieldComponent.init(editorHelper.getRenderingContext(), field); layoutDragComponentPalette.addDraggableComponent(groupId, field.getId(), layoutFieldComponent); } } } } | FormEditorPresenter extends KieEditor<FormModelerContent> { protected void addAllDraggableGroupComponent(Collection<FieldDefinition> fields) { String groupId = translationService.getTranslation(FormEditorConstants.FormEditorPresenterModelFields); Iterator<FieldDefinition> it = fields.iterator(); while (it.hasNext()) { FieldDefinition field = it.next(); EditorFieldLayoutComponent layoutFieldComponent = editorFieldLayoutComponents.get(); if (layoutFieldComponent != null) { layoutFieldComponent.init(editorHelper.getRenderingContext(), field); layoutDragComponentPalette.addDraggableComponent(groupId, field.getId(), layoutFieldComponent); } } } @Inject FormEditorPresenter(FormEditorView view,
ChangesNotificationDisplayer changesNotificationDisplayer,
FormDefinitionResourceType resourceType,
Caller<FormEditorService> editorService,
TranslationService translationService,
ManagedInstance<EditorFieldLayoutComponent> editorFieldLayoutComponents,
ShowAssetUsagesDisplayer showAssetUsagesDisplayer,
ErrorMessageDisplayer errorMessageDisplayer,
LayoutEditorPropertiesPresenter layoutEditorPropertiesPresenter); } | FormEditorPresenter extends KieEditor<FormModelerContent> { protected void addAllDraggableGroupComponent(Collection<FieldDefinition> fields) { String groupId = translationService.getTranslation(FormEditorConstants.FormEditorPresenterModelFields); Iterator<FieldDefinition> it = fields.iterator(); while (it.hasNext()) { FieldDefinition field = it.next(); EditorFieldLayoutComponent layoutFieldComponent = editorFieldLayoutComponents.get(); if (layoutFieldComponent != null) { layoutFieldComponent.init(editorHelper.getRenderingContext(), field); layoutDragComponentPalette.addDraggableComponent(groupId, field.getId(), layoutFieldComponent); } } } @Inject FormEditorPresenter(FormEditorView view,
ChangesNotificationDisplayer changesNotificationDisplayer,
FormDefinitionResourceType resourceType,
Caller<FormEditorService> editorService,
TranslationService translationService,
ManagedInstance<EditorFieldLayoutComponent> editorFieldLayoutComponents,
ShowAssetUsagesDisplayer showAssetUsagesDisplayer,
ErrorMessageDisplayer errorMessageDisplayer,
LayoutEditorPropertiesPresenter layoutEditorPropertiesPresenter); @OnStartup void onStartup(final ObservablePath path,
final PlaceRequest place); @OnFocus void onFocus(); @Override void hideDocks(); void doLoadContent(final FormModelerContent content); @Override @WorkbenchPartTitle String getTitleText(); @WorkbenchMenu void getMenus(final Consumer<Menus> menusConsumer); @Override @WorkbenchPartView IsWidget getWidget(); void copy(boolean save); void rename(boolean save); LayoutTemplate getFormTemplate(); FormDefinition getFormDefinition(); void onRemoveComponent(@Observes ComponentRemovedEvent event); void onLayoutEditorElementSelectEvent(@Observes LayoutEditorElementSelectEvent event); void onSyncPalette(@Observes FormEditorSyncPaletteEvent event); void onSyncPalette(String formId); void safeDelete(); @OnMayClose Boolean onMayClose(); @PreDestroy void destroy(); void onLockStatusChange(@Observes UpdatedLockStatusEvent updatedLockStatusEvent); } | FormEditorPresenter extends KieEditor<FormModelerContent> { protected void addAllDraggableGroupComponent(Collection<FieldDefinition> fields) { String groupId = translationService.getTranslation(FormEditorConstants.FormEditorPresenterModelFields); Iterator<FieldDefinition> it = fields.iterator(); while (it.hasNext()) { FieldDefinition field = it.next(); EditorFieldLayoutComponent layoutFieldComponent = editorFieldLayoutComponents.get(); if (layoutFieldComponent != null) { layoutFieldComponent.init(editorHelper.getRenderingContext(), field); layoutDragComponentPalette.addDraggableComponent(groupId, field.getId(), layoutFieldComponent); } } } @Inject FormEditorPresenter(FormEditorView view,
ChangesNotificationDisplayer changesNotificationDisplayer,
FormDefinitionResourceType resourceType,
Caller<FormEditorService> editorService,
TranslationService translationService,
ManagedInstance<EditorFieldLayoutComponent> editorFieldLayoutComponents,
ShowAssetUsagesDisplayer showAssetUsagesDisplayer,
ErrorMessageDisplayer errorMessageDisplayer,
LayoutEditorPropertiesPresenter layoutEditorPropertiesPresenter); @OnStartup void onStartup(final ObservablePath path,
final PlaceRequest place); @OnFocus void onFocus(); @Override void hideDocks(); void doLoadContent(final FormModelerContent content); @Override @WorkbenchPartTitle String getTitleText(); @WorkbenchMenu void getMenus(final Consumer<Menus> menusConsumer); @Override @WorkbenchPartView IsWidget getWidget(); void copy(boolean save); void rename(boolean save); LayoutTemplate getFormTemplate(); FormDefinition getFormDefinition(); void onRemoveComponent(@Observes ComponentRemovedEvent event); void onLayoutEditorElementSelectEvent(@Observes LayoutEditorElementSelectEvent event); void onSyncPalette(@Observes FormEditorSyncPaletteEvent event); void onSyncPalette(String formId); void safeDelete(); @OnMayClose Boolean onMayClose(); @PreDestroy void destroy(); void onLockStatusChange(@Observes UpdatedLockStatusEvent updatedLockStatusEvent); static final String ID; } |
@Test public void testDestroy() { loadContent(); presenter.destroy(); verify(editorFieldLayoutComponents).destroyAll(); } | @PreDestroy public void destroy() { if (Objects.equals(FormEditorContext.getActiveEditorHelper(), editorHelper)) { FormEditorContext.setActiveEditorHelper(null); } editorFieldLayoutComponents.destroyAll(); } | FormEditorPresenter extends KieEditor<FormModelerContent> { @PreDestroy public void destroy() { if (Objects.equals(FormEditorContext.getActiveEditorHelper(), editorHelper)) { FormEditorContext.setActiveEditorHelper(null); } editorFieldLayoutComponents.destroyAll(); } } | FormEditorPresenter extends KieEditor<FormModelerContent> { @PreDestroy public void destroy() { if (Objects.equals(FormEditorContext.getActiveEditorHelper(), editorHelper)) { FormEditorContext.setActiveEditorHelper(null); } editorFieldLayoutComponents.destroyAll(); } @Inject FormEditorPresenter(FormEditorView view,
ChangesNotificationDisplayer changesNotificationDisplayer,
FormDefinitionResourceType resourceType,
Caller<FormEditorService> editorService,
TranslationService translationService,
ManagedInstance<EditorFieldLayoutComponent> editorFieldLayoutComponents,
ShowAssetUsagesDisplayer showAssetUsagesDisplayer,
ErrorMessageDisplayer errorMessageDisplayer,
LayoutEditorPropertiesPresenter layoutEditorPropertiesPresenter); } | FormEditorPresenter extends KieEditor<FormModelerContent> { @PreDestroy public void destroy() { if (Objects.equals(FormEditorContext.getActiveEditorHelper(), editorHelper)) { FormEditorContext.setActiveEditorHelper(null); } editorFieldLayoutComponents.destroyAll(); } @Inject FormEditorPresenter(FormEditorView view,
ChangesNotificationDisplayer changesNotificationDisplayer,
FormDefinitionResourceType resourceType,
Caller<FormEditorService> editorService,
TranslationService translationService,
ManagedInstance<EditorFieldLayoutComponent> editorFieldLayoutComponents,
ShowAssetUsagesDisplayer showAssetUsagesDisplayer,
ErrorMessageDisplayer errorMessageDisplayer,
LayoutEditorPropertiesPresenter layoutEditorPropertiesPresenter); @OnStartup void onStartup(final ObservablePath path,
final PlaceRequest place); @OnFocus void onFocus(); @Override void hideDocks(); void doLoadContent(final FormModelerContent content); @Override @WorkbenchPartTitle String getTitleText(); @WorkbenchMenu void getMenus(final Consumer<Menus> menusConsumer); @Override @WorkbenchPartView IsWidget getWidget(); void copy(boolean save); void rename(boolean save); LayoutTemplate getFormTemplate(); FormDefinition getFormDefinition(); void onRemoveComponent(@Observes ComponentRemovedEvent event); void onLayoutEditorElementSelectEvent(@Observes LayoutEditorElementSelectEvent event); void onSyncPalette(@Observes FormEditorSyncPaletteEvent event); void onSyncPalette(String formId); void safeDelete(); @OnMayClose Boolean onMayClose(); @PreDestroy void destroy(); void onLockStatusChange(@Observes UpdatedLockStatusEvent updatedLockStatusEvent); } | FormEditorPresenter extends KieEditor<FormModelerContent> { @PreDestroy public void destroy() { if (Objects.equals(FormEditorContext.getActiveEditorHelper(), editorHelper)) { FormEditorContext.setActiveEditorHelper(null); } editorFieldLayoutComponents.destroyAll(); } @Inject FormEditorPresenter(FormEditorView view,
ChangesNotificationDisplayer changesNotificationDisplayer,
FormDefinitionResourceType resourceType,
Caller<FormEditorService> editorService,
TranslationService translationService,
ManagedInstance<EditorFieldLayoutComponent> editorFieldLayoutComponents,
ShowAssetUsagesDisplayer showAssetUsagesDisplayer,
ErrorMessageDisplayer errorMessageDisplayer,
LayoutEditorPropertiesPresenter layoutEditorPropertiesPresenter); @OnStartup void onStartup(final ObservablePath path,
final PlaceRequest place); @OnFocus void onFocus(); @Override void hideDocks(); void doLoadContent(final FormModelerContent content); @Override @WorkbenchPartTitle String getTitleText(); @WorkbenchMenu void getMenus(final Consumer<Menus> menusConsumer); @Override @WorkbenchPartView IsWidget getWidget(); void copy(boolean save); void rename(boolean save); LayoutTemplate getFormTemplate(); FormDefinition getFormDefinition(); void onRemoveComponent(@Observes ComponentRemovedEvent event); void onLayoutEditorElementSelectEvent(@Observes LayoutEditorElementSelectEvent event); void onSyncPalette(@Observes FormEditorSyncPaletteEvent event); void onSyncPalette(String formId); void safeDelete(); @OnMayClose Boolean onMayClose(); @PreDestroy void destroy(); void onLockStatusChange(@Observes UpdatedLockStatusEvent updatedLockStatusEvent); static final String ID; } |
@Test public void testGetFormTemplate() { loadContent(); presenter.getFormTemplate(); verify(layoutEditorMock).getLayout(); } | public LayoutTemplate getFormTemplate() { return layoutEditor.getLayout(); } | FormEditorPresenter extends KieEditor<FormModelerContent> { public LayoutTemplate getFormTemplate() { return layoutEditor.getLayout(); } } | FormEditorPresenter extends KieEditor<FormModelerContent> { public LayoutTemplate getFormTemplate() { return layoutEditor.getLayout(); } @Inject FormEditorPresenter(FormEditorView view,
ChangesNotificationDisplayer changesNotificationDisplayer,
FormDefinitionResourceType resourceType,
Caller<FormEditorService> editorService,
TranslationService translationService,
ManagedInstance<EditorFieldLayoutComponent> editorFieldLayoutComponents,
ShowAssetUsagesDisplayer showAssetUsagesDisplayer,
ErrorMessageDisplayer errorMessageDisplayer,
LayoutEditorPropertiesPresenter layoutEditorPropertiesPresenter); } | FormEditorPresenter extends KieEditor<FormModelerContent> { public LayoutTemplate getFormTemplate() { return layoutEditor.getLayout(); } @Inject FormEditorPresenter(FormEditorView view,
ChangesNotificationDisplayer changesNotificationDisplayer,
FormDefinitionResourceType resourceType,
Caller<FormEditorService> editorService,
TranslationService translationService,
ManagedInstance<EditorFieldLayoutComponent> editorFieldLayoutComponents,
ShowAssetUsagesDisplayer showAssetUsagesDisplayer,
ErrorMessageDisplayer errorMessageDisplayer,
LayoutEditorPropertiesPresenter layoutEditorPropertiesPresenter); @OnStartup void onStartup(final ObservablePath path,
final PlaceRequest place); @OnFocus void onFocus(); @Override void hideDocks(); void doLoadContent(final FormModelerContent content); @Override @WorkbenchPartTitle String getTitleText(); @WorkbenchMenu void getMenus(final Consumer<Menus> menusConsumer); @Override @WorkbenchPartView IsWidget getWidget(); void copy(boolean save); void rename(boolean save); LayoutTemplate getFormTemplate(); FormDefinition getFormDefinition(); void onRemoveComponent(@Observes ComponentRemovedEvent event); void onLayoutEditorElementSelectEvent(@Observes LayoutEditorElementSelectEvent event); void onSyncPalette(@Observes FormEditorSyncPaletteEvent event); void onSyncPalette(String formId); void safeDelete(); @OnMayClose Boolean onMayClose(); @PreDestroy void destroy(); void onLockStatusChange(@Observes UpdatedLockStatusEvent updatedLockStatusEvent); } | FormEditorPresenter extends KieEditor<FormModelerContent> { public LayoutTemplate getFormTemplate() { return layoutEditor.getLayout(); } @Inject FormEditorPresenter(FormEditorView view,
ChangesNotificationDisplayer changesNotificationDisplayer,
FormDefinitionResourceType resourceType,
Caller<FormEditorService> editorService,
TranslationService translationService,
ManagedInstance<EditorFieldLayoutComponent> editorFieldLayoutComponents,
ShowAssetUsagesDisplayer showAssetUsagesDisplayer,
ErrorMessageDisplayer errorMessageDisplayer,
LayoutEditorPropertiesPresenter layoutEditorPropertiesPresenter); @OnStartup void onStartup(final ObservablePath path,
final PlaceRequest place); @OnFocus void onFocus(); @Override void hideDocks(); void doLoadContent(final FormModelerContent content); @Override @WorkbenchPartTitle String getTitleText(); @WorkbenchMenu void getMenus(final Consumer<Menus> menusConsumer); @Override @WorkbenchPartView IsWidget getWidget(); void copy(boolean save); void rename(boolean save); LayoutTemplate getFormTemplate(); FormDefinition getFormDefinition(); void onRemoveComponent(@Observes ComponentRemovedEvent event); void onLayoutEditorElementSelectEvent(@Observes LayoutEditorElementSelectEvent event); void onSyncPalette(@Observes FormEditorSyncPaletteEvent event); void onSyncPalette(String formId); void safeDelete(); @OnMayClose Boolean onMayClose(); @PreDestroy void destroy(); void onLockStatusChange(@Observes UpdatedLockStatusEvent updatedLockStatusEvent); static final String ID; } |
@Test public void testSave() { loadContent(); presenter.editorHelper.getContent().getDefinition().setLayoutTemplate(mock(LayoutTemplate.class)); presenter.save(""); } | @Override protected void save(String commitMessage) { synchronizeFormLayout(); editorService.call(getSaveSuccessCallback(editorHelper.getContent().getDefinition().hashCode())) .save(versionRecordManager.getCurrentPath(), editorHelper.getContent(), metadata, commitMessage); } | FormEditorPresenter extends KieEditor<FormModelerContent> { @Override protected void save(String commitMessage) { synchronizeFormLayout(); editorService.call(getSaveSuccessCallback(editorHelper.getContent().getDefinition().hashCode())) .save(versionRecordManager.getCurrentPath(), editorHelper.getContent(), metadata, commitMessage); } } | FormEditorPresenter extends KieEditor<FormModelerContent> { @Override protected void save(String commitMessage) { synchronizeFormLayout(); editorService.call(getSaveSuccessCallback(editorHelper.getContent().getDefinition().hashCode())) .save(versionRecordManager.getCurrentPath(), editorHelper.getContent(), metadata, commitMessage); } @Inject FormEditorPresenter(FormEditorView view,
ChangesNotificationDisplayer changesNotificationDisplayer,
FormDefinitionResourceType resourceType,
Caller<FormEditorService> editorService,
TranslationService translationService,
ManagedInstance<EditorFieldLayoutComponent> editorFieldLayoutComponents,
ShowAssetUsagesDisplayer showAssetUsagesDisplayer,
ErrorMessageDisplayer errorMessageDisplayer,
LayoutEditorPropertiesPresenter layoutEditorPropertiesPresenter); } | FormEditorPresenter extends KieEditor<FormModelerContent> { @Override protected void save(String commitMessage) { synchronizeFormLayout(); editorService.call(getSaveSuccessCallback(editorHelper.getContent().getDefinition().hashCode())) .save(versionRecordManager.getCurrentPath(), editorHelper.getContent(), metadata, commitMessage); } @Inject FormEditorPresenter(FormEditorView view,
ChangesNotificationDisplayer changesNotificationDisplayer,
FormDefinitionResourceType resourceType,
Caller<FormEditorService> editorService,
TranslationService translationService,
ManagedInstance<EditorFieldLayoutComponent> editorFieldLayoutComponents,
ShowAssetUsagesDisplayer showAssetUsagesDisplayer,
ErrorMessageDisplayer errorMessageDisplayer,
LayoutEditorPropertiesPresenter layoutEditorPropertiesPresenter); @OnStartup void onStartup(final ObservablePath path,
final PlaceRequest place); @OnFocus void onFocus(); @Override void hideDocks(); void doLoadContent(final FormModelerContent content); @Override @WorkbenchPartTitle String getTitleText(); @WorkbenchMenu void getMenus(final Consumer<Menus> menusConsumer); @Override @WorkbenchPartView IsWidget getWidget(); void copy(boolean save); void rename(boolean save); LayoutTemplate getFormTemplate(); FormDefinition getFormDefinition(); void onRemoveComponent(@Observes ComponentRemovedEvent event); void onLayoutEditorElementSelectEvent(@Observes LayoutEditorElementSelectEvent event); void onSyncPalette(@Observes FormEditorSyncPaletteEvent event); void onSyncPalette(String formId); void safeDelete(); @OnMayClose Boolean onMayClose(); @PreDestroy void destroy(); void onLockStatusChange(@Observes UpdatedLockStatusEvent updatedLockStatusEvent); } | FormEditorPresenter extends KieEditor<FormModelerContent> { @Override protected void save(String commitMessage) { synchronizeFormLayout(); editorService.call(getSaveSuccessCallback(editorHelper.getContent().getDefinition().hashCode())) .save(versionRecordManager.getCurrentPath(), editorHelper.getContent(), metadata, commitMessage); } @Inject FormEditorPresenter(FormEditorView view,
ChangesNotificationDisplayer changesNotificationDisplayer,
FormDefinitionResourceType resourceType,
Caller<FormEditorService> editorService,
TranslationService translationService,
ManagedInstance<EditorFieldLayoutComponent> editorFieldLayoutComponents,
ShowAssetUsagesDisplayer showAssetUsagesDisplayer,
ErrorMessageDisplayer errorMessageDisplayer,
LayoutEditorPropertiesPresenter layoutEditorPropertiesPresenter); @OnStartup void onStartup(final ObservablePath path,
final PlaceRequest place); @OnFocus void onFocus(); @Override void hideDocks(); void doLoadContent(final FormModelerContent content); @Override @WorkbenchPartTitle String getTitleText(); @WorkbenchMenu void getMenus(final Consumer<Menus> menusConsumer); @Override @WorkbenchPartView IsWidget getWidget(); void copy(boolean save); void rename(boolean save); LayoutTemplate getFormTemplate(); FormDefinition getFormDefinition(); void onRemoveComponent(@Observes ComponentRemovedEvent event); void onLayoutEditorElementSelectEvent(@Observes LayoutEditorElementSelectEvent event); void onSyncPalette(@Observes FormEditorSyncPaletteEvent event); void onSyncPalette(String formId); void safeDelete(); @OnMayClose Boolean onMayClose(); @PreDestroy void destroy(); void onLockStatusChange(@Observes UpdatedLockStatusEvent updatedLockStatusEvent); static final String ID; } |
@Test public void testGetTitleText() { loadContent(); presenter.getTitleText(); verify(translationService).format(anyString(), any()); } | @Override @WorkbenchPartTitle public String getTitleText() { String fileName = FileNameUtil.removeExtension(versionRecordManager.getCurrentPath(), resourceType); return translationService.format(FormEditorConstants.FormEditorPresenterTitle, fileName); } | FormEditorPresenter extends KieEditor<FormModelerContent> { @Override @WorkbenchPartTitle public String getTitleText() { String fileName = FileNameUtil.removeExtension(versionRecordManager.getCurrentPath(), resourceType); return translationService.format(FormEditorConstants.FormEditorPresenterTitle, fileName); } } | FormEditorPresenter extends KieEditor<FormModelerContent> { @Override @WorkbenchPartTitle public String getTitleText() { String fileName = FileNameUtil.removeExtension(versionRecordManager.getCurrentPath(), resourceType); return translationService.format(FormEditorConstants.FormEditorPresenterTitle, fileName); } @Inject FormEditorPresenter(FormEditorView view,
ChangesNotificationDisplayer changesNotificationDisplayer,
FormDefinitionResourceType resourceType,
Caller<FormEditorService> editorService,
TranslationService translationService,
ManagedInstance<EditorFieldLayoutComponent> editorFieldLayoutComponents,
ShowAssetUsagesDisplayer showAssetUsagesDisplayer,
ErrorMessageDisplayer errorMessageDisplayer,
LayoutEditorPropertiesPresenter layoutEditorPropertiesPresenter); } | FormEditorPresenter extends KieEditor<FormModelerContent> { @Override @WorkbenchPartTitle public String getTitleText() { String fileName = FileNameUtil.removeExtension(versionRecordManager.getCurrentPath(), resourceType); return translationService.format(FormEditorConstants.FormEditorPresenterTitle, fileName); } @Inject FormEditorPresenter(FormEditorView view,
ChangesNotificationDisplayer changesNotificationDisplayer,
FormDefinitionResourceType resourceType,
Caller<FormEditorService> editorService,
TranslationService translationService,
ManagedInstance<EditorFieldLayoutComponent> editorFieldLayoutComponents,
ShowAssetUsagesDisplayer showAssetUsagesDisplayer,
ErrorMessageDisplayer errorMessageDisplayer,
LayoutEditorPropertiesPresenter layoutEditorPropertiesPresenter); @OnStartup void onStartup(final ObservablePath path,
final PlaceRequest place); @OnFocus void onFocus(); @Override void hideDocks(); void doLoadContent(final FormModelerContent content); @Override @WorkbenchPartTitle String getTitleText(); @WorkbenchMenu void getMenus(final Consumer<Menus> menusConsumer); @Override @WorkbenchPartView IsWidget getWidget(); void copy(boolean save); void rename(boolean save); LayoutTemplate getFormTemplate(); FormDefinition getFormDefinition(); void onRemoveComponent(@Observes ComponentRemovedEvent event); void onLayoutEditorElementSelectEvent(@Observes LayoutEditorElementSelectEvent event); void onSyncPalette(@Observes FormEditorSyncPaletteEvent event); void onSyncPalette(String formId); void safeDelete(); @OnMayClose Boolean onMayClose(); @PreDestroy void destroy(); void onLockStatusChange(@Observes UpdatedLockStatusEvent updatedLockStatusEvent); } | FormEditorPresenter extends KieEditor<FormModelerContent> { @Override @WorkbenchPartTitle public String getTitleText() { String fileName = FileNameUtil.removeExtension(versionRecordManager.getCurrentPath(), resourceType); return translationService.format(FormEditorConstants.FormEditorPresenterTitle, fileName); } @Inject FormEditorPresenter(FormEditorView view,
ChangesNotificationDisplayer changesNotificationDisplayer,
FormDefinitionResourceType resourceType,
Caller<FormEditorService> editorService,
TranslationService translationService,
ManagedInstance<EditorFieldLayoutComponent> editorFieldLayoutComponents,
ShowAssetUsagesDisplayer showAssetUsagesDisplayer,
ErrorMessageDisplayer errorMessageDisplayer,
LayoutEditorPropertiesPresenter layoutEditorPropertiesPresenter); @OnStartup void onStartup(final ObservablePath path,
final PlaceRequest place); @OnFocus void onFocus(); @Override void hideDocks(); void doLoadContent(final FormModelerContent content); @Override @WorkbenchPartTitle String getTitleText(); @WorkbenchMenu void getMenus(final Consumer<Menus> menusConsumer); @Override @WorkbenchPartView IsWidget getWidget(); void copy(boolean save); void rename(boolean save); LayoutTemplate getFormTemplate(); FormDefinition getFormDefinition(); void onRemoveComponent(@Observes ComponentRemovedEvent event); void onLayoutEditorElementSelectEvent(@Observes LayoutEditorElementSelectEvent event); void onSyncPalette(@Observes FormEditorSyncPaletteEvent event); void onSyncPalette(String formId); void safeDelete(); @OnMayClose Boolean onMayClose(); @PreDestroy void destroy(); void onLockStatusChange(@Observes UpdatedLockStatusEvent updatedLockStatusEvent); static final String ID; } |
@Test public void testMakeMenuBar() { doReturn(Optional.of(mock(WorkspaceProject.class))).when(workbenchContext).getActiveWorkspaceProject(); doReturn(promises.resolve(true)).when(projectController).canUpdateProject(any()); loadContent(); verify(menuBuilderMock).addSave(any(MenuItem.class)); verify(menuBuilderMock).addCopy(any(Command.class)); verify(menuBuilderMock).addRename(any(Command.class)); verify(menuBuilderMock).addDelete(any(Command.class)); verify(menuBuilderMock).addNewTopLevelMenu(alertsButtonMenuItem); verify(menuBuilderMock).addNewTopLevelMenu(downloadMenuItem); presenter.getMenus(Assert::assertNotNull); verify(menuBuilderMock, atLeastOnce()).build(); } | @Override protected Promise<Void> makeMenuBar() { if (workbenchContext.getActiveWorkspaceProject().isPresent()) { final WorkspaceProject activeProject = workbenchContext.getActiveWorkspaceProject().get(); return projectController.canUpdateProject(activeProject).then(canUpdateProject -> { if (canUpdateProject) { final ParameterizedCommand<Boolean> onSave = withComments -> { saveWithComments = withComments; saveAction(); }; fileMenuBuilder .addSave(versionRecordManager.newSaveMenuItem(onSave)) .addCopy(this::safeCopy) .addRename(this::safeRename) .addDelete(this::safeDelete); } addDownloadMenuItem(fileMenuBuilder); fileMenuBuilder .addNewTopLevelMenu(versionRecordManager.buildMenu()) .addNewTopLevelMenu(alertsButtonMenuItemBuilder.build()); return promises.resolve(); }); } return promises.resolve(); } | FormEditorPresenter extends KieEditor<FormModelerContent> { @Override protected Promise<Void> makeMenuBar() { if (workbenchContext.getActiveWorkspaceProject().isPresent()) { final WorkspaceProject activeProject = workbenchContext.getActiveWorkspaceProject().get(); return projectController.canUpdateProject(activeProject).then(canUpdateProject -> { if (canUpdateProject) { final ParameterizedCommand<Boolean> onSave = withComments -> { saveWithComments = withComments; saveAction(); }; fileMenuBuilder .addSave(versionRecordManager.newSaveMenuItem(onSave)) .addCopy(this::safeCopy) .addRename(this::safeRename) .addDelete(this::safeDelete); } addDownloadMenuItem(fileMenuBuilder); fileMenuBuilder .addNewTopLevelMenu(versionRecordManager.buildMenu()) .addNewTopLevelMenu(alertsButtonMenuItemBuilder.build()); return promises.resolve(); }); } return promises.resolve(); } } | FormEditorPresenter extends KieEditor<FormModelerContent> { @Override protected Promise<Void> makeMenuBar() { if (workbenchContext.getActiveWorkspaceProject().isPresent()) { final WorkspaceProject activeProject = workbenchContext.getActiveWorkspaceProject().get(); return projectController.canUpdateProject(activeProject).then(canUpdateProject -> { if (canUpdateProject) { final ParameterizedCommand<Boolean> onSave = withComments -> { saveWithComments = withComments; saveAction(); }; fileMenuBuilder .addSave(versionRecordManager.newSaveMenuItem(onSave)) .addCopy(this::safeCopy) .addRename(this::safeRename) .addDelete(this::safeDelete); } addDownloadMenuItem(fileMenuBuilder); fileMenuBuilder .addNewTopLevelMenu(versionRecordManager.buildMenu()) .addNewTopLevelMenu(alertsButtonMenuItemBuilder.build()); return promises.resolve(); }); } return promises.resolve(); } @Inject FormEditorPresenter(FormEditorView view,
ChangesNotificationDisplayer changesNotificationDisplayer,
FormDefinitionResourceType resourceType,
Caller<FormEditorService> editorService,
TranslationService translationService,
ManagedInstance<EditorFieldLayoutComponent> editorFieldLayoutComponents,
ShowAssetUsagesDisplayer showAssetUsagesDisplayer,
ErrorMessageDisplayer errorMessageDisplayer,
LayoutEditorPropertiesPresenter layoutEditorPropertiesPresenter); } | FormEditorPresenter extends KieEditor<FormModelerContent> { @Override protected Promise<Void> makeMenuBar() { if (workbenchContext.getActiveWorkspaceProject().isPresent()) { final WorkspaceProject activeProject = workbenchContext.getActiveWorkspaceProject().get(); return projectController.canUpdateProject(activeProject).then(canUpdateProject -> { if (canUpdateProject) { final ParameterizedCommand<Boolean> onSave = withComments -> { saveWithComments = withComments; saveAction(); }; fileMenuBuilder .addSave(versionRecordManager.newSaveMenuItem(onSave)) .addCopy(this::safeCopy) .addRename(this::safeRename) .addDelete(this::safeDelete); } addDownloadMenuItem(fileMenuBuilder); fileMenuBuilder .addNewTopLevelMenu(versionRecordManager.buildMenu()) .addNewTopLevelMenu(alertsButtonMenuItemBuilder.build()); return promises.resolve(); }); } return promises.resolve(); } @Inject FormEditorPresenter(FormEditorView view,
ChangesNotificationDisplayer changesNotificationDisplayer,
FormDefinitionResourceType resourceType,
Caller<FormEditorService> editorService,
TranslationService translationService,
ManagedInstance<EditorFieldLayoutComponent> editorFieldLayoutComponents,
ShowAssetUsagesDisplayer showAssetUsagesDisplayer,
ErrorMessageDisplayer errorMessageDisplayer,
LayoutEditorPropertiesPresenter layoutEditorPropertiesPresenter); @OnStartup void onStartup(final ObservablePath path,
final PlaceRequest place); @OnFocus void onFocus(); @Override void hideDocks(); void doLoadContent(final FormModelerContent content); @Override @WorkbenchPartTitle String getTitleText(); @WorkbenchMenu void getMenus(final Consumer<Menus> menusConsumer); @Override @WorkbenchPartView IsWidget getWidget(); void copy(boolean save); void rename(boolean save); LayoutTemplate getFormTemplate(); FormDefinition getFormDefinition(); void onRemoveComponent(@Observes ComponentRemovedEvent event); void onLayoutEditorElementSelectEvent(@Observes LayoutEditorElementSelectEvent event); void onSyncPalette(@Observes FormEditorSyncPaletteEvent event); void onSyncPalette(String formId); void safeDelete(); @OnMayClose Boolean onMayClose(); @PreDestroy void destroy(); void onLockStatusChange(@Observes UpdatedLockStatusEvent updatedLockStatusEvent); } | FormEditorPresenter extends KieEditor<FormModelerContent> { @Override protected Promise<Void> makeMenuBar() { if (workbenchContext.getActiveWorkspaceProject().isPresent()) { final WorkspaceProject activeProject = workbenchContext.getActiveWorkspaceProject().get(); return projectController.canUpdateProject(activeProject).then(canUpdateProject -> { if (canUpdateProject) { final ParameterizedCommand<Boolean> onSave = withComments -> { saveWithComments = withComments; saveAction(); }; fileMenuBuilder .addSave(versionRecordManager.newSaveMenuItem(onSave)) .addCopy(this::safeCopy) .addRename(this::safeRename) .addDelete(this::safeDelete); } addDownloadMenuItem(fileMenuBuilder); fileMenuBuilder .addNewTopLevelMenu(versionRecordManager.buildMenu()) .addNewTopLevelMenu(alertsButtonMenuItemBuilder.build()); return promises.resolve(); }); } return promises.resolve(); } @Inject FormEditorPresenter(FormEditorView view,
ChangesNotificationDisplayer changesNotificationDisplayer,
FormDefinitionResourceType resourceType,
Caller<FormEditorService> editorService,
TranslationService translationService,
ManagedInstance<EditorFieldLayoutComponent> editorFieldLayoutComponents,
ShowAssetUsagesDisplayer showAssetUsagesDisplayer,
ErrorMessageDisplayer errorMessageDisplayer,
LayoutEditorPropertiesPresenter layoutEditorPropertiesPresenter); @OnStartup void onStartup(final ObservablePath path,
final PlaceRequest place); @OnFocus void onFocus(); @Override void hideDocks(); void doLoadContent(final FormModelerContent content); @Override @WorkbenchPartTitle String getTitleText(); @WorkbenchMenu void getMenus(final Consumer<Menus> menusConsumer); @Override @WorkbenchPartView IsWidget getWidget(); void copy(boolean save); void rename(boolean save); LayoutTemplate getFormTemplate(); FormDefinition getFormDefinition(); void onRemoveComponent(@Observes ComponentRemovedEvent event); void onLayoutEditorElementSelectEvent(@Observes LayoutEditorElementSelectEvent event); void onSyncPalette(@Observes FormEditorSyncPaletteEvent event); void onSyncPalette(String formId); void safeDelete(); @OnMayClose Boolean onMayClose(); @PreDestroy void destroy(); void onLockStatusChange(@Observes UpdatedLockStatusEvent updatedLockStatusEvent); static final String ID; } |
@Test public void testSafeRenameDirtySaving() { FormEditorPresenter presenterSpy = triggerSafeRename(true, true); verify(view).showSavePopup(any(Path.class), any(Command.class), any(Command.class)); verify(presenterSpy).rename(eq(true)); } | public void rename(boolean save) { if (save) { synchronizeFormLayout(); } renamePopUpPresenter.show(versionRecordManager.getPathToLatest(), assetUpdateValidator, getRenameCommand(save)); } | FormEditorPresenter extends KieEditor<FormModelerContent> { public void rename(boolean save) { if (save) { synchronizeFormLayout(); } renamePopUpPresenter.show(versionRecordManager.getPathToLatest(), assetUpdateValidator, getRenameCommand(save)); } } | FormEditorPresenter extends KieEditor<FormModelerContent> { public void rename(boolean save) { if (save) { synchronizeFormLayout(); } renamePopUpPresenter.show(versionRecordManager.getPathToLatest(), assetUpdateValidator, getRenameCommand(save)); } @Inject FormEditorPresenter(FormEditorView view,
ChangesNotificationDisplayer changesNotificationDisplayer,
FormDefinitionResourceType resourceType,
Caller<FormEditorService> editorService,
TranslationService translationService,
ManagedInstance<EditorFieldLayoutComponent> editorFieldLayoutComponents,
ShowAssetUsagesDisplayer showAssetUsagesDisplayer,
ErrorMessageDisplayer errorMessageDisplayer,
LayoutEditorPropertiesPresenter layoutEditorPropertiesPresenter); } | FormEditorPresenter extends KieEditor<FormModelerContent> { public void rename(boolean save) { if (save) { synchronizeFormLayout(); } renamePopUpPresenter.show(versionRecordManager.getPathToLatest(), assetUpdateValidator, getRenameCommand(save)); } @Inject FormEditorPresenter(FormEditorView view,
ChangesNotificationDisplayer changesNotificationDisplayer,
FormDefinitionResourceType resourceType,
Caller<FormEditorService> editorService,
TranslationService translationService,
ManagedInstance<EditorFieldLayoutComponent> editorFieldLayoutComponents,
ShowAssetUsagesDisplayer showAssetUsagesDisplayer,
ErrorMessageDisplayer errorMessageDisplayer,
LayoutEditorPropertiesPresenter layoutEditorPropertiesPresenter); @OnStartup void onStartup(final ObservablePath path,
final PlaceRequest place); @OnFocus void onFocus(); @Override void hideDocks(); void doLoadContent(final FormModelerContent content); @Override @WorkbenchPartTitle String getTitleText(); @WorkbenchMenu void getMenus(final Consumer<Menus> menusConsumer); @Override @WorkbenchPartView IsWidget getWidget(); void copy(boolean save); void rename(boolean save); LayoutTemplate getFormTemplate(); FormDefinition getFormDefinition(); void onRemoveComponent(@Observes ComponentRemovedEvent event); void onLayoutEditorElementSelectEvent(@Observes LayoutEditorElementSelectEvent event); void onSyncPalette(@Observes FormEditorSyncPaletteEvent event); void onSyncPalette(String formId); void safeDelete(); @OnMayClose Boolean onMayClose(); @PreDestroy void destroy(); void onLockStatusChange(@Observes UpdatedLockStatusEvent updatedLockStatusEvent); } | FormEditorPresenter extends KieEditor<FormModelerContent> { public void rename(boolean save) { if (save) { synchronizeFormLayout(); } renamePopUpPresenter.show(versionRecordManager.getPathToLatest(), assetUpdateValidator, getRenameCommand(save)); } @Inject FormEditorPresenter(FormEditorView view,
ChangesNotificationDisplayer changesNotificationDisplayer,
FormDefinitionResourceType resourceType,
Caller<FormEditorService> editorService,
TranslationService translationService,
ManagedInstance<EditorFieldLayoutComponent> editorFieldLayoutComponents,
ShowAssetUsagesDisplayer showAssetUsagesDisplayer,
ErrorMessageDisplayer errorMessageDisplayer,
LayoutEditorPropertiesPresenter layoutEditorPropertiesPresenter); @OnStartup void onStartup(final ObservablePath path,
final PlaceRequest place); @OnFocus void onFocus(); @Override void hideDocks(); void doLoadContent(final FormModelerContent content); @Override @WorkbenchPartTitle String getTitleText(); @WorkbenchMenu void getMenus(final Consumer<Menus> menusConsumer); @Override @WorkbenchPartView IsWidget getWidget(); void copy(boolean save); void rename(boolean save); LayoutTemplate getFormTemplate(); FormDefinition getFormDefinition(); void onRemoveComponent(@Observes ComponentRemovedEvent event); void onLayoutEditorElementSelectEvent(@Observes LayoutEditorElementSelectEvent event); void onSyncPalette(@Observes FormEditorSyncPaletteEvent event); void onSyncPalette(String formId); void safeDelete(); @OnMayClose Boolean onMayClose(); @PreDestroy void destroy(); void onLockStatusChange(@Observes UpdatedLockStatusEvent updatedLockStatusEvent); static final String ID; } |
@Test public void testSafeRenameDirtyNotSaving() { FormEditorPresenter presenterSpy = triggerSafeRename(true, false); verify(view).showSavePopup(any(Path.class), any(Command.class), any(Command.class)); verify(presenterSpy).rename(eq(false)); } | public void rename(boolean save) { if (save) { synchronizeFormLayout(); } renamePopUpPresenter.show(versionRecordManager.getPathToLatest(), assetUpdateValidator, getRenameCommand(save)); } | FormEditorPresenter extends KieEditor<FormModelerContent> { public void rename(boolean save) { if (save) { synchronizeFormLayout(); } renamePopUpPresenter.show(versionRecordManager.getPathToLatest(), assetUpdateValidator, getRenameCommand(save)); } } | FormEditorPresenter extends KieEditor<FormModelerContent> { public void rename(boolean save) { if (save) { synchronizeFormLayout(); } renamePopUpPresenter.show(versionRecordManager.getPathToLatest(), assetUpdateValidator, getRenameCommand(save)); } @Inject FormEditorPresenter(FormEditorView view,
ChangesNotificationDisplayer changesNotificationDisplayer,
FormDefinitionResourceType resourceType,
Caller<FormEditorService> editorService,
TranslationService translationService,
ManagedInstance<EditorFieldLayoutComponent> editorFieldLayoutComponents,
ShowAssetUsagesDisplayer showAssetUsagesDisplayer,
ErrorMessageDisplayer errorMessageDisplayer,
LayoutEditorPropertiesPresenter layoutEditorPropertiesPresenter); } | FormEditorPresenter extends KieEditor<FormModelerContent> { public void rename(boolean save) { if (save) { synchronizeFormLayout(); } renamePopUpPresenter.show(versionRecordManager.getPathToLatest(), assetUpdateValidator, getRenameCommand(save)); } @Inject FormEditorPresenter(FormEditorView view,
ChangesNotificationDisplayer changesNotificationDisplayer,
FormDefinitionResourceType resourceType,
Caller<FormEditorService> editorService,
TranslationService translationService,
ManagedInstance<EditorFieldLayoutComponent> editorFieldLayoutComponents,
ShowAssetUsagesDisplayer showAssetUsagesDisplayer,
ErrorMessageDisplayer errorMessageDisplayer,
LayoutEditorPropertiesPresenter layoutEditorPropertiesPresenter); @OnStartup void onStartup(final ObservablePath path,
final PlaceRequest place); @OnFocus void onFocus(); @Override void hideDocks(); void doLoadContent(final FormModelerContent content); @Override @WorkbenchPartTitle String getTitleText(); @WorkbenchMenu void getMenus(final Consumer<Menus> menusConsumer); @Override @WorkbenchPartView IsWidget getWidget(); void copy(boolean save); void rename(boolean save); LayoutTemplate getFormTemplate(); FormDefinition getFormDefinition(); void onRemoveComponent(@Observes ComponentRemovedEvent event); void onLayoutEditorElementSelectEvent(@Observes LayoutEditorElementSelectEvent event); void onSyncPalette(@Observes FormEditorSyncPaletteEvent event); void onSyncPalette(String formId); void safeDelete(); @OnMayClose Boolean onMayClose(); @PreDestroy void destroy(); void onLockStatusChange(@Observes UpdatedLockStatusEvent updatedLockStatusEvent); } | FormEditorPresenter extends KieEditor<FormModelerContent> { public void rename(boolean save) { if (save) { synchronizeFormLayout(); } renamePopUpPresenter.show(versionRecordManager.getPathToLatest(), assetUpdateValidator, getRenameCommand(save)); } @Inject FormEditorPresenter(FormEditorView view,
ChangesNotificationDisplayer changesNotificationDisplayer,
FormDefinitionResourceType resourceType,
Caller<FormEditorService> editorService,
TranslationService translationService,
ManagedInstance<EditorFieldLayoutComponent> editorFieldLayoutComponents,
ShowAssetUsagesDisplayer showAssetUsagesDisplayer,
ErrorMessageDisplayer errorMessageDisplayer,
LayoutEditorPropertiesPresenter layoutEditorPropertiesPresenter); @OnStartup void onStartup(final ObservablePath path,
final PlaceRequest place); @OnFocus void onFocus(); @Override void hideDocks(); void doLoadContent(final FormModelerContent content); @Override @WorkbenchPartTitle String getTitleText(); @WorkbenchMenu void getMenus(final Consumer<Menus> menusConsumer); @Override @WorkbenchPartView IsWidget getWidget(); void copy(boolean save); void rename(boolean save); LayoutTemplate getFormTemplate(); FormDefinition getFormDefinition(); void onRemoveComponent(@Observes ComponentRemovedEvent event); void onLayoutEditorElementSelectEvent(@Observes LayoutEditorElementSelectEvent event); void onSyncPalette(@Observes FormEditorSyncPaletteEvent event); void onSyncPalette(String formId); void safeDelete(); @OnMayClose Boolean onMayClose(); @PreDestroy void destroy(); void onLockStatusChange(@Observes UpdatedLockStatusEvent updatedLockStatusEvent); static final String ID; } |
@Test public void testSafeRenameNotDirty() { FormEditorPresenter presenterSpy = triggerSafeRename(false, false); verify(view, never()).showSavePopup(any(Path.class), any(Command.class), any(Command.class)); verify(presenterSpy).rename(eq(false)); } | public void rename(boolean save) { if (save) { synchronizeFormLayout(); } renamePopUpPresenter.show(versionRecordManager.getPathToLatest(), assetUpdateValidator, getRenameCommand(save)); } | FormEditorPresenter extends KieEditor<FormModelerContent> { public void rename(boolean save) { if (save) { synchronizeFormLayout(); } renamePopUpPresenter.show(versionRecordManager.getPathToLatest(), assetUpdateValidator, getRenameCommand(save)); } } | FormEditorPresenter extends KieEditor<FormModelerContent> { public void rename(boolean save) { if (save) { synchronizeFormLayout(); } renamePopUpPresenter.show(versionRecordManager.getPathToLatest(), assetUpdateValidator, getRenameCommand(save)); } @Inject FormEditorPresenter(FormEditorView view,
ChangesNotificationDisplayer changesNotificationDisplayer,
FormDefinitionResourceType resourceType,
Caller<FormEditorService> editorService,
TranslationService translationService,
ManagedInstance<EditorFieldLayoutComponent> editorFieldLayoutComponents,
ShowAssetUsagesDisplayer showAssetUsagesDisplayer,
ErrorMessageDisplayer errorMessageDisplayer,
LayoutEditorPropertiesPresenter layoutEditorPropertiesPresenter); } | FormEditorPresenter extends KieEditor<FormModelerContent> { public void rename(boolean save) { if (save) { synchronizeFormLayout(); } renamePopUpPresenter.show(versionRecordManager.getPathToLatest(), assetUpdateValidator, getRenameCommand(save)); } @Inject FormEditorPresenter(FormEditorView view,
ChangesNotificationDisplayer changesNotificationDisplayer,
FormDefinitionResourceType resourceType,
Caller<FormEditorService> editorService,
TranslationService translationService,
ManagedInstance<EditorFieldLayoutComponent> editorFieldLayoutComponents,
ShowAssetUsagesDisplayer showAssetUsagesDisplayer,
ErrorMessageDisplayer errorMessageDisplayer,
LayoutEditorPropertiesPresenter layoutEditorPropertiesPresenter); @OnStartup void onStartup(final ObservablePath path,
final PlaceRequest place); @OnFocus void onFocus(); @Override void hideDocks(); void doLoadContent(final FormModelerContent content); @Override @WorkbenchPartTitle String getTitleText(); @WorkbenchMenu void getMenus(final Consumer<Menus> menusConsumer); @Override @WorkbenchPartView IsWidget getWidget(); void copy(boolean save); void rename(boolean save); LayoutTemplate getFormTemplate(); FormDefinition getFormDefinition(); void onRemoveComponent(@Observes ComponentRemovedEvent event); void onLayoutEditorElementSelectEvent(@Observes LayoutEditorElementSelectEvent event); void onSyncPalette(@Observes FormEditorSyncPaletteEvent event); void onSyncPalette(String formId); void safeDelete(); @OnMayClose Boolean onMayClose(); @PreDestroy void destroy(); void onLockStatusChange(@Observes UpdatedLockStatusEvent updatedLockStatusEvent); } | FormEditorPresenter extends KieEditor<FormModelerContent> { public void rename(boolean save) { if (save) { synchronizeFormLayout(); } renamePopUpPresenter.show(versionRecordManager.getPathToLatest(), assetUpdateValidator, getRenameCommand(save)); } @Inject FormEditorPresenter(FormEditorView view,
ChangesNotificationDisplayer changesNotificationDisplayer,
FormDefinitionResourceType resourceType,
Caller<FormEditorService> editorService,
TranslationService translationService,
ManagedInstance<EditorFieldLayoutComponent> editorFieldLayoutComponents,
ShowAssetUsagesDisplayer showAssetUsagesDisplayer,
ErrorMessageDisplayer errorMessageDisplayer,
LayoutEditorPropertiesPresenter layoutEditorPropertiesPresenter); @OnStartup void onStartup(final ObservablePath path,
final PlaceRequest place); @OnFocus void onFocus(); @Override void hideDocks(); void doLoadContent(final FormModelerContent content); @Override @WorkbenchPartTitle String getTitleText(); @WorkbenchMenu void getMenus(final Consumer<Menus> menusConsumer); @Override @WorkbenchPartView IsWidget getWidget(); void copy(boolean save); void rename(boolean save); LayoutTemplate getFormTemplate(); FormDefinition getFormDefinition(); void onRemoveComponent(@Observes ComponentRemovedEvent event); void onLayoutEditorElementSelectEvent(@Observes LayoutEditorElementSelectEvent event); void onSyncPalette(@Observes FormEditorSyncPaletteEvent event); void onSyncPalette(String formId); void safeDelete(); @OnMayClose Boolean onMayClose(); @PreDestroy void destroy(); void onLockStatusChange(@Observes UpdatedLockStatusEvent updatedLockStatusEvent); static final String ID; } |
@Test public void testSafeCopyDirtySaving() { FormEditorPresenter presenterSpy = triggerSafeCopy(true, true); verify(view).showSavePopup(any(Path.class), any(Command.class), any(Command.class)); verify(presenterSpy).copy(eq(true)); } | public void copy(boolean save) { if (save) { synchronizeFormLayout(); } copyPopUpPresenter.show(versionRecordManager.getPathToLatest(), assetUpdateValidator, getCopyCommand(save)); } | FormEditorPresenter extends KieEditor<FormModelerContent> { public void copy(boolean save) { if (save) { synchronizeFormLayout(); } copyPopUpPresenter.show(versionRecordManager.getPathToLatest(), assetUpdateValidator, getCopyCommand(save)); } } | FormEditorPresenter extends KieEditor<FormModelerContent> { public void copy(boolean save) { if (save) { synchronizeFormLayout(); } copyPopUpPresenter.show(versionRecordManager.getPathToLatest(), assetUpdateValidator, getCopyCommand(save)); } @Inject FormEditorPresenter(FormEditorView view,
ChangesNotificationDisplayer changesNotificationDisplayer,
FormDefinitionResourceType resourceType,
Caller<FormEditorService> editorService,
TranslationService translationService,
ManagedInstance<EditorFieldLayoutComponent> editorFieldLayoutComponents,
ShowAssetUsagesDisplayer showAssetUsagesDisplayer,
ErrorMessageDisplayer errorMessageDisplayer,
LayoutEditorPropertiesPresenter layoutEditorPropertiesPresenter); } | FormEditorPresenter extends KieEditor<FormModelerContent> { public void copy(boolean save) { if (save) { synchronizeFormLayout(); } copyPopUpPresenter.show(versionRecordManager.getPathToLatest(), assetUpdateValidator, getCopyCommand(save)); } @Inject FormEditorPresenter(FormEditorView view,
ChangesNotificationDisplayer changesNotificationDisplayer,
FormDefinitionResourceType resourceType,
Caller<FormEditorService> editorService,
TranslationService translationService,
ManagedInstance<EditorFieldLayoutComponent> editorFieldLayoutComponents,
ShowAssetUsagesDisplayer showAssetUsagesDisplayer,
ErrorMessageDisplayer errorMessageDisplayer,
LayoutEditorPropertiesPresenter layoutEditorPropertiesPresenter); @OnStartup void onStartup(final ObservablePath path,
final PlaceRequest place); @OnFocus void onFocus(); @Override void hideDocks(); void doLoadContent(final FormModelerContent content); @Override @WorkbenchPartTitle String getTitleText(); @WorkbenchMenu void getMenus(final Consumer<Menus> menusConsumer); @Override @WorkbenchPartView IsWidget getWidget(); void copy(boolean save); void rename(boolean save); LayoutTemplate getFormTemplate(); FormDefinition getFormDefinition(); void onRemoveComponent(@Observes ComponentRemovedEvent event); void onLayoutEditorElementSelectEvent(@Observes LayoutEditorElementSelectEvent event); void onSyncPalette(@Observes FormEditorSyncPaletteEvent event); void onSyncPalette(String formId); void safeDelete(); @OnMayClose Boolean onMayClose(); @PreDestroy void destroy(); void onLockStatusChange(@Observes UpdatedLockStatusEvent updatedLockStatusEvent); } | FormEditorPresenter extends KieEditor<FormModelerContent> { public void copy(boolean save) { if (save) { synchronizeFormLayout(); } copyPopUpPresenter.show(versionRecordManager.getPathToLatest(), assetUpdateValidator, getCopyCommand(save)); } @Inject FormEditorPresenter(FormEditorView view,
ChangesNotificationDisplayer changesNotificationDisplayer,
FormDefinitionResourceType resourceType,
Caller<FormEditorService> editorService,
TranslationService translationService,
ManagedInstance<EditorFieldLayoutComponent> editorFieldLayoutComponents,
ShowAssetUsagesDisplayer showAssetUsagesDisplayer,
ErrorMessageDisplayer errorMessageDisplayer,
LayoutEditorPropertiesPresenter layoutEditorPropertiesPresenter); @OnStartup void onStartup(final ObservablePath path,
final PlaceRequest place); @OnFocus void onFocus(); @Override void hideDocks(); void doLoadContent(final FormModelerContent content); @Override @WorkbenchPartTitle String getTitleText(); @WorkbenchMenu void getMenus(final Consumer<Menus> menusConsumer); @Override @WorkbenchPartView IsWidget getWidget(); void copy(boolean save); void rename(boolean save); LayoutTemplate getFormTemplate(); FormDefinition getFormDefinition(); void onRemoveComponent(@Observes ComponentRemovedEvent event); void onLayoutEditorElementSelectEvent(@Observes LayoutEditorElementSelectEvent event); void onSyncPalette(@Observes FormEditorSyncPaletteEvent event); void onSyncPalette(String formId); void safeDelete(); @OnMayClose Boolean onMayClose(); @PreDestroy void destroy(); void onLockStatusChange(@Observes UpdatedLockStatusEvent updatedLockStatusEvent); static final String ID; } |
@Test public void testSetDividerLineY() { view.setDividerLineY(50.0); assertThat(getMoveDividerControlHandle().getControl().getY()).isEqualTo(50.0); } | public void setDividerLineY(final double y) { divider.setY(y); decisionServiceControlHandleFactory .getMoveDividerControlHandle() .ifPresent(handle -> handle.getControl().setY(y)); } | DecisionServiceSVGShapeView extends SVGShapeViewImpl { public void setDividerLineY(final double y) { divider.setY(y); decisionServiceControlHandleFactory .getMoveDividerControlHandle() .ifPresent(handle -> handle.getControl().setY(y)); } } | DecisionServiceSVGShapeView extends SVGShapeViewImpl { public void setDividerLineY(final double y) { divider.setY(y); decisionServiceControlHandleFactory .getMoveDividerControlHandle() .ifPresent(handle -> handle.getControl().setY(y)); } DecisionServiceSVGShapeView(final String name,
final SVGPrimitiveShape svgPrimitive,
final double width,
final double height,
final boolean resizable); } | DecisionServiceSVGShapeView extends SVGShapeViewImpl { public void setDividerLineY(final double y) { divider.setY(y); decisionServiceControlHandleFactory .getMoveDividerControlHandle() .ifPresent(handle -> handle.getControl().setY(y)); } DecisionServiceSVGShapeView(final String name,
final SVGPrimitiveShape svgPrimitive,
final double width,
final double height,
final boolean resizable); DecisionServiceSVGShapeView addDividerDragHandler(final DragHandler dragHandler); double getDividerLineY(); void setDividerLineY(final double y); @Override //Override to increase visibility for Unit Tests HandlerManager getHandlerManager(); @Override void destroy(); } | DecisionServiceSVGShapeView extends SVGShapeViewImpl { public void setDividerLineY(final double y) { divider.setY(y); decisionServiceControlHandleFactory .getMoveDividerControlHandle() .ifPresent(handle -> handle.getControl().setY(y)); } DecisionServiceSVGShapeView(final String name,
final SVGPrimitiveShape svgPrimitive,
final double width,
final double height,
final boolean resizable); DecisionServiceSVGShapeView addDividerDragHandler(final DragHandler dragHandler); double getDividerLineY(); void setDividerLineY(final double y); @Override //Override to increase visibility for Unit Tests HandlerManager getHandlerManager(); @Override void destroy(); } |
@Test public void testLoadDataObjects_NoJavaFilesAvailable() { final List<DataObject> dataObjects = service.loadDataObjects(workspaceProject); assertThat(dataObjects).isEmpty(); } | @Override public List<DataObject> loadDataObjects(final WorkspaceProject workspaceProject) { final KieModule module = moduleService.resolveModule(workspaceProject.getRootPath()); final ClassLoader classLoader = moduleClassLoaderHelper.getModuleClassLoader(module); final ModuleDataModelOracle dmo = dataModelService.getModuleDataModel(workspaceProject.getRootPath()); final String[] types = DataModelOracleUtilities.getFactTypes(dmo); final Map<String, ModelField[]> typesModelFields = dmo.getModuleModelFields(); final Map<String, String> parametersType = dmo.getModuleFieldParametersType(); final List<DataObject> dataObjects = Arrays.stream(types).map(DataObject::new).collect(Collectors.toList()); dataObjects.forEach(dataObject -> convertProperties(dataObject, dataObjects, typesModelFields, classLoader, parametersType)); return dataObjects; } | DataObjectsServiceImpl implements DataObjectsService { @Override public List<DataObject> loadDataObjects(final WorkspaceProject workspaceProject) { final KieModule module = moduleService.resolveModule(workspaceProject.getRootPath()); final ClassLoader classLoader = moduleClassLoaderHelper.getModuleClassLoader(module); final ModuleDataModelOracle dmo = dataModelService.getModuleDataModel(workspaceProject.getRootPath()); final String[] types = DataModelOracleUtilities.getFactTypes(dmo); final Map<String, ModelField[]> typesModelFields = dmo.getModuleModelFields(); final Map<String, String> parametersType = dmo.getModuleFieldParametersType(); final List<DataObject> dataObjects = Arrays.stream(types).map(DataObject::new).collect(Collectors.toList()); dataObjects.forEach(dataObject -> convertProperties(dataObject, dataObjects, typesModelFields, classLoader, parametersType)); return dataObjects; } } | DataObjectsServiceImpl implements DataObjectsService { @Override public List<DataObject> loadDataObjects(final WorkspaceProject workspaceProject) { final KieModule module = moduleService.resolveModule(workspaceProject.getRootPath()); final ClassLoader classLoader = moduleClassLoaderHelper.getModuleClassLoader(module); final ModuleDataModelOracle dmo = dataModelService.getModuleDataModel(workspaceProject.getRootPath()); final String[] types = DataModelOracleUtilities.getFactTypes(dmo); final Map<String, ModelField[]> typesModelFields = dmo.getModuleModelFields(); final Map<String, String> parametersType = dmo.getModuleFieldParametersType(); final List<DataObject> dataObjects = Arrays.stream(types).map(DataObject::new).collect(Collectors.toList()); dataObjects.forEach(dataObject -> convertProperties(dataObject, dataObjects, typesModelFields, classLoader, parametersType)); return dataObjects; } protected DataObjectsServiceImpl(); @Inject DataObjectsServiceImpl(final DataModelService dataModelService,
final ModuleClassLoaderHelper moduleClassLoaderHelper,
final KieModuleService moduleService); } | DataObjectsServiceImpl implements DataObjectsService { @Override public List<DataObject> loadDataObjects(final WorkspaceProject workspaceProject) { final KieModule module = moduleService.resolveModule(workspaceProject.getRootPath()); final ClassLoader classLoader = moduleClassLoaderHelper.getModuleClassLoader(module); final ModuleDataModelOracle dmo = dataModelService.getModuleDataModel(workspaceProject.getRootPath()); final String[] types = DataModelOracleUtilities.getFactTypes(dmo); final Map<String, ModelField[]> typesModelFields = dmo.getModuleModelFields(); final Map<String, String> parametersType = dmo.getModuleFieldParametersType(); final List<DataObject> dataObjects = Arrays.stream(types).map(DataObject::new).collect(Collectors.toList()); dataObjects.forEach(dataObject -> convertProperties(dataObject, dataObjects, typesModelFields, classLoader, parametersType)); return dataObjects; } protected DataObjectsServiceImpl(); @Inject DataObjectsServiceImpl(final DataModelService dataModelService,
final ModuleClassLoaderHelper moduleClassLoaderHelper,
final KieModuleService moduleService); @Override List<DataObject> loadDataObjects(final WorkspaceProject workspaceProject); } | DataObjectsServiceImpl implements DataObjectsService { @Override public List<DataObject> loadDataObjects(final WorkspaceProject workspaceProject) { final KieModule module = moduleService.resolveModule(workspaceProject.getRootPath()); final ClassLoader classLoader = moduleClassLoaderHelper.getModuleClassLoader(module); final ModuleDataModelOracle dmo = dataModelService.getModuleDataModel(workspaceProject.getRootPath()); final String[] types = DataModelOracleUtilities.getFactTypes(dmo); final Map<String, ModelField[]> typesModelFields = dmo.getModuleModelFields(); final Map<String, String> parametersType = dmo.getModuleFieldParametersType(); final List<DataObject> dataObjects = Arrays.stream(types).map(DataObject::new).collect(Collectors.toList()); dataObjects.forEach(dataObject -> convertProperties(dataObject, dataObjects, typesModelFields, classLoader, parametersType)); return dataObjects; } protected DataObjectsServiceImpl(); @Inject DataObjectsServiceImpl(final DataModelService dataModelService,
final ModuleClassLoaderHelper moduleClassLoaderHelper,
final KieModuleService moduleService); @Override List<DataObject> loadDataObjects(final WorkspaceProject workspaceProject); } |
@Test public void testSafeCopyDirtyNotSaving() { FormEditorPresenter presenterSpy = triggerSafeCopy(true, false); verify(view).showSavePopup(any(Path.class), any(Command.class), any(Command.class)); verify(presenterSpy).copy(eq(false)); } | public void copy(boolean save) { if (save) { synchronizeFormLayout(); } copyPopUpPresenter.show(versionRecordManager.getPathToLatest(), assetUpdateValidator, getCopyCommand(save)); } | FormEditorPresenter extends KieEditor<FormModelerContent> { public void copy(boolean save) { if (save) { synchronizeFormLayout(); } copyPopUpPresenter.show(versionRecordManager.getPathToLatest(), assetUpdateValidator, getCopyCommand(save)); } } | FormEditorPresenter extends KieEditor<FormModelerContent> { public void copy(boolean save) { if (save) { synchronizeFormLayout(); } copyPopUpPresenter.show(versionRecordManager.getPathToLatest(), assetUpdateValidator, getCopyCommand(save)); } @Inject FormEditorPresenter(FormEditorView view,
ChangesNotificationDisplayer changesNotificationDisplayer,
FormDefinitionResourceType resourceType,
Caller<FormEditorService> editorService,
TranslationService translationService,
ManagedInstance<EditorFieldLayoutComponent> editorFieldLayoutComponents,
ShowAssetUsagesDisplayer showAssetUsagesDisplayer,
ErrorMessageDisplayer errorMessageDisplayer,
LayoutEditorPropertiesPresenter layoutEditorPropertiesPresenter); } | FormEditorPresenter extends KieEditor<FormModelerContent> { public void copy(boolean save) { if (save) { synchronizeFormLayout(); } copyPopUpPresenter.show(versionRecordManager.getPathToLatest(), assetUpdateValidator, getCopyCommand(save)); } @Inject FormEditorPresenter(FormEditorView view,
ChangesNotificationDisplayer changesNotificationDisplayer,
FormDefinitionResourceType resourceType,
Caller<FormEditorService> editorService,
TranslationService translationService,
ManagedInstance<EditorFieldLayoutComponent> editorFieldLayoutComponents,
ShowAssetUsagesDisplayer showAssetUsagesDisplayer,
ErrorMessageDisplayer errorMessageDisplayer,
LayoutEditorPropertiesPresenter layoutEditorPropertiesPresenter); @OnStartup void onStartup(final ObservablePath path,
final PlaceRequest place); @OnFocus void onFocus(); @Override void hideDocks(); void doLoadContent(final FormModelerContent content); @Override @WorkbenchPartTitle String getTitleText(); @WorkbenchMenu void getMenus(final Consumer<Menus> menusConsumer); @Override @WorkbenchPartView IsWidget getWidget(); void copy(boolean save); void rename(boolean save); LayoutTemplate getFormTemplate(); FormDefinition getFormDefinition(); void onRemoveComponent(@Observes ComponentRemovedEvent event); void onLayoutEditorElementSelectEvent(@Observes LayoutEditorElementSelectEvent event); void onSyncPalette(@Observes FormEditorSyncPaletteEvent event); void onSyncPalette(String formId); void safeDelete(); @OnMayClose Boolean onMayClose(); @PreDestroy void destroy(); void onLockStatusChange(@Observes UpdatedLockStatusEvent updatedLockStatusEvent); } | FormEditorPresenter extends KieEditor<FormModelerContent> { public void copy(boolean save) { if (save) { synchronizeFormLayout(); } copyPopUpPresenter.show(versionRecordManager.getPathToLatest(), assetUpdateValidator, getCopyCommand(save)); } @Inject FormEditorPresenter(FormEditorView view,
ChangesNotificationDisplayer changesNotificationDisplayer,
FormDefinitionResourceType resourceType,
Caller<FormEditorService> editorService,
TranslationService translationService,
ManagedInstance<EditorFieldLayoutComponent> editorFieldLayoutComponents,
ShowAssetUsagesDisplayer showAssetUsagesDisplayer,
ErrorMessageDisplayer errorMessageDisplayer,
LayoutEditorPropertiesPresenter layoutEditorPropertiesPresenter); @OnStartup void onStartup(final ObservablePath path,
final PlaceRequest place); @OnFocus void onFocus(); @Override void hideDocks(); void doLoadContent(final FormModelerContent content); @Override @WorkbenchPartTitle String getTitleText(); @WorkbenchMenu void getMenus(final Consumer<Menus> menusConsumer); @Override @WorkbenchPartView IsWidget getWidget(); void copy(boolean save); void rename(boolean save); LayoutTemplate getFormTemplate(); FormDefinition getFormDefinition(); void onRemoveComponent(@Observes ComponentRemovedEvent event); void onLayoutEditorElementSelectEvent(@Observes LayoutEditorElementSelectEvent event); void onSyncPalette(@Observes FormEditorSyncPaletteEvent event); void onSyncPalette(String formId); void safeDelete(); @OnMayClose Boolean onMayClose(); @PreDestroy void destroy(); void onLockStatusChange(@Observes UpdatedLockStatusEvent updatedLockStatusEvent); static final String ID; } |
@Test public void testSafeCopyNotDirty() { FormEditorPresenter presenterSpy = triggerSafeCopy(false, false); verify(view, never()).showSavePopup(any(Path.class), any(Command.class), any(Command.class)); verify(presenterSpy).copy(eq(false)); } | public void copy(boolean save) { if (save) { synchronizeFormLayout(); } copyPopUpPresenter.show(versionRecordManager.getPathToLatest(), assetUpdateValidator, getCopyCommand(save)); } | FormEditorPresenter extends KieEditor<FormModelerContent> { public void copy(boolean save) { if (save) { synchronizeFormLayout(); } copyPopUpPresenter.show(versionRecordManager.getPathToLatest(), assetUpdateValidator, getCopyCommand(save)); } } | FormEditorPresenter extends KieEditor<FormModelerContent> { public void copy(boolean save) { if (save) { synchronizeFormLayout(); } copyPopUpPresenter.show(versionRecordManager.getPathToLatest(), assetUpdateValidator, getCopyCommand(save)); } @Inject FormEditorPresenter(FormEditorView view,
ChangesNotificationDisplayer changesNotificationDisplayer,
FormDefinitionResourceType resourceType,
Caller<FormEditorService> editorService,
TranslationService translationService,
ManagedInstance<EditorFieldLayoutComponent> editorFieldLayoutComponents,
ShowAssetUsagesDisplayer showAssetUsagesDisplayer,
ErrorMessageDisplayer errorMessageDisplayer,
LayoutEditorPropertiesPresenter layoutEditorPropertiesPresenter); } | FormEditorPresenter extends KieEditor<FormModelerContent> { public void copy(boolean save) { if (save) { synchronizeFormLayout(); } copyPopUpPresenter.show(versionRecordManager.getPathToLatest(), assetUpdateValidator, getCopyCommand(save)); } @Inject FormEditorPresenter(FormEditorView view,
ChangesNotificationDisplayer changesNotificationDisplayer,
FormDefinitionResourceType resourceType,
Caller<FormEditorService> editorService,
TranslationService translationService,
ManagedInstance<EditorFieldLayoutComponent> editorFieldLayoutComponents,
ShowAssetUsagesDisplayer showAssetUsagesDisplayer,
ErrorMessageDisplayer errorMessageDisplayer,
LayoutEditorPropertiesPresenter layoutEditorPropertiesPresenter); @OnStartup void onStartup(final ObservablePath path,
final PlaceRequest place); @OnFocus void onFocus(); @Override void hideDocks(); void doLoadContent(final FormModelerContent content); @Override @WorkbenchPartTitle String getTitleText(); @WorkbenchMenu void getMenus(final Consumer<Menus> menusConsumer); @Override @WorkbenchPartView IsWidget getWidget(); void copy(boolean save); void rename(boolean save); LayoutTemplate getFormTemplate(); FormDefinition getFormDefinition(); void onRemoveComponent(@Observes ComponentRemovedEvent event); void onLayoutEditorElementSelectEvent(@Observes LayoutEditorElementSelectEvent event); void onSyncPalette(@Observes FormEditorSyncPaletteEvent event); void onSyncPalette(String formId); void safeDelete(); @OnMayClose Boolean onMayClose(); @PreDestroy void destroy(); void onLockStatusChange(@Observes UpdatedLockStatusEvent updatedLockStatusEvent); } | FormEditorPresenter extends KieEditor<FormModelerContent> { public void copy(boolean save) { if (save) { synchronizeFormLayout(); } copyPopUpPresenter.show(versionRecordManager.getPathToLatest(), assetUpdateValidator, getCopyCommand(save)); } @Inject FormEditorPresenter(FormEditorView view,
ChangesNotificationDisplayer changesNotificationDisplayer,
FormDefinitionResourceType resourceType,
Caller<FormEditorService> editorService,
TranslationService translationService,
ManagedInstance<EditorFieldLayoutComponent> editorFieldLayoutComponents,
ShowAssetUsagesDisplayer showAssetUsagesDisplayer,
ErrorMessageDisplayer errorMessageDisplayer,
LayoutEditorPropertiesPresenter layoutEditorPropertiesPresenter); @OnStartup void onStartup(final ObservablePath path,
final PlaceRequest place); @OnFocus void onFocus(); @Override void hideDocks(); void doLoadContent(final FormModelerContent content); @Override @WorkbenchPartTitle String getTitleText(); @WorkbenchMenu void getMenus(final Consumer<Menus> menusConsumer); @Override @WorkbenchPartView IsWidget getWidget(); void copy(boolean save); void rename(boolean save); LayoutTemplate getFormTemplate(); FormDefinition getFormDefinition(); void onRemoveComponent(@Observes ComponentRemovedEvent event); void onLayoutEditorElementSelectEvent(@Observes LayoutEditorElementSelectEvent event); void onSyncPalette(@Observes FormEditorSyncPaletteEvent event); void onSyncPalette(String formId); void safeDelete(); @OnMayClose Boolean onMayClose(); @PreDestroy void destroy(); void onLockStatusChange(@Observes UpdatedLockStatusEvent updatedLockStatusEvent); static final String ID; } |
@Test public void testRenameCommand() { loadContent(); FormEditorPresenter presenterSpy = spy(presenter); FileNameAndCommitMessage details = mock(FileNameAndCommitMessage.class); when(renamePopUpPresenter.getView()).thenReturn(mock(RenamePopUpPresenter.View.class)); doNothing().when(presenterSpy).doLoadContent(any(FormModelerContent.class)); presenterSpy.renameCommand(details, true); verify(view).showBusyIndicator(anyString()); verify(presenterSpy).getRenameErrorCallback(any(RenamePopUpPresenter.View.class)); verify(presenterSpy).getRenameSuccessCallback(any(RenamePopUpPresenter.View.class)); } | protected void renameCommand(FileNameAndCommitMessage details, boolean save) { view.showBusyIndicator(org.kie.workbench.common.widgets.client.resources.i18n.CommonConstants.INSTANCE.Renaming()); editorService.call(getRenameSuccessCallback(renamePopUpPresenter.getView()), getRenameErrorCallback(renamePopUpPresenter.getView())).rename(versionRecordManager.getPathToLatest(), details.getNewFileName(), details.getCommitMessage(), save, editorHelper.getContent(), metadata); } | FormEditorPresenter extends KieEditor<FormModelerContent> { protected void renameCommand(FileNameAndCommitMessage details, boolean save) { view.showBusyIndicator(org.kie.workbench.common.widgets.client.resources.i18n.CommonConstants.INSTANCE.Renaming()); editorService.call(getRenameSuccessCallback(renamePopUpPresenter.getView()), getRenameErrorCallback(renamePopUpPresenter.getView())).rename(versionRecordManager.getPathToLatest(), details.getNewFileName(), details.getCommitMessage(), save, editorHelper.getContent(), metadata); } } | FormEditorPresenter extends KieEditor<FormModelerContent> { protected void renameCommand(FileNameAndCommitMessage details, boolean save) { view.showBusyIndicator(org.kie.workbench.common.widgets.client.resources.i18n.CommonConstants.INSTANCE.Renaming()); editorService.call(getRenameSuccessCallback(renamePopUpPresenter.getView()), getRenameErrorCallback(renamePopUpPresenter.getView())).rename(versionRecordManager.getPathToLatest(), details.getNewFileName(), details.getCommitMessage(), save, editorHelper.getContent(), metadata); } @Inject FormEditorPresenter(FormEditorView view,
ChangesNotificationDisplayer changesNotificationDisplayer,
FormDefinitionResourceType resourceType,
Caller<FormEditorService> editorService,
TranslationService translationService,
ManagedInstance<EditorFieldLayoutComponent> editorFieldLayoutComponents,
ShowAssetUsagesDisplayer showAssetUsagesDisplayer,
ErrorMessageDisplayer errorMessageDisplayer,
LayoutEditorPropertiesPresenter layoutEditorPropertiesPresenter); } | FormEditorPresenter extends KieEditor<FormModelerContent> { protected void renameCommand(FileNameAndCommitMessage details, boolean save) { view.showBusyIndicator(org.kie.workbench.common.widgets.client.resources.i18n.CommonConstants.INSTANCE.Renaming()); editorService.call(getRenameSuccessCallback(renamePopUpPresenter.getView()), getRenameErrorCallback(renamePopUpPresenter.getView())).rename(versionRecordManager.getPathToLatest(), details.getNewFileName(), details.getCommitMessage(), save, editorHelper.getContent(), metadata); } @Inject FormEditorPresenter(FormEditorView view,
ChangesNotificationDisplayer changesNotificationDisplayer,
FormDefinitionResourceType resourceType,
Caller<FormEditorService> editorService,
TranslationService translationService,
ManagedInstance<EditorFieldLayoutComponent> editorFieldLayoutComponents,
ShowAssetUsagesDisplayer showAssetUsagesDisplayer,
ErrorMessageDisplayer errorMessageDisplayer,
LayoutEditorPropertiesPresenter layoutEditorPropertiesPresenter); @OnStartup void onStartup(final ObservablePath path,
final PlaceRequest place); @OnFocus void onFocus(); @Override void hideDocks(); void doLoadContent(final FormModelerContent content); @Override @WorkbenchPartTitle String getTitleText(); @WorkbenchMenu void getMenus(final Consumer<Menus> menusConsumer); @Override @WorkbenchPartView IsWidget getWidget(); void copy(boolean save); void rename(boolean save); LayoutTemplate getFormTemplate(); FormDefinition getFormDefinition(); void onRemoveComponent(@Observes ComponentRemovedEvent event); void onLayoutEditorElementSelectEvent(@Observes LayoutEditorElementSelectEvent event); void onSyncPalette(@Observes FormEditorSyncPaletteEvent event); void onSyncPalette(String formId); void safeDelete(); @OnMayClose Boolean onMayClose(); @PreDestroy void destroy(); void onLockStatusChange(@Observes UpdatedLockStatusEvent updatedLockStatusEvent); } | FormEditorPresenter extends KieEditor<FormModelerContent> { protected void renameCommand(FileNameAndCommitMessage details, boolean save) { view.showBusyIndicator(org.kie.workbench.common.widgets.client.resources.i18n.CommonConstants.INSTANCE.Renaming()); editorService.call(getRenameSuccessCallback(renamePopUpPresenter.getView()), getRenameErrorCallback(renamePopUpPresenter.getView())).rename(versionRecordManager.getPathToLatest(), details.getNewFileName(), details.getCommitMessage(), save, editorHelper.getContent(), metadata); } @Inject FormEditorPresenter(FormEditorView view,
ChangesNotificationDisplayer changesNotificationDisplayer,
FormDefinitionResourceType resourceType,
Caller<FormEditorService> editorService,
TranslationService translationService,
ManagedInstance<EditorFieldLayoutComponent> editorFieldLayoutComponents,
ShowAssetUsagesDisplayer showAssetUsagesDisplayer,
ErrorMessageDisplayer errorMessageDisplayer,
LayoutEditorPropertiesPresenter layoutEditorPropertiesPresenter); @OnStartup void onStartup(final ObservablePath path,
final PlaceRequest place); @OnFocus void onFocus(); @Override void hideDocks(); void doLoadContent(final FormModelerContent content); @Override @WorkbenchPartTitle String getTitleText(); @WorkbenchMenu void getMenus(final Consumer<Menus> menusConsumer); @Override @WorkbenchPartView IsWidget getWidget(); void copy(boolean save); void rename(boolean save); LayoutTemplate getFormTemplate(); FormDefinition getFormDefinition(); void onRemoveComponent(@Observes ComponentRemovedEvent event); void onLayoutEditorElementSelectEvent(@Observes LayoutEditorElementSelectEvent event); void onSyncPalette(@Observes FormEditorSyncPaletteEvent event); void onSyncPalette(String formId); void safeDelete(); @OnMayClose Boolean onMayClose(); @PreDestroy void destroy(); void onLockStatusChange(@Observes UpdatedLockStatusEvent updatedLockStatusEvent); static final String ID; } |
@Test public void testOnLockStatusChange() { loadContent(); FormEditorPresenter presenterSpy = spy(presenter); UpdatedLockStatusEvent updatedLockStatusEvent = new UpdatedLockStatusEvent(versionRecordManager.getCurrentPath(), true,false); presenterSpy.onLockStatusChange(updatedLockStatusEvent); verify(layoutEditorMock).lock(); updatedLockStatusEvent = new UpdatedLockStatusEvent(versionRecordManager.getCurrentPath(), false, false); presenterSpy.onLockStatusChange(updatedLockStatusEvent); verify(layoutEditorMock).unlock(); } | public void onLockStatusChange(@Observes UpdatedLockStatusEvent updatedLockStatusEvent) { if (updatedLockStatusEvent.getFile().equals(versionRecordManager.getCurrentPath())) { if (updatedLockStatusEvent.isLocked() && !updatedLockStatusEvent.isLockedByCurrentUser()) { layoutEditor.lock(); } else { layoutEditor.unlock(); } } } | FormEditorPresenter extends KieEditor<FormModelerContent> { public void onLockStatusChange(@Observes UpdatedLockStatusEvent updatedLockStatusEvent) { if (updatedLockStatusEvent.getFile().equals(versionRecordManager.getCurrentPath())) { if (updatedLockStatusEvent.isLocked() && !updatedLockStatusEvent.isLockedByCurrentUser()) { layoutEditor.lock(); } else { layoutEditor.unlock(); } } } } | FormEditorPresenter extends KieEditor<FormModelerContent> { public void onLockStatusChange(@Observes UpdatedLockStatusEvent updatedLockStatusEvent) { if (updatedLockStatusEvent.getFile().equals(versionRecordManager.getCurrentPath())) { if (updatedLockStatusEvent.isLocked() && !updatedLockStatusEvent.isLockedByCurrentUser()) { layoutEditor.lock(); } else { layoutEditor.unlock(); } } } @Inject FormEditorPresenter(FormEditorView view,
ChangesNotificationDisplayer changesNotificationDisplayer,
FormDefinitionResourceType resourceType,
Caller<FormEditorService> editorService,
TranslationService translationService,
ManagedInstance<EditorFieldLayoutComponent> editorFieldLayoutComponents,
ShowAssetUsagesDisplayer showAssetUsagesDisplayer,
ErrorMessageDisplayer errorMessageDisplayer,
LayoutEditorPropertiesPresenter layoutEditorPropertiesPresenter); } | FormEditorPresenter extends KieEditor<FormModelerContent> { public void onLockStatusChange(@Observes UpdatedLockStatusEvent updatedLockStatusEvent) { if (updatedLockStatusEvent.getFile().equals(versionRecordManager.getCurrentPath())) { if (updatedLockStatusEvent.isLocked() && !updatedLockStatusEvent.isLockedByCurrentUser()) { layoutEditor.lock(); } else { layoutEditor.unlock(); } } } @Inject FormEditorPresenter(FormEditorView view,
ChangesNotificationDisplayer changesNotificationDisplayer,
FormDefinitionResourceType resourceType,
Caller<FormEditorService> editorService,
TranslationService translationService,
ManagedInstance<EditorFieldLayoutComponent> editorFieldLayoutComponents,
ShowAssetUsagesDisplayer showAssetUsagesDisplayer,
ErrorMessageDisplayer errorMessageDisplayer,
LayoutEditorPropertiesPresenter layoutEditorPropertiesPresenter); @OnStartup void onStartup(final ObservablePath path,
final PlaceRequest place); @OnFocus void onFocus(); @Override void hideDocks(); void doLoadContent(final FormModelerContent content); @Override @WorkbenchPartTitle String getTitleText(); @WorkbenchMenu void getMenus(final Consumer<Menus> menusConsumer); @Override @WorkbenchPartView IsWidget getWidget(); void copy(boolean save); void rename(boolean save); LayoutTemplate getFormTemplate(); FormDefinition getFormDefinition(); void onRemoveComponent(@Observes ComponentRemovedEvent event); void onLayoutEditorElementSelectEvent(@Observes LayoutEditorElementSelectEvent event); void onSyncPalette(@Observes FormEditorSyncPaletteEvent event); void onSyncPalette(String formId); void safeDelete(); @OnMayClose Boolean onMayClose(); @PreDestroy void destroy(); void onLockStatusChange(@Observes UpdatedLockStatusEvent updatedLockStatusEvent); } | FormEditorPresenter extends KieEditor<FormModelerContent> { public void onLockStatusChange(@Observes UpdatedLockStatusEvent updatedLockStatusEvent) { if (updatedLockStatusEvent.getFile().equals(versionRecordManager.getCurrentPath())) { if (updatedLockStatusEvent.isLocked() && !updatedLockStatusEvent.isLockedByCurrentUser()) { layoutEditor.lock(); } else { layoutEditor.unlock(); } } } @Inject FormEditorPresenter(FormEditorView view,
ChangesNotificationDisplayer changesNotificationDisplayer,
FormDefinitionResourceType resourceType,
Caller<FormEditorService> editorService,
TranslationService translationService,
ManagedInstance<EditorFieldLayoutComponent> editorFieldLayoutComponents,
ShowAssetUsagesDisplayer showAssetUsagesDisplayer,
ErrorMessageDisplayer errorMessageDisplayer,
LayoutEditorPropertiesPresenter layoutEditorPropertiesPresenter); @OnStartup void onStartup(final ObservablePath path,
final PlaceRequest place); @OnFocus void onFocus(); @Override void hideDocks(); void doLoadContent(final FormModelerContent content); @Override @WorkbenchPartTitle String getTitleText(); @WorkbenchMenu void getMenus(final Consumer<Menus> menusConsumer); @Override @WorkbenchPartView IsWidget getWidget(); void copy(boolean save); void rename(boolean save); LayoutTemplate getFormTemplate(); FormDefinition getFormDefinition(); void onRemoveComponent(@Observes ComponentRemovedEvent event); void onLayoutEditorElementSelectEvent(@Observes LayoutEditorElementSelectEvent event); void onSyncPalette(@Observes FormEditorSyncPaletteEvent event); void onSyncPalette(String formId); void safeDelete(); @OnMayClose Boolean onMayClose(); @PreDestroy void destroy(); void onLockStatusChange(@Observes UpdatedLockStatusEvent updatedLockStatusEvent); static final String ID; } |
@Test public void testGenerateContextForModel() { StaticModelFormRenderingContext context = dynamicFormModelGenerator.getContextForModel(model); assertNotNull(context); assertNotNull(context.getRootForm()); assertEquals(3, context.getAvailableForms().size()); context.getAvailableForms().forEach((id, form) -> { testGeneratedForm(form, id); }); } | public StaticModelFormRenderingContext getContextForModel(Object model, FormElementFilter... filters) { PortablePreconditions.checkNotNull("model", model); Optional<FormElementFilter[]> optional = Optional.ofNullable(filters); Stream<FormElementFilter> streamFilter = optional.map(value -> Stream.of(value)).orElseGet(Stream::empty); List<FormElementFilter> rootFormElemenFilters = new ArrayList<>(); List<FormElementFilter> nestedFormFilters = new ArrayList<>(); streamFilter.forEach(filter -> { if(!filter.getElementName().contains(".")) { rootFormElemenFilters.add(filter); } else { nestedFormFilters.add(filter); } }); FormDefinition formDefinition = formBuildingService.generateFormForModel(model, rootFormElemenFilters.stream().toArray(FormElementFilter[]::new)); if (formDefinition == null) { return null; } StaticModelFormRenderingContext context = new StaticModelFormRenderingContext(String.valueOf(System.currentTimeMillis())); context.setModel(model); context.setRootForm(formDefinition); if (context.getModel() != null) { initNestedFormSettings(formDefinition, context.getModel(), context, nestedFormFilters); } else { initNestedFormSettings(formDefinition,null, context, nestedFormFilters); } return context; } | DynamicFormModelGenerator { public StaticModelFormRenderingContext getContextForModel(Object model, FormElementFilter... filters) { PortablePreconditions.checkNotNull("model", model); Optional<FormElementFilter[]> optional = Optional.ofNullable(filters); Stream<FormElementFilter> streamFilter = optional.map(value -> Stream.of(value)).orElseGet(Stream::empty); List<FormElementFilter> rootFormElemenFilters = new ArrayList<>(); List<FormElementFilter> nestedFormFilters = new ArrayList<>(); streamFilter.forEach(filter -> { if(!filter.getElementName().contains(".")) { rootFormElemenFilters.add(filter); } else { nestedFormFilters.add(filter); } }); FormDefinition formDefinition = formBuildingService.generateFormForModel(model, rootFormElemenFilters.stream().toArray(FormElementFilter[]::new)); if (formDefinition == null) { return null; } StaticModelFormRenderingContext context = new StaticModelFormRenderingContext(String.valueOf(System.currentTimeMillis())); context.setModel(model); context.setRootForm(formDefinition); if (context.getModel() != null) { initNestedFormSettings(formDefinition, context.getModel(), context, nestedFormFilters); } else { initNestedFormSettings(formDefinition,null, context, nestedFormFilters); } return context; } } | DynamicFormModelGenerator { public StaticModelFormRenderingContext getContextForModel(Object model, FormElementFilter... filters) { PortablePreconditions.checkNotNull("model", model); Optional<FormElementFilter[]> optional = Optional.ofNullable(filters); Stream<FormElementFilter> streamFilter = optional.map(value -> Stream.of(value)).orElseGet(Stream::empty); List<FormElementFilter> rootFormElemenFilters = new ArrayList<>(); List<FormElementFilter> nestedFormFilters = new ArrayList<>(); streamFilter.forEach(filter -> { if(!filter.getElementName().contains(".")) { rootFormElemenFilters.add(filter); } else { nestedFormFilters.add(filter); } }); FormDefinition formDefinition = formBuildingService.generateFormForModel(model, rootFormElemenFilters.stream().toArray(FormElementFilter[]::new)); if (formDefinition == null) { return null; } StaticModelFormRenderingContext context = new StaticModelFormRenderingContext(String.valueOf(System.currentTimeMillis())); context.setModel(model); context.setRootForm(formDefinition); if (context.getModel() != null) { initNestedFormSettings(formDefinition, context.getModel(), context, nestedFormFilters); } else { initNestedFormSettings(formDefinition,null, context, nestedFormFilters); } return context; } @Inject DynamicFormModelGenerator(FormBuildingService formBuildingService,
PropertyValueExtractor propertyValueExtractor); } | DynamicFormModelGenerator { public StaticModelFormRenderingContext getContextForModel(Object model, FormElementFilter... filters) { PortablePreconditions.checkNotNull("model", model); Optional<FormElementFilter[]> optional = Optional.ofNullable(filters); Stream<FormElementFilter> streamFilter = optional.map(value -> Stream.of(value)).orElseGet(Stream::empty); List<FormElementFilter> rootFormElemenFilters = new ArrayList<>(); List<FormElementFilter> nestedFormFilters = new ArrayList<>(); streamFilter.forEach(filter -> { if(!filter.getElementName().contains(".")) { rootFormElemenFilters.add(filter); } else { nestedFormFilters.add(filter); } }); FormDefinition formDefinition = formBuildingService.generateFormForModel(model, rootFormElemenFilters.stream().toArray(FormElementFilter[]::new)); if (formDefinition == null) { return null; } StaticModelFormRenderingContext context = new StaticModelFormRenderingContext(String.valueOf(System.currentTimeMillis())); context.setModel(model); context.setRootForm(formDefinition); if (context.getModel() != null) { initNestedFormSettings(formDefinition, context.getModel(), context, nestedFormFilters); } else { initNestedFormSettings(formDefinition,null, context, nestedFormFilters); } return context; } @Inject DynamicFormModelGenerator(FormBuildingService formBuildingService,
PropertyValueExtractor propertyValueExtractor); StaticModelFormRenderingContext getContextForModel(Object model, FormElementFilter... filters); } | DynamicFormModelGenerator { public StaticModelFormRenderingContext getContextForModel(Object model, FormElementFilter... filters) { PortablePreconditions.checkNotNull("model", model); Optional<FormElementFilter[]> optional = Optional.ofNullable(filters); Stream<FormElementFilter> streamFilter = optional.map(value -> Stream.of(value)).orElseGet(Stream::empty); List<FormElementFilter> rootFormElemenFilters = new ArrayList<>(); List<FormElementFilter> nestedFormFilters = new ArrayList<>(); streamFilter.forEach(filter -> { if(!filter.getElementName().contains(".")) { rootFormElemenFilters.add(filter); } else { nestedFormFilters.add(filter); } }); FormDefinition formDefinition = formBuildingService.generateFormForModel(model, rootFormElemenFilters.stream().toArray(FormElementFilter[]::new)); if (formDefinition == null) { return null; } StaticModelFormRenderingContext context = new StaticModelFormRenderingContext(String.valueOf(System.currentTimeMillis())); context.setModel(model); context.setRootForm(formDefinition); if (context.getModel() != null) { initNestedFormSettings(formDefinition, context.getModel(), context, nestedFormFilters); } else { initNestedFormSettings(formDefinition,null, context, nestedFormFilters); } return context; } @Inject DynamicFormModelGenerator(FormBuildingService formBuildingService,
PropertyValueExtractor propertyValueExtractor); StaticModelFormRenderingContext getContextForModel(Object model, FormElementFilter... filters); } |
@Test public void testGenerateContextForModelWithFilters() { FormElementFilter nameFilter = new FormElementFilter("name", o -> true); FormElementFilter lastNameFilter = new FormElementFilter("lastName", o -> false); FormElementFilter addressStreetFilter = new FormElementFilter("address.street", o -> true); FormElementFilter addressNumFilter = new FormElementFilter("address.number", o -> false); StaticModelFormRenderingContext context = dynamicFormModelGenerator.getContextForModel(model, nameFilter, lastNameFilter, addressStreetFilter, addressNumFilter); assertEquals(3, context.getAvailableForms().size()); FormDefinition rootForm = context.getRootForm(); assertNotNull(rootForm); assertEquals(rootForm.getFields().size(), rootForm.getLayoutTemplate().getRows().size()); assertNotNull(rootForm.getFieldByBinding("name")); assertNull(rootForm.getFieldByBinding("lastName")); FormDefinition addressForm = context.getAvailableForms().get(Address.class.getName()); assertNotNull(addressForm); assertEquals(addressForm.getFields().size(), addressForm.getLayoutTemplate().getRows().size()); assertNotNull(addressForm.getFieldByBinding("street")); assertNull(addressForm.getFieldByBinding("number")); } | public StaticModelFormRenderingContext getContextForModel(Object model, FormElementFilter... filters) { PortablePreconditions.checkNotNull("model", model); Optional<FormElementFilter[]> optional = Optional.ofNullable(filters); Stream<FormElementFilter> streamFilter = optional.map(value -> Stream.of(value)).orElseGet(Stream::empty); List<FormElementFilter> rootFormElemenFilters = new ArrayList<>(); List<FormElementFilter> nestedFormFilters = new ArrayList<>(); streamFilter.forEach(filter -> { if(!filter.getElementName().contains(".")) { rootFormElemenFilters.add(filter); } else { nestedFormFilters.add(filter); } }); FormDefinition formDefinition = formBuildingService.generateFormForModel(model, rootFormElemenFilters.stream().toArray(FormElementFilter[]::new)); if (formDefinition == null) { return null; } StaticModelFormRenderingContext context = new StaticModelFormRenderingContext(String.valueOf(System.currentTimeMillis())); context.setModel(model); context.setRootForm(formDefinition); if (context.getModel() != null) { initNestedFormSettings(formDefinition, context.getModel(), context, nestedFormFilters); } else { initNestedFormSettings(formDefinition,null, context, nestedFormFilters); } return context; } | DynamicFormModelGenerator { public StaticModelFormRenderingContext getContextForModel(Object model, FormElementFilter... filters) { PortablePreconditions.checkNotNull("model", model); Optional<FormElementFilter[]> optional = Optional.ofNullable(filters); Stream<FormElementFilter> streamFilter = optional.map(value -> Stream.of(value)).orElseGet(Stream::empty); List<FormElementFilter> rootFormElemenFilters = new ArrayList<>(); List<FormElementFilter> nestedFormFilters = new ArrayList<>(); streamFilter.forEach(filter -> { if(!filter.getElementName().contains(".")) { rootFormElemenFilters.add(filter); } else { nestedFormFilters.add(filter); } }); FormDefinition formDefinition = formBuildingService.generateFormForModel(model, rootFormElemenFilters.stream().toArray(FormElementFilter[]::new)); if (formDefinition == null) { return null; } StaticModelFormRenderingContext context = new StaticModelFormRenderingContext(String.valueOf(System.currentTimeMillis())); context.setModel(model); context.setRootForm(formDefinition); if (context.getModel() != null) { initNestedFormSettings(formDefinition, context.getModel(), context, nestedFormFilters); } else { initNestedFormSettings(formDefinition,null, context, nestedFormFilters); } return context; } } | DynamicFormModelGenerator { public StaticModelFormRenderingContext getContextForModel(Object model, FormElementFilter... filters) { PortablePreconditions.checkNotNull("model", model); Optional<FormElementFilter[]> optional = Optional.ofNullable(filters); Stream<FormElementFilter> streamFilter = optional.map(value -> Stream.of(value)).orElseGet(Stream::empty); List<FormElementFilter> rootFormElemenFilters = new ArrayList<>(); List<FormElementFilter> nestedFormFilters = new ArrayList<>(); streamFilter.forEach(filter -> { if(!filter.getElementName().contains(".")) { rootFormElemenFilters.add(filter); } else { nestedFormFilters.add(filter); } }); FormDefinition formDefinition = formBuildingService.generateFormForModel(model, rootFormElemenFilters.stream().toArray(FormElementFilter[]::new)); if (formDefinition == null) { return null; } StaticModelFormRenderingContext context = new StaticModelFormRenderingContext(String.valueOf(System.currentTimeMillis())); context.setModel(model); context.setRootForm(formDefinition); if (context.getModel() != null) { initNestedFormSettings(formDefinition, context.getModel(), context, nestedFormFilters); } else { initNestedFormSettings(formDefinition,null, context, nestedFormFilters); } return context; } @Inject DynamicFormModelGenerator(FormBuildingService formBuildingService,
PropertyValueExtractor propertyValueExtractor); } | DynamicFormModelGenerator { public StaticModelFormRenderingContext getContextForModel(Object model, FormElementFilter... filters) { PortablePreconditions.checkNotNull("model", model); Optional<FormElementFilter[]> optional = Optional.ofNullable(filters); Stream<FormElementFilter> streamFilter = optional.map(value -> Stream.of(value)).orElseGet(Stream::empty); List<FormElementFilter> rootFormElemenFilters = new ArrayList<>(); List<FormElementFilter> nestedFormFilters = new ArrayList<>(); streamFilter.forEach(filter -> { if(!filter.getElementName().contains(".")) { rootFormElemenFilters.add(filter); } else { nestedFormFilters.add(filter); } }); FormDefinition formDefinition = formBuildingService.generateFormForModel(model, rootFormElemenFilters.stream().toArray(FormElementFilter[]::new)); if (formDefinition == null) { return null; } StaticModelFormRenderingContext context = new StaticModelFormRenderingContext(String.valueOf(System.currentTimeMillis())); context.setModel(model); context.setRootForm(formDefinition); if (context.getModel() != null) { initNestedFormSettings(formDefinition, context.getModel(), context, nestedFormFilters); } else { initNestedFormSettings(formDefinition,null, context, nestedFormFilters); } return context; } @Inject DynamicFormModelGenerator(FormBuildingService formBuildingService,
PropertyValueExtractor propertyValueExtractor); StaticModelFormRenderingContext getContextForModel(Object model, FormElementFilter... filters); } | DynamicFormModelGenerator { public StaticModelFormRenderingContext getContextForModel(Object model, FormElementFilter... filters) { PortablePreconditions.checkNotNull("model", model); Optional<FormElementFilter[]> optional = Optional.ofNullable(filters); Stream<FormElementFilter> streamFilter = optional.map(value -> Stream.of(value)).orElseGet(Stream::empty); List<FormElementFilter> rootFormElemenFilters = new ArrayList<>(); List<FormElementFilter> nestedFormFilters = new ArrayList<>(); streamFilter.forEach(filter -> { if(!filter.getElementName().contains(".")) { rootFormElemenFilters.add(filter); } else { nestedFormFilters.add(filter); } }); FormDefinition formDefinition = formBuildingService.generateFormForModel(model, rootFormElemenFilters.stream().toArray(FormElementFilter[]::new)); if (formDefinition == null) { return null; } StaticModelFormRenderingContext context = new StaticModelFormRenderingContext(String.valueOf(System.currentTimeMillis())); context.setModel(model); context.setRootForm(formDefinition); if (context.getModel() != null) { initNestedFormSettings(formDefinition, context.getModel(), context, nestedFormFilters); } else { initNestedFormSettings(formDefinition,null, context, nestedFormFilters); } return context; } @Inject DynamicFormModelGenerator(FormBuildingService formBuildingService,
PropertyValueExtractor propertyValueExtractor); StaticModelFormRenderingContext getContextForModel(Object model, FormElementFilter... filters); } |
@Test public void testCreateComponent() { HTMLElement column = mock(HTMLElement.class); LayoutComponent layoutComponent = new LayoutComponent(FieldLayoutComponent.class.getName()); driver.createComponent(column, layoutComponent); verify(beanManager).lookupBeans(anyString()); verify(instance).select(eq(FieldLayoutComponent.class)); verify(wrapperWidgetUtil).getWidget(same(driver), any(HTMLElement.class)); Assertions.assertThat(driver.getLayoutFields()) .hasSize(1); FieldLayoutComponent fieldLayoutComponent = driver.getLayoutFields().get(0); verify(fieldLayoutComponent).init(eq(context), any()); verify(fieldLayoutComponent).getShowWidget(any()); layoutComponent = new LayoutComponent(FieldLayoutComponent.class.getName()); driver.createComponent(column, layoutComponent); verify(beanManager, times(1)).lookupBeans(anyString()); verify(instance, times(2)).select(eq(FieldLayoutComponent.class)); verify(wrapperWidgetUtil, times(2)).getWidget(same(driver), any(HTMLElement.class)); Assertions.assertThat(driver.getLayoutFields()) .hasSize(2); fieldLayoutComponent = driver.getLayoutFields().get(1); verify(fieldLayoutComponent).init(eq(context), any()); verify(fieldLayoutComponent).getShowWidget(any()); } | @Override public IsWidget createComponent(HTMLElement column, LayoutComponent layoutComponent) { final LayoutDragComponent dragComponent = lookupComponent(layoutComponent); if (dragComponent != null) { Widget columnWidget = getWidget(column); RenderingContext componentContext = new RenderingContext(layoutComponent, columnWidget); return dragComponent.getShowWidget(componentContext); } return null; } | FormGeneratorDriver implements LayoutGeneratorDriver { @Override public IsWidget createComponent(HTMLElement column, LayoutComponent layoutComponent) { final LayoutDragComponent dragComponent = lookupComponent(layoutComponent); if (dragComponent != null) { Widget columnWidget = getWidget(column); RenderingContext componentContext = new RenderingContext(layoutComponent, columnWidget); return dragComponent.getShowWidget(componentContext); } return null; } } | FormGeneratorDriver implements LayoutGeneratorDriver { @Override public IsWidget createComponent(HTMLElement column, LayoutComponent layoutComponent) { final LayoutDragComponent dragComponent = lookupComponent(layoutComponent); if (dragComponent != null) { Widget columnWidget = getWidget(column); RenderingContext componentContext = new RenderingContext(layoutComponent, columnWidget); return dragComponent.getShowWidget(componentContext); } return null; } @Inject FormGeneratorDriver(SyncBeanManager beanManager, ManagedInstance<LayoutDragComponent> instance, FormsElementWrapperWidgetUtil wrapperWidgetUtil, Document document); } | FormGeneratorDriver implements LayoutGeneratorDriver { @Override public IsWidget createComponent(HTMLElement column, LayoutComponent layoutComponent) { final LayoutDragComponent dragComponent = lookupComponent(layoutComponent); if (dragComponent != null) { Widget columnWidget = getWidget(column); RenderingContext componentContext = new RenderingContext(layoutComponent, columnWidget); return dragComponent.getShowWidget(componentContext); } return null; } @Inject FormGeneratorDriver(SyncBeanManager beanManager, ManagedInstance<LayoutDragComponent> instance, FormsElementWrapperWidgetUtil wrapperWidgetUtil, Document document); FormRenderingContext getRenderingContext(); void setRenderingContext(FormRenderingContext renderingContext); @Override HTMLElement createContainer(); @Override HTMLElement createRow(LayoutRow layoutRow); @Override HTMLElement createColumn(LayoutColumn layoutColumn); @Override IsWidget createComponent(HTMLElement column, LayoutComponent layoutComponent); @Override Optional<IsWidget> getComponentPart(HTMLElement column, LayoutComponent layoutComponent, String partId); List<FieldLayoutComponent> getLayoutFields(); FieldLayoutComponent getFieldLayoutComponentForField(FieldDefinition field); void clear(); } | FormGeneratorDriver implements LayoutGeneratorDriver { @Override public IsWidget createComponent(HTMLElement column, LayoutComponent layoutComponent) { final LayoutDragComponent dragComponent = lookupComponent(layoutComponent); if (dragComponent != null) { Widget columnWidget = getWidget(column); RenderingContext componentContext = new RenderingContext(layoutComponent, columnWidget); return dragComponent.getShowWidget(componentContext); } return null; } @Inject FormGeneratorDriver(SyncBeanManager beanManager, ManagedInstance<LayoutDragComponent> instance, FormsElementWrapperWidgetUtil wrapperWidgetUtil, Document document); FormRenderingContext getRenderingContext(); void setRenderingContext(FormRenderingContext renderingContext); @Override HTMLElement createContainer(); @Override HTMLElement createRow(LayoutRow layoutRow); @Override HTMLElement createColumn(LayoutColumn layoutColumn); @Override IsWidget createComponent(HTMLElement column, LayoutComponent layoutComponent); @Override Optional<IsWidget> getComponentPart(HTMLElement column, LayoutComponent layoutComponent, String partId); List<FieldLayoutComponent> getLayoutFields(); FieldLayoutComponent getFieldLayoutComponentForField(FieldDefinition field); void clear(); } |
@Test public void testGetComponentPart() { testCreateComponent(); HTMLElement column = mock(HTMLElement.class); LayoutComponent layoutComponent = new LayoutComponent(FieldLayoutComponent.class.getName()); Optional<IsWidget> result = driver.getComponentPart(column, layoutComponent, ""); Assert.assertTrue(result.isPresent()); verify(wrapperWidgetUtil, times(3)).getWidget(same(driver), any(HTMLElement.class)); FieldLayoutComponent fieldLayoutComponent = driver.getLayoutFields().get(0); verify(fieldLayoutComponent).getContentPart(eq(""), any()); } | @Override public Optional<IsWidget> getComponentPart(HTMLElement column, LayoutComponent layoutComponent, String partId) { FieldDefinition field = getFieldForLayoutComponent(layoutComponent); FieldLayoutComponent dragComponent = getFieldLayoutComponentForField(field); if (dragComponent != null) { Widget columnWidget = getWidget(column); RenderingContext componentContext = new RenderingContext(layoutComponent, columnWidget); return dragComponent.getContentPart(partId, componentContext); } return Optional.empty(); } | FormGeneratorDriver implements LayoutGeneratorDriver { @Override public Optional<IsWidget> getComponentPart(HTMLElement column, LayoutComponent layoutComponent, String partId) { FieldDefinition field = getFieldForLayoutComponent(layoutComponent); FieldLayoutComponent dragComponent = getFieldLayoutComponentForField(field); if (dragComponent != null) { Widget columnWidget = getWidget(column); RenderingContext componentContext = new RenderingContext(layoutComponent, columnWidget); return dragComponent.getContentPart(partId, componentContext); } return Optional.empty(); } } | FormGeneratorDriver implements LayoutGeneratorDriver { @Override public Optional<IsWidget> getComponentPart(HTMLElement column, LayoutComponent layoutComponent, String partId) { FieldDefinition field = getFieldForLayoutComponent(layoutComponent); FieldLayoutComponent dragComponent = getFieldLayoutComponentForField(field); if (dragComponent != null) { Widget columnWidget = getWidget(column); RenderingContext componentContext = new RenderingContext(layoutComponent, columnWidget); return dragComponent.getContentPart(partId, componentContext); } return Optional.empty(); } @Inject FormGeneratorDriver(SyncBeanManager beanManager, ManagedInstance<LayoutDragComponent> instance, FormsElementWrapperWidgetUtil wrapperWidgetUtil, Document document); } | FormGeneratorDriver implements LayoutGeneratorDriver { @Override public Optional<IsWidget> getComponentPart(HTMLElement column, LayoutComponent layoutComponent, String partId) { FieldDefinition field = getFieldForLayoutComponent(layoutComponent); FieldLayoutComponent dragComponent = getFieldLayoutComponentForField(field); if (dragComponent != null) { Widget columnWidget = getWidget(column); RenderingContext componentContext = new RenderingContext(layoutComponent, columnWidget); return dragComponent.getContentPart(partId, componentContext); } return Optional.empty(); } @Inject FormGeneratorDriver(SyncBeanManager beanManager, ManagedInstance<LayoutDragComponent> instance, FormsElementWrapperWidgetUtil wrapperWidgetUtil, Document document); FormRenderingContext getRenderingContext(); void setRenderingContext(FormRenderingContext renderingContext); @Override HTMLElement createContainer(); @Override HTMLElement createRow(LayoutRow layoutRow); @Override HTMLElement createColumn(LayoutColumn layoutColumn); @Override IsWidget createComponent(HTMLElement column, LayoutComponent layoutComponent); @Override Optional<IsWidget> getComponentPart(HTMLElement column, LayoutComponent layoutComponent, String partId); List<FieldLayoutComponent> getLayoutFields(); FieldLayoutComponent getFieldLayoutComponentForField(FieldDefinition field); void clear(); } | FormGeneratorDriver implements LayoutGeneratorDriver { @Override public Optional<IsWidget> getComponentPart(HTMLElement column, LayoutComponent layoutComponent, String partId) { FieldDefinition field = getFieldForLayoutComponent(layoutComponent); FieldLayoutComponent dragComponent = getFieldLayoutComponentForField(field); if (dragComponent != null) { Widget columnWidget = getWidget(column); RenderingContext componentContext = new RenderingContext(layoutComponent, columnWidget); return dragComponent.getContentPart(partId, componentContext); } return Optional.empty(); } @Inject FormGeneratorDriver(SyncBeanManager beanManager, ManagedInstance<LayoutDragComponent> instance, FormsElementWrapperWidgetUtil wrapperWidgetUtil, Document document); FormRenderingContext getRenderingContext(); void setRenderingContext(FormRenderingContext renderingContext); @Override HTMLElement createContainer(); @Override HTMLElement createRow(LayoutRow layoutRow); @Override HTMLElement createColumn(LayoutColumn layoutColumn); @Override IsWidget createComponent(HTMLElement column, LayoutComponent layoutComponent); @Override Optional<IsWidget> getComponentPart(HTMLElement column, LayoutComponent layoutComponent, String partId); List<FieldLayoutComponent> getLayoutFields(); FieldLayoutComponent getFieldLayoutComponentForField(FieldDefinition field); void clear(); } |
@Test public void testClear() { driver.clear(); verify(instance).destroyAll(); verify(wrapperWidgetUtil).clear(same(driver)); } | public void clear() { layoutComponents.clear(); instance.destroyAll(); wrapperWidgetUtil.clear(this); componentsCache.clear(); renderingContext = null; } | FormGeneratorDriver implements LayoutGeneratorDriver { public void clear() { layoutComponents.clear(); instance.destroyAll(); wrapperWidgetUtil.clear(this); componentsCache.clear(); renderingContext = null; } } | FormGeneratorDriver implements LayoutGeneratorDriver { public void clear() { layoutComponents.clear(); instance.destroyAll(); wrapperWidgetUtil.clear(this); componentsCache.clear(); renderingContext = null; } @Inject FormGeneratorDriver(SyncBeanManager beanManager, ManagedInstance<LayoutDragComponent> instance, FormsElementWrapperWidgetUtil wrapperWidgetUtil, Document document); } | FormGeneratorDriver implements LayoutGeneratorDriver { public void clear() { layoutComponents.clear(); instance.destroyAll(); wrapperWidgetUtil.clear(this); componentsCache.clear(); renderingContext = null; } @Inject FormGeneratorDriver(SyncBeanManager beanManager, ManagedInstance<LayoutDragComponent> instance, FormsElementWrapperWidgetUtil wrapperWidgetUtil, Document document); FormRenderingContext getRenderingContext(); void setRenderingContext(FormRenderingContext renderingContext); @Override HTMLElement createContainer(); @Override HTMLElement createRow(LayoutRow layoutRow); @Override HTMLElement createColumn(LayoutColumn layoutColumn); @Override IsWidget createComponent(HTMLElement column, LayoutComponent layoutComponent); @Override Optional<IsWidget> getComponentPart(HTMLElement column, LayoutComponent layoutComponent, String partId); List<FieldLayoutComponent> getLayoutFields(); FieldLayoutComponent getFieldLayoutComponentForField(FieldDefinition field); void clear(); } | FormGeneratorDriver implements LayoutGeneratorDriver { public void clear() { layoutComponents.clear(); instance.destroyAll(); wrapperWidgetUtil.clear(this); componentsCache.clear(); renderingContext = null; } @Inject FormGeneratorDriver(SyncBeanManager beanManager, ManagedInstance<LayoutDragComponent> instance, FormsElementWrapperWidgetUtil wrapperWidgetUtil, Document document); FormRenderingContext getRenderingContext(); void setRenderingContext(FormRenderingContext renderingContext); @Override HTMLElement createContainer(); @Override HTMLElement createRow(LayoutRow layoutRow); @Override HTMLElement createColumn(LayoutColumn layoutColumn); @Override IsWidget createComponent(HTMLElement column, LayoutComponent layoutComponent); @Override Optional<IsWidget> getComponentPart(HTMLElement column, LayoutComponent layoutComponent, String partId); List<FieldLayoutComponent> getLayoutFields(); FieldLayoutComponent getFieldLayoutComponentForField(FieldDefinition field); void clear(); } |
@Test public void testGetConverterInt() { when(fieldDefinition.getStandaloneClassName()).thenReturn("int"); Converter converter = fieldRenderer.getConverter(); assertNotNull(converter); assertThat(converter, instanceOf(IntegerToDoubleConverter.class)); } | @Override public Converter getConverter() { if (field.getStandaloneClassName() == Integer.class.getName() || field.getStandaloneClassName() == "int") { return new IntegerToDoubleConverter(); } return null; } | SliderFieldRenderer extends FieldRenderer<SliderBaseDefinition, SliderFormGroup> implements RequiresValueConverter { @Override public Converter getConverter() { if (field.getStandaloneClassName() == Integer.class.getName() || field.getStandaloneClassName() == "int") { return new IntegerToDoubleConverter(); } return null; } } | SliderFieldRenderer extends FieldRenderer<SliderBaseDefinition, SliderFormGroup> implements RequiresValueConverter { @Override public Converter getConverter() { if (field.getStandaloneClassName() == Integer.class.getName() || field.getStandaloneClassName() == "int") { return new IntegerToDoubleConverter(); } return null; } } | SliderFieldRenderer extends FieldRenderer<SliderBaseDefinition, SliderFormGroup> implements RequiresValueConverter { @Override public Converter getConverter() { if (field.getStandaloneClassName() == Integer.class.getName() || field.getStandaloneClassName() == "int") { return new IntegerToDoubleConverter(); } return null; } @Override String getName(); @Override Converter getConverter(); } | SliderFieldRenderer extends FieldRenderer<SliderBaseDefinition, SliderFormGroup> implements RequiresValueConverter { @Override public Converter getConverter() { if (field.getStandaloneClassName() == Integer.class.getName() || field.getStandaloneClassName() == "int") { return new IntegerToDoubleConverter(); } return null; } @Override String getName(); @Override Converter getConverter(); } |
@Test public void testResize() { view.getHandlerManager().fireEvent(new WiresResizeStepEvent(view, nodeDragMoveEvent, 0, 0, WIDTH, HEIGHT)); assertThat(getMoveDividerControlHandle().getControl().getX()).isEqualTo(WIDTH / 2); } | @Override public HandlerManager getHandlerManager() { return super.getHandlerManager(); } | DecisionServiceSVGShapeView extends SVGShapeViewImpl { @Override public HandlerManager getHandlerManager() { return super.getHandlerManager(); } } | DecisionServiceSVGShapeView extends SVGShapeViewImpl { @Override public HandlerManager getHandlerManager() { return super.getHandlerManager(); } DecisionServiceSVGShapeView(final String name,
final SVGPrimitiveShape svgPrimitive,
final double width,
final double height,
final boolean resizable); } | DecisionServiceSVGShapeView extends SVGShapeViewImpl { @Override public HandlerManager getHandlerManager() { return super.getHandlerManager(); } DecisionServiceSVGShapeView(final String name,
final SVGPrimitiveShape svgPrimitive,
final double width,
final double height,
final boolean resizable); DecisionServiceSVGShapeView addDividerDragHandler(final DragHandler dragHandler); double getDividerLineY(); void setDividerLineY(final double y); @Override //Override to increase visibility for Unit Tests HandlerManager getHandlerManager(); @Override void destroy(); } | DecisionServiceSVGShapeView extends SVGShapeViewImpl { @Override public HandlerManager getHandlerManager() { return super.getHandlerManager(); } DecisionServiceSVGShapeView(final String name,
final SVGPrimitiveShape svgPrimitive,
final double width,
final double height,
final boolean resizable); DecisionServiceSVGShapeView addDividerDragHandler(final DragHandler dragHandler); double getDividerLineY(); void setDividerLineY(final double y); @Override //Override to increase visibility for Unit Tests HandlerManager getHandlerManager(); @Override void destroy(); } |
@Test public void testGetFormGroup() { renderer.getFormGroup(RenderMode.EDIT_MODE); verify(formGroupsInstance).get(); verify(textBox).setId(any()); verify(textBox).setName(anyString()); verify(textBox).setPlaceholder(eq(fieldDefinition.getPlaceHolder())); verify(textBox).setMaxLength(eq(fieldDefinition.getMaxLength())); verify(textBox).setEnabled(eq(!fieldDefinition.getReadOnly())); verify(formGroup).render(anyString(), eq(textBox), eq(fieldDefinition)); } | @Override protected FormGroup getFormGroup(RenderMode renderMode) { DefaultFormGroup formGroup = formGroupsInstance.get(); if (renderMode.equals(RenderMode.PRETTY_MODE)) { HTML html = new HTML(); formGroup.render(html, field); } else { String inputId = generateUniqueId(); textBox.setName(fieldNS); textBox.setId(inputId); textBox.setPlaceholder(field.getPlaceHolder()); textBox.setMaxLength(field.getMaxLength()); textBox.setEnabled(!field.getReadOnly()); registerFieldRendererPart(textBox); formGroup.render(inputId, textBox, field); } return formGroup; } | TextBoxFieldRenderer extends FieldRenderer<TextBoxBaseDefinition, DefaultFormGroup> implements RequiresValueConverter { @Override protected FormGroup getFormGroup(RenderMode renderMode) { DefaultFormGroup formGroup = formGroupsInstance.get(); if (renderMode.equals(RenderMode.PRETTY_MODE)) { HTML html = new HTML(); formGroup.render(html, field); } else { String inputId = generateUniqueId(); textBox.setName(fieldNS); textBox.setId(inputId); textBox.setPlaceholder(field.getPlaceHolder()); textBox.setMaxLength(field.getMaxLength()); textBox.setEnabled(!field.getReadOnly()); registerFieldRendererPart(textBox); formGroup.render(inputId, textBox, field); } return formGroup; } } | TextBoxFieldRenderer extends FieldRenderer<TextBoxBaseDefinition, DefaultFormGroup> implements RequiresValueConverter { @Override protected FormGroup getFormGroup(RenderMode renderMode) { DefaultFormGroup formGroup = formGroupsInstance.get(); if (renderMode.equals(RenderMode.PRETTY_MODE)) { HTML html = new HTML(); formGroup.render(html, field); } else { String inputId = generateUniqueId(); textBox.setName(fieldNS); textBox.setId(inputId); textBox.setPlaceholder(field.getPlaceHolder()); textBox.setMaxLength(field.getMaxLength()); textBox.setEnabled(!field.getReadOnly()); registerFieldRendererPart(textBox); formGroup.render(inputId, textBox, field); } return formGroup; } } | TextBoxFieldRenderer extends FieldRenderer<TextBoxBaseDefinition, DefaultFormGroup> implements RequiresValueConverter { @Override protected FormGroup getFormGroup(RenderMode renderMode) { DefaultFormGroup formGroup = formGroupsInstance.get(); if (renderMode.equals(RenderMode.PRETTY_MODE)) { HTML html = new HTML(); formGroup.render(html, field); } else { String inputId = generateUniqueId(); textBox.setName(fieldNS); textBox.setId(inputId); textBox.setPlaceholder(field.getPlaceHolder()); textBox.setMaxLength(field.getMaxLength()); textBox.setEnabled(!field.getReadOnly()); registerFieldRendererPart(textBox); formGroup.render(inputId, textBox, field); } return formGroup; } @Override String getName(); @Override Converter getConverter(); } | TextBoxFieldRenderer extends FieldRenderer<TextBoxBaseDefinition, DefaultFormGroup> implements RequiresValueConverter { @Override protected FormGroup getFormGroup(RenderMode renderMode) { DefaultFormGroup formGroup = formGroupsInstance.get(); if (renderMode.equals(RenderMode.PRETTY_MODE)) { HTML html = new HTML(); formGroup.render(html, field); } else { String inputId = generateUniqueId(); textBox.setName(fieldNS); textBox.setId(inputId); textBox.setPlaceholder(field.getPlaceHolder()); textBox.setMaxLength(field.getMaxLength()); textBox.setEnabled(!field.getReadOnly()); registerFieldRendererPart(textBox); formGroup.render(inputId, textBox, field); } return formGroup; } @Override String getName(); @Override Converter getConverter(); } |
@Test public void testRender() { subFormWidget.render(context); verify(formRenderer).render(same(context)); } | public void render(FormRenderingContext renderingContext) { formRenderer.render(renderingContext); } | SubFormWidget extends Composite implements TakesValue<Object>,
IsNestedModel,
NeedsFlush { public void render(FormRenderingContext renderingContext) { formRenderer.render(renderingContext); } } | SubFormWidget extends Composite implements TakesValue<Object>,
IsNestedModel,
NeedsFlush { public void render(FormRenderingContext renderingContext) { formRenderer.render(renderingContext); } } | SubFormWidget extends Composite implements TakesValue<Object>,
IsNestedModel,
NeedsFlush { public void render(FormRenderingContext renderingContext) { formRenderer.render(renderingContext); } void render(FormRenderingContext renderingContext); @Override Object getValue(); @Override void setValue(Object value); @Override void clear(); @Override void flush(); @Override void addFieldChangeHandler(FieldChangeHandler handler); void setReadOnly(boolean readOnly); boolean isValid(); } | SubFormWidget extends Composite implements TakesValue<Object>,
IsNestedModel,
NeedsFlush { public void render(FormRenderingContext renderingContext) { formRenderer.render(renderingContext); } void render(FormRenderingContext renderingContext); @Override Object getValue(); @Override void setValue(Object value); @Override void clear(); @Override void flush(); @Override void addFieldChangeHandler(FieldChangeHandler handler); void setReadOnly(boolean readOnly); boolean isValid(); } |
@Test public void testGetValue() { subFormWidget.getValue(); verify(formRenderer).getModel(); } | @Override public Object getValue() { return formRenderer.getModel(); } | SubFormWidget extends Composite implements TakesValue<Object>,
IsNestedModel,
NeedsFlush { @Override public Object getValue() { return formRenderer.getModel(); } } | SubFormWidget extends Composite implements TakesValue<Object>,
IsNestedModel,
NeedsFlush { @Override public Object getValue() { return formRenderer.getModel(); } } | SubFormWidget extends Composite implements TakesValue<Object>,
IsNestedModel,
NeedsFlush { @Override public Object getValue() { return formRenderer.getModel(); } void render(FormRenderingContext renderingContext); @Override Object getValue(); @Override void setValue(Object value); @Override void clear(); @Override void flush(); @Override void addFieldChangeHandler(FieldChangeHandler handler); void setReadOnly(boolean readOnly); boolean isValid(); } | SubFormWidget extends Composite implements TakesValue<Object>,
IsNestedModel,
NeedsFlush { @Override public Object getValue() { return formRenderer.getModel(); } void render(FormRenderingContext renderingContext); @Override Object getValue(); @Override void setValue(Object value); @Override void clear(); @Override void flush(); @Override void addFieldChangeHandler(FieldChangeHandler handler); void setReadOnly(boolean readOnly); boolean isValid(); } |
@Test public void testSetValue() { final Object value = new Object(); subFormWidget.setValue(value); verify(formRenderer).bind(same(value)); } | @Override public void setValue(Object value) { formRenderer.bind(value); } | SubFormWidget extends Composite implements TakesValue<Object>,
IsNestedModel,
NeedsFlush { @Override public void setValue(Object value) { formRenderer.bind(value); } } | SubFormWidget extends Composite implements TakesValue<Object>,
IsNestedModel,
NeedsFlush { @Override public void setValue(Object value) { formRenderer.bind(value); } } | SubFormWidget extends Composite implements TakesValue<Object>,
IsNestedModel,
NeedsFlush { @Override public void setValue(Object value) { formRenderer.bind(value); } void render(FormRenderingContext renderingContext); @Override Object getValue(); @Override void setValue(Object value); @Override void clear(); @Override void flush(); @Override void addFieldChangeHandler(FieldChangeHandler handler); void setReadOnly(boolean readOnly); boolean isValid(); } | SubFormWidget extends Composite implements TakesValue<Object>,
IsNestedModel,
NeedsFlush { @Override public void setValue(Object value) { formRenderer.bind(value); } void render(FormRenderingContext renderingContext); @Override Object getValue(); @Override void setValue(Object value); @Override void clear(); @Override void flush(); @Override void addFieldChangeHandler(FieldChangeHandler handler); void setReadOnly(boolean readOnly); boolean isValid(); } |
@Test public void testClear() { subFormWidget.clear(); verify(formRenderer).unBind(); } | @Override public void clear() { formRenderer.unBind(); } | SubFormWidget extends Composite implements TakesValue<Object>,
IsNestedModel,
NeedsFlush { @Override public void clear() { formRenderer.unBind(); } } | SubFormWidget extends Composite implements TakesValue<Object>,
IsNestedModel,
NeedsFlush { @Override public void clear() { formRenderer.unBind(); } } | SubFormWidget extends Composite implements TakesValue<Object>,
IsNestedModel,
NeedsFlush { @Override public void clear() { formRenderer.unBind(); } void render(FormRenderingContext renderingContext); @Override Object getValue(); @Override void setValue(Object value); @Override void clear(); @Override void flush(); @Override void addFieldChangeHandler(FieldChangeHandler handler); void setReadOnly(boolean readOnly); boolean isValid(); } | SubFormWidget extends Composite implements TakesValue<Object>,
IsNestedModel,
NeedsFlush { @Override public void clear() { formRenderer.unBind(); } void render(FormRenderingContext renderingContext); @Override Object getValue(); @Override void setValue(Object value); @Override void clear(); @Override void flush(); @Override void addFieldChangeHandler(FieldChangeHandler handler); void setReadOnly(boolean readOnly); boolean isValid(); } |
@Test public void testFlush() { subFormWidget.flush(); verify(formRenderer).flush(); } | @Override public void flush() { formRenderer.flush(); } | SubFormWidget extends Composite implements TakesValue<Object>,
IsNestedModel,
NeedsFlush { @Override public void flush() { formRenderer.flush(); } } | SubFormWidget extends Composite implements TakesValue<Object>,
IsNestedModel,
NeedsFlush { @Override public void flush() { formRenderer.flush(); } } | SubFormWidget extends Composite implements TakesValue<Object>,
IsNestedModel,
NeedsFlush { @Override public void flush() { formRenderer.flush(); } void render(FormRenderingContext renderingContext); @Override Object getValue(); @Override void setValue(Object value); @Override void clear(); @Override void flush(); @Override void addFieldChangeHandler(FieldChangeHandler handler); void setReadOnly(boolean readOnly); boolean isValid(); } | SubFormWidget extends Composite implements TakesValue<Object>,
IsNestedModel,
NeedsFlush { @Override public void flush() { formRenderer.flush(); } void render(FormRenderingContext renderingContext); @Override Object getValue(); @Override void setValue(Object value); @Override void clear(); @Override void flush(); @Override void addFieldChangeHandler(FieldChangeHandler handler); void setReadOnly(boolean readOnly); boolean isValid(); } |
@Test public void testAddFieldChangeHandler() { FieldChangeHandler handler = mock(FieldChangeHandler.class); subFormWidget.addFieldChangeHandler(handler); verify(formRenderer).addFieldChangeHandler(same(handler)); } | @Override public void addFieldChangeHandler(FieldChangeHandler handler) { formRenderer.addFieldChangeHandler(handler); } | SubFormWidget extends Composite implements TakesValue<Object>,
IsNestedModel,
NeedsFlush { @Override public void addFieldChangeHandler(FieldChangeHandler handler) { formRenderer.addFieldChangeHandler(handler); } } | SubFormWidget extends Composite implements TakesValue<Object>,
IsNestedModel,
NeedsFlush { @Override public void addFieldChangeHandler(FieldChangeHandler handler) { formRenderer.addFieldChangeHandler(handler); } } | SubFormWidget extends Composite implements TakesValue<Object>,
IsNestedModel,
NeedsFlush { @Override public void addFieldChangeHandler(FieldChangeHandler handler) { formRenderer.addFieldChangeHandler(handler); } void render(FormRenderingContext renderingContext); @Override Object getValue(); @Override void setValue(Object value); @Override void clear(); @Override void flush(); @Override void addFieldChangeHandler(FieldChangeHandler handler); void setReadOnly(boolean readOnly); boolean isValid(); } | SubFormWidget extends Composite implements TakesValue<Object>,
IsNestedModel,
NeedsFlush { @Override public void addFieldChangeHandler(FieldChangeHandler handler) { formRenderer.addFieldChangeHandler(handler); } void render(FormRenderingContext renderingContext); @Override Object getValue(); @Override void setValue(Object value); @Override void clear(); @Override void flush(); @Override void addFieldChangeHandler(FieldChangeHandler handler); void setReadOnly(boolean readOnly); boolean isValid(); } |
@Test public void testSetReadOnly() { subFormWidget.setReadOnly(true); verify(formRenderer).switchToMode(eq(RenderMode.READ_ONLY_MODE)); subFormWidget.setReadOnly(false); verify(formRenderer).switchToMode(eq(RenderMode.EDIT_MODE)); } | public void setReadOnly(boolean readOnly) { formRenderer.switchToMode(readOnly ? RenderMode.READ_ONLY_MODE : RenderMode.EDIT_MODE); } | SubFormWidget extends Composite implements TakesValue<Object>,
IsNestedModel,
NeedsFlush { public void setReadOnly(boolean readOnly) { formRenderer.switchToMode(readOnly ? RenderMode.READ_ONLY_MODE : RenderMode.EDIT_MODE); } } | SubFormWidget extends Composite implements TakesValue<Object>,
IsNestedModel,
NeedsFlush { public void setReadOnly(boolean readOnly) { formRenderer.switchToMode(readOnly ? RenderMode.READ_ONLY_MODE : RenderMode.EDIT_MODE); } } | SubFormWidget extends Composite implements TakesValue<Object>,
IsNestedModel,
NeedsFlush { public void setReadOnly(boolean readOnly) { formRenderer.switchToMode(readOnly ? RenderMode.READ_ONLY_MODE : RenderMode.EDIT_MODE); } void render(FormRenderingContext renderingContext); @Override Object getValue(); @Override void setValue(Object value); @Override void clear(); @Override void flush(); @Override void addFieldChangeHandler(FieldChangeHandler handler); void setReadOnly(boolean readOnly); boolean isValid(); } | SubFormWidget extends Composite implements TakesValue<Object>,
IsNestedModel,
NeedsFlush { public void setReadOnly(boolean readOnly) { formRenderer.switchToMode(readOnly ? RenderMode.READ_ONLY_MODE : RenderMode.EDIT_MODE); } void render(FormRenderingContext renderingContext); @Override Object getValue(); @Override void setValue(Object value); @Override void clear(); @Override void flush(); @Override void addFieldChangeHandler(FieldChangeHandler handler); void setReadOnly(boolean readOnly); boolean isValid(); } |
@Test public void testIsValid() { subFormWidget.isValid(); verify(formRenderer).isValid(); } | public boolean isValid() { return formRenderer.isValid(); } | SubFormWidget extends Composite implements TakesValue<Object>,
IsNestedModel,
NeedsFlush { public boolean isValid() { return formRenderer.isValid(); } } | SubFormWidget extends Composite implements TakesValue<Object>,
IsNestedModel,
NeedsFlush { public boolean isValid() { return formRenderer.isValid(); } } | SubFormWidget extends Composite implements TakesValue<Object>,
IsNestedModel,
NeedsFlush { public boolean isValid() { return formRenderer.isValid(); } void render(FormRenderingContext renderingContext); @Override Object getValue(); @Override void setValue(Object value); @Override void clear(); @Override void flush(); @Override void addFieldChangeHandler(FieldChangeHandler handler); void setReadOnly(boolean readOnly); boolean isValid(); } | SubFormWidget extends Composite implements TakesValue<Object>,
IsNestedModel,
NeedsFlush { public boolean isValid() { return formRenderer.isValid(); } void render(FormRenderingContext renderingContext); @Override Object getValue(); @Override void setValue(Object value); @Override void clear(); @Override void flush(); @Override void addFieldChangeHandler(FieldChangeHandler handler); void setReadOnly(boolean readOnly); boolean isValid(); } |
@Test public void testGetFormGroup() { renderer.getFormGroup(RenderMode.EDIT_MODE); verify(formGroupsInstance).get(); multipleSubFormWidget.config(any(), any()); verify(formGroup).render(any(), any()); } | @Override protected FormGroup getFormGroup(RenderMode renderMode) { FieldSetFormGroup formGroup = formGroupsInstance.get(); multipleSubFormWidget.config(field, renderingContext); formGroup.render(multipleSubFormWidget, field); return formGroup; } | MultipleSubFormFieldRenderer extends FieldRenderer<MultipleSubFormFieldDefinition, FieldSetFormGroup> { @Override protected FormGroup getFormGroup(RenderMode renderMode) { FieldSetFormGroup formGroup = formGroupsInstance.get(); multipleSubFormWidget.config(field, renderingContext); formGroup.render(multipleSubFormWidget, field); return formGroup; } } | MultipleSubFormFieldRenderer extends FieldRenderer<MultipleSubFormFieldDefinition, FieldSetFormGroup> { @Override protected FormGroup getFormGroup(RenderMode renderMode) { FieldSetFormGroup formGroup = formGroupsInstance.get(); multipleSubFormWidget.config(field, renderingContext); formGroup.render(multipleSubFormWidget, field); return formGroup; } } | MultipleSubFormFieldRenderer extends FieldRenderer<MultipleSubFormFieldDefinition, FieldSetFormGroup> { @Override protected FormGroup getFormGroup(RenderMode renderMode) { FieldSetFormGroup formGroup = formGroupsInstance.get(); multipleSubFormWidget.config(field, renderingContext); formGroup.render(multipleSubFormWidget, field); return formGroup; } @Override String getName(); } | MultipleSubFormFieldRenderer extends FieldRenderer<MultipleSubFormFieldDefinition, FieldSetFormGroup> { @Override protected FormGroup getFormGroup(RenderMode renderMode) { FieldSetFormGroup formGroup = formGroupsInstance.get(); multipleSubFormWidget.config(field, renderingContext); formGroup.render(multipleSubFormWidget, field); return formGroup; } @Override String getName(); } |
@Test public void testAddDividerDragHandler() { view.addDividerDragHandler(dragHandler); final HandlerManager handlerManager = view.getHandlerManager(); assertThat(handlerManager.isEventHandled(MoveDividerStartEvent.TYPE)).isTrue(); assertThat(handlerManager.isEventHandled(MoveDividerStepEvent.TYPE)).isTrue(); assertThat(handlerManager.isEventHandled(MoveDividerEndEvent.TYPE)).isTrue(); assertThat(handlerManager.getHandlerCount(MoveDividerStartEvent.TYPE)).isEqualTo(1); assertThat(handlerManager.getHandlerCount(MoveDividerStepEvent.TYPE)).isEqualTo(1); assertThat(handlerManager.getHandlerCount(MoveDividerEndEvent.TYPE)).isEqualTo(1); handlerManager.getHandler(MoveDividerStartEvent.TYPE, 0).onMoveDividerStart(new MoveDividerStartEvent(view, nodeDragStartEvent)); verify(dragHandler).start(any(DragEvent.class)); handlerManager.getHandler(MoveDividerStepEvent.TYPE, 0).onMoveDividerStep(new MoveDividerStepEvent(view, nodeDragMoveEvent)); verify(dragHandler).handle(any(DragEvent.class)); handlerManager.getHandler(MoveDividerEndEvent.TYPE, 0).onMoveDividerEnd(new MoveDividerEndEvent(view, nodeDragEndEvent)); verify(dragHandler).end(any(DragEvent.class)); } | public DecisionServiceSVGShapeView addDividerDragHandler(final DragHandler dragHandler) { final HandlerManager handlerManager = getHandlerManager(); final HandlerRegistration dragStartRegistration = handlerManager.addHandler(MoveDividerStartEvent.TYPE, event -> dragHandler.start(buildDragEvent(event))); final HandlerRegistration dragStepRegistration = handlerManager.addHandler(MoveDividerStepEvent.TYPE, event -> dragHandler.handle(buildDragEvent(event))); final HandlerRegistration dragEndRegistration = handlerManager.addHandler(MoveDividerEndEvent.TYPE, event -> dragHandler.end(buildDragEvent(event))); final HandlerRegistration[] registrations = new HandlerRegistration[]{dragStartRegistration, dragStepRegistration, dragEndRegistration}; getEventHandlerManager().addHandlersRegistration(ViewEventType.DRAG, registrations); return this; } | DecisionServiceSVGShapeView extends SVGShapeViewImpl { public DecisionServiceSVGShapeView addDividerDragHandler(final DragHandler dragHandler) { final HandlerManager handlerManager = getHandlerManager(); final HandlerRegistration dragStartRegistration = handlerManager.addHandler(MoveDividerStartEvent.TYPE, event -> dragHandler.start(buildDragEvent(event))); final HandlerRegistration dragStepRegistration = handlerManager.addHandler(MoveDividerStepEvent.TYPE, event -> dragHandler.handle(buildDragEvent(event))); final HandlerRegistration dragEndRegistration = handlerManager.addHandler(MoveDividerEndEvent.TYPE, event -> dragHandler.end(buildDragEvent(event))); final HandlerRegistration[] registrations = new HandlerRegistration[]{dragStartRegistration, dragStepRegistration, dragEndRegistration}; getEventHandlerManager().addHandlersRegistration(ViewEventType.DRAG, registrations); return this; } } | DecisionServiceSVGShapeView extends SVGShapeViewImpl { public DecisionServiceSVGShapeView addDividerDragHandler(final DragHandler dragHandler) { final HandlerManager handlerManager = getHandlerManager(); final HandlerRegistration dragStartRegistration = handlerManager.addHandler(MoveDividerStartEvent.TYPE, event -> dragHandler.start(buildDragEvent(event))); final HandlerRegistration dragStepRegistration = handlerManager.addHandler(MoveDividerStepEvent.TYPE, event -> dragHandler.handle(buildDragEvent(event))); final HandlerRegistration dragEndRegistration = handlerManager.addHandler(MoveDividerEndEvent.TYPE, event -> dragHandler.end(buildDragEvent(event))); final HandlerRegistration[] registrations = new HandlerRegistration[]{dragStartRegistration, dragStepRegistration, dragEndRegistration}; getEventHandlerManager().addHandlersRegistration(ViewEventType.DRAG, registrations); return this; } DecisionServiceSVGShapeView(final String name,
final SVGPrimitiveShape svgPrimitive,
final double width,
final double height,
final boolean resizable); } | DecisionServiceSVGShapeView extends SVGShapeViewImpl { public DecisionServiceSVGShapeView addDividerDragHandler(final DragHandler dragHandler) { final HandlerManager handlerManager = getHandlerManager(); final HandlerRegistration dragStartRegistration = handlerManager.addHandler(MoveDividerStartEvent.TYPE, event -> dragHandler.start(buildDragEvent(event))); final HandlerRegistration dragStepRegistration = handlerManager.addHandler(MoveDividerStepEvent.TYPE, event -> dragHandler.handle(buildDragEvent(event))); final HandlerRegistration dragEndRegistration = handlerManager.addHandler(MoveDividerEndEvent.TYPE, event -> dragHandler.end(buildDragEvent(event))); final HandlerRegistration[] registrations = new HandlerRegistration[]{dragStartRegistration, dragStepRegistration, dragEndRegistration}; getEventHandlerManager().addHandlersRegistration(ViewEventType.DRAG, registrations); return this; } DecisionServiceSVGShapeView(final String name,
final SVGPrimitiveShape svgPrimitive,
final double width,
final double height,
final boolean resizable); DecisionServiceSVGShapeView addDividerDragHandler(final DragHandler dragHandler); double getDividerLineY(); void setDividerLineY(final double y); @Override //Override to increase visibility for Unit Tests HandlerManager getHandlerManager(); @Override void destroy(); } | DecisionServiceSVGShapeView extends SVGShapeViewImpl { public DecisionServiceSVGShapeView addDividerDragHandler(final DragHandler dragHandler) { final HandlerManager handlerManager = getHandlerManager(); final HandlerRegistration dragStartRegistration = handlerManager.addHandler(MoveDividerStartEvent.TYPE, event -> dragHandler.start(buildDragEvent(event))); final HandlerRegistration dragStepRegistration = handlerManager.addHandler(MoveDividerStepEvent.TYPE, event -> dragHandler.handle(buildDragEvent(event))); final HandlerRegistration dragEndRegistration = handlerManager.addHandler(MoveDividerEndEvent.TYPE, event -> dragHandler.end(buildDragEvent(event))); final HandlerRegistration[] registrations = new HandlerRegistration[]{dragStartRegistration, dragStepRegistration, dragEndRegistration}; getEventHandlerManager().addHandlersRegistration(ViewEventType.DRAG, registrations); return this; } DecisionServiceSVGShapeView(final String name,
final SVGPrimitiveShape svgPrimitive,
final double width,
final double height,
final boolean resizable); DecisionServiceSVGShapeView addDividerDragHandler(final DragHandler dragHandler); double getDividerLineY(); void setDividerLineY(final double y); @Override //Override to increase visibility for Unit Tests HandlerManager getHandlerManager(); @Override void destroy(); } |
@Test public void testGetFormGroup() { renderer.getFormGroup(RenderMode.EDIT_MODE); verify(formGroupsInstance).get(); verify(decimalBox).setId(any()); verify(decimalBox).setPlaceholder(eq(fieldDefinition.getPlaceHolder())); verify(decimalBox).setMaxLength(eq(fieldDefinition.getMaxLength())); verify(decimalBox).setEnabled(eq(!fieldDefinition.getReadOnly())); verify(decimalBox).asWidget(); verify(formGroup).render(anyString(), any(), eq(fieldDefinition)); } | @Override protected FormGroup getFormGroup(RenderMode renderMode) { DefaultFormGroup formGroup = formGroupsInstance.get(); if (renderMode.equals(RenderMode.PRETTY_MODE)) { formGroup.render(new HTML(), field); } else { String inputId = generateUniqueId(); decimalBox.setId(inputId); decimalBox.setPlaceholder(field.getPlaceHolder()); decimalBox.setMaxLength(field.getMaxLength()); decimalBox.setEnabled(!field.getReadOnly()); formGroup.render(inputId, decimalBox.asWidget(), field); registerFieldRendererPart(decimalBox); } return formGroup; } | DecimalBoxFieldRenderer extends FieldRenderer<DecimalBoxFieldDefinition, DefaultFormGroup> implements RequiresValueConverter { @Override protected FormGroup getFormGroup(RenderMode renderMode) { DefaultFormGroup formGroup = formGroupsInstance.get(); if (renderMode.equals(RenderMode.PRETTY_MODE)) { formGroup.render(new HTML(), field); } else { String inputId = generateUniqueId(); decimalBox.setId(inputId); decimalBox.setPlaceholder(field.getPlaceHolder()); decimalBox.setMaxLength(field.getMaxLength()); decimalBox.setEnabled(!field.getReadOnly()); formGroup.render(inputId, decimalBox.asWidget(), field); registerFieldRendererPart(decimalBox); } return formGroup; } } | DecimalBoxFieldRenderer extends FieldRenderer<DecimalBoxFieldDefinition, DefaultFormGroup> implements RequiresValueConverter { @Override protected FormGroup getFormGroup(RenderMode renderMode) { DefaultFormGroup formGroup = formGroupsInstance.get(); if (renderMode.equals(RenderMode.PRETTY_MODE)) { formGroup.render(new HTML(), field); } else { String inputId = generateUniqueId(); decimalBox.setId(inputId); decimalBox.setPlaceholder(field.getPlaceHolder()); decimalBox.setMaxLength(field.getMaxLength()); decimalBox.setEnabled(!field.getReadOnly()); formGroup.render(inputId, decimalBox.asWidget(), field); registerFieldRendererPart(decimalBox); } return formGroup; } @Inject DecimalBoxFieldRenderer(DecimalBox decimalBox); } | DecimalBoxFieldRenderer extends FieldRenderer<DecimalBoxFieldDefinition, DefaultFormGroup> implements RequiresValueConverter { @Override protected FormGroup getFormGroup(RenderMode renderMode) { DefaultFormGroup formGroup = formGroupsInstance.get(); if (renderMode.equals(RenderMode.PRETTY_MODE)) { formGroup.render(new HTML(), field); } else { String inputId = generateUniqueId(); decimalBox.setId(inputId); decimalBox.setPlaceholder(field.getPlaceHolder()); decimalBox.setMaxLength(field.getMaxLength()); decimalBox.setEnabled(!field.getReadOnly()); formGroup.render(inputId, decimalBox.asWidget(), field); registerFieldRendererPart(decimalBox); } return formGroup; } @Inject DecimalBoxFieldRenderer(DecimalBox decimalBox); @Override String getName(); @Override Converter getConverter(); } | DecimalBoxFieldRenderer extends FieldRenderer<DecimalBoxFieldDefinition, DefaultFormGroup> implements RequiresValueConverter { @Override protected FormGroup getFormGroup(RenderMode renderMode) { DefaultFormGroup formGroup = formGroupsInstance.get(); if (renderMode.equals(RenderMode.PRETTY_MODE)) { formGroup.render(new HTML(), field); } else { String inputId = generateUniqueId(); decimalBox.setId(inputId); decimalBox.setPlaceholder(field.getPlaceHolder()); decimalBox.setMaxLength(field.getMaxLength()); decimalBox.setEnabled(!field.getReadOnly()); formGroup.render(inputId, decimalBox.asWidget(), field); registerFieldRendererPart(decimalBox); } return formGroup; } @Inject DecimalBoxFieldRenderer(DecimalBox decimalBox); @Override String getName(); @Override Converter getConverter(); } |
@Test public void testGetConverter() { checkConverter(Float.class.getName(), FloatToDoubleConverter.class); checkConverter(float.class.getName(), FloatToDoubleConverter.class); checkConverter(BigDecimal.class.getName(), BigDecimalToDoubleConverter.class); } | @Override public Converter getConverter() { return ValueConvertersFactory.getConverterForType(field.getStandaloneClassName()); } | DecimalBoxFieldRenderer extends FieldRenderer<DecimalBoxFieldDefinition, DefaultFormGroup> implements RequiresValueConverter { @Override public Converter getConverter() { return ValueConvertersFactory.getConverterForType(field.getStandaloneClassName()); } } | DecimalBoxFieldRenderer extends FieldRenderer<DecimalBoxFieldDefinition, DefaultFormGroup> implements RequiresValueConverter { @Override public Converter getConverter() { return ValueConvertersFactory.getConverterForType(field.getStandaloneClassName()); } @Inject DecimalBoxFieldRenderer(DecimalBox decimalBox); } | DecimalBoxFieldRenderer extends FieldRenderer<DecimalBoxFieldDefinition, DefaultFormGroup> implements RequiresValueConverter { @Override public Converter getConverter() { return ValueConvertersFactory.getConverterForType(field.getStandaloneClassName()); } @Inject DecimalBoxFieldRenderer(DecimalBox decimalBox); @Override String getName(); @Override Converter getConverter(); } | DecimalBoxFieldRenderer extends FieldRenderer<DecimalBoxFieldDefinition, DefaultFormGroup> implements RequiresValueConverter { @Override public Converter getConverter() { return ValueConvertersFactory.getConverterForType(field.getStandaloneClassName()); } @Inject DecimalBoxFieldRenderer(DecimalBox decimalBox); @Override String getName(); @Override Converter getConverter(); } |
@Test public void testGetFormGroup() { renderer.getFormGroup(RenderMode.EDIT_MODE); verify(formGroupsInstance).get(); verify(integerBox).setId(any()); verify(integerBox).setPlaceholder(eq(fieldDefinition.getPlaceHolder())); verify(integerBox).setMaxLength(eq(fieldDefinition.getMaxLength())); verify(integerBox).setEnabled(eq(!fieldDefinition.getReadOnly())); verify(integerBox).asWidget(); verify(formGroup).render(anyString(), any(), eq(fieldDefinition)); } | @Override protected FormGroup getFormGroup(RenderMode renderMode) { Widget widget; String inputId = generateUniqueId(); if (renderMode.equals(RenderMode.PRETTY_MODE)) { widget = new HTML(); widget.getElement().setId(inputId); } else { integerBox.setId(inputId); integerBox.setPlaceholder(field.getPlaceHolder()); integerBox.setMaxLength(field.getMaxLength()); integerBox.setEnabled(!field.getReadOnly()); widget = integerBox.asWidget(); } DefaultFormGroup formGroup = formGroupsInstance.get(); formGroup.render(inputId, widget, field); registerFieldRendererPart(widget); return formGroup; } | IntegerBoxFieldRenderer extends FieldRenderer<IntegerBoxFieldDefinition, DefaultFormGroup> implements RequiresValueConverter { @Override protected FormGroup getFormGroup(RenderMode renderMode) { Widget widget; String inputId = generateUniqueId(); if (renderMode.equals(RenderMode.PRETTY_MODE)) { widget = new HTML(); widget.getElement().setId(inputId); } else { integerBox.setId(inputId); integerBox.setPlaceholder(field.getPlaceHolder()); integerBox.setMaxLength(field.getMaxLength()); integerBox.setEnabled(!field.getReadOnly()); widget = integerBox.asWidget(); } DefaultFormGroup formGroup = formGroupsInstance.get(); formGroup.render(inputId, widget, field); registerFieldRendererPart(widget); return formGroup; } } | IntegerBoxFieldRenderer extends FieldRenderer<IntegerBoxFieldDefinition, DefaultFormGroup> implements RequiresValueConverter { @Override protected FormGroup getFormGroup(RenderMode renderMode) { Widget widget; String inputId = generateUniqueId(); if (renderMode.equals(RenderMode.PRETTY_MODE)) { widget = new HTML(); widget.getElement().setId(inputId); } else { integerBox.setId(inputId); integerBox.setPlaceholder(field.getPlaceHolder()); integerBox.setMaxLength(field.getMaxLength()); integerBox.setEnabled(!field.getReadOnly()); widget = integerBox.asWidget(); } DefaultFormGroup formGroup = formGroupsInstance.get(); formGroup.render(inputId, widget, field); registerFieldRendererPart(widget); return formGroup; } @Inject IntegerBoxFieldRenderer(IntegerBox integerBox); } | IntegerBoxFieldRenderer extends FieldRenderer<IntegerBoxFieldDefinition, DefaultFormGroup> implements RequiresValueConverter { @Override protected FormGroup getFormGroup(RenderMode renderMode) { Widget widget; String inputId = generateUniqueId(); if (renderMode.equals(RenderMode.PRETTY_MODE)) { widget = new HTML(); widget.getElement().setId(inputId); } else { integerBox.setId(inputId); integerBox.setPlaceholder(field.getPlaceHolder()); integerBox.setMaxLength(field.getMaxLength()); integerBox.setEnabled(!field.getReadOnly()); widget = integerBox.asWidget(); } DefaultFormGroup formGroup = formGroupsInstance.get(); formGroup.render(inputId, widget, field); registerFieldRendererPart(widget); return formGroup; } @Inject IntegerBoxFieldRenderer(IntegerBox integerBox); @Override String getName(); @Override Converter getConverter(); } | IntegerBoxFieldRenderer extends FieldRenderer<IntegerBoxFieldDefinition, DefaultFormGroup> implements RequiresValueConverter { @Override protected FormGroup getFormGroup(RenderMode renderMode) { Widget widget; String inputId = generateUniqueId(); if (renderMode.equals(RenderMode.PRETTY_MODE)) { widget = new HTML(); widget.getElement().setId(inputId); } else { integerBox.setId(inputId); integerBox.setPlaceholder(field.getPlaceHolder()); integerBox.setMaxLength(field.getMaxLength()); integerBox.setEnabled(!field.getReadOnly()); widget = integerBox.asWidget(); } DefaultFormGroup formGroup = formGroupsInstance.get(); formGroup.render(inputId, widget, field); registerFieldRendererPart(widget); return formGroup; } @Inject IntegerBoxFieldRenderer(IntegerBox integerBox); @Override String getName(); @Override Converter getConverter(); } |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.