org.squashtest.tm.service.requirement

Interface RequirementLibraryNavigationService

All Superinterfaces:

LibraryNavigationService<org.squashtest.tm.domain.requirement.RequirementLibrary,org.squashtest.tm.domain.requirement.RequirementFolder,org.squashtest.tm.domain.requirement.RequirementLibraryNode>, RequirementLibraryFinderService

All Known Implementing Classes:

RequirementLibraryNavigationServiceImpl

public interface RequirementLibraryNavigationService
extends LibraryNavigationService<org.squashtest.tm.domain.requirement.RequirementLibrary,org.squashtest.tm.domain.requirement.RequirementFolder,org.squashtest.tm.domain.requirement.RequirementLibraryNode>, RequirementLibraryFinderService

Field Summary

Fields

Modifier and Type	Field and Description
static String	DESTINATION_ID
static String	NODE_IDS
static String	REQUIREMENT_ID
static String	SOURCE_NODES_IDS
static String	TARGET_ID
static String	TARGET_IDS

Method Summary

Methods

Modifier and Type	Method and Description
org.squashtest.tm.domain.requirement.Requirement	addRequirementToRequirement(long requirementId, org.squashtest.tm.domain.requirement.NewRequirementVersionDto newRequirement, List<Long> milestoneIds) Same than {@link #addRequirementToRequirementLibrary(long, NewRequirementVersionDto, List), except that the requirement will be added to the given parent requirement.
org.squashtest.tm.domain.requirement.Requirement	addRequirementToRequirement(long requirementId, org.squashtest.tm.domain.requirement.Requirement newRequirement, List<Long> milestoneIds) Same than addRequirementToRequirementLibrary(long, Requirement, List), except that the requirement will be added to the given parent requirement.
org.squashtest.tm.domain.requirement.Requirement	addRequirementToRequirementFolder(long folderId, org.squashtest.tm.domain.requirement.NewRequirementVersionDto newRequirement, List<Long> milestoneIds) Same than {@link #addRequirementToRequirementLibrary(long, NewRequirementVersionDto, List), except that the requirement will be added to the given folder.
org.squashtest.tm.domain.requirement.Requirement	addRequirementToRequirementFolder(long folderId, org.squashtest.tm.domain.requirement.Requirement requirement, List<Long> milestoneIds) Deprecated. Looks like this methid is useless
org.squashtest.tm.domain.requirement.Requirement	addRequirementToRequirementLibrary(long libraryId, org.squashtest.tm.domain.requirement.NewRequirementVersionDto newRequirement, List<Long> milestoneIds) Given a DTO that eventually generates a RequirementVersion, will create a Requirement using this version then add it to the given library with and bind it to the given milestones.
org.squashtest.tm.domain.requirement.Requirement	addRequirementToRequirementLibrary(long libraryId, org.squashtest.tm.domain.requirement.Requirement requirement, List<Long> milestoneIds) Deprecated. Looks like this method is useless
void	changeCurrentVersionNumber(org.squashtest.tm.domain.requirement.Requirement requirement, Integer noVersion) Change the current version number.
List<org.squashtest.tm.domain.requirement.RequirementLibraryNode>	copyNodesToFolder(long destinationId, Long[] sourceNodesIds) will create a deep copy of the given LibraryNodes, paste them in the destination folder, and return the copies.
List<org.squashtest.tm.domain.requirement.RequirementLibraryNode>	copyNodesToLibrary(long destinationId, Long[] targetId) same, when the destination is a Library.
List<org.squashtest.tm.domain.requirement.Requirement>	copyNodesToRequirement(long requirementId, Long[] sourceNodesIds)
OperationReport	deleteNodes(List<Long> targetIds) that method should delete the nodes.
File	exportRequirementAsExcel(List<Long> libraryIds, List<Long> nodeIds, boolean keepRteFormat, org.springframework.context.MessageSource messageSource) Generate a xls file to export requirements
List<Long>	findAllRequirementIdsInMilestone(org.squashtest.tm.domain.milestone.Milestone activeMilestone)
List<org.squashtest.tm.domain.requirement.Requirement>	findChildrenRequirements(long requirementId)
List<String>	findNamesInLibraryStartingWith(long libraryId, String nameStart)
List<String>	findNamesInNodeStartingWith(long folderId, String nameStart)
org.squashtest.tm.domain.requirement.Requirement	findRequirement(long reqId)
org.squashtest.tm.domain.requirement.RequirementLibraryNode	findRequirementLibraryNodeById(Long id)
List<org.squashtest.tm.domain.requirement.ExportRequirementData>	findRequirementsToExportFromLibrary(List<Long> libraryIds) Will find all requirements found in the given projects and return their information as a list of ExportRequirementData
List<org.squashtest.tm.domain.requirement.ExportRequirementData>	findRequirementsToExportFromNodes(List<Long> nodesIds) Will find all requirements of the given ids and contained in folders of the given ids, and return their information as a list of ExportRequirementData
List<String>	getParentNodesAsStringList(Long elementId)
ImportLog	importExcelRequirement(File xls)
void	initCUFvalues(org.squashtest.tm.domain.requirement.RequirementVersion reqVersion, Map<Long,org.squashtest.tm.domain.customfield.RawValue> initialCustomFieldValues) Initialize the CUF values for a RequirementVersion
Long	mkdirs(String folderpath) Create a hierarchy of requirement library node.
void	moveNodesToFolder(long destinationId, Long[] targetId)
void	moveNodesToFolder(long destinationId, Long[] targetId, int position)
void	moveNodesToLibrary(long destinationId, Long[] targetId)
void	moveNodesToLibrary(long destinationId, Long[] targetId, int position)
void	moveNodesToRequirement(long requirementId, Long[] nodeIds)
void	moveNodesToRequirement(long requirementId, Long[] nodeIds, int position)
File	searchExportRequirementAsExcel(List<Long> nodeIds, boolean keepRteFormat, org.springframework.context.MessageSource messageSource) Generate a xls file to export requirements from research screen
ImportLog	simulateImportExcelRequirement(File xls)

Methods inherited from interface org.squashtest.tm.service.library.LibraryNavigationService

addFolderToFolder, addFolderToLibrary, findCreatableLibrary, findFolder, findFolderContent, findLibrary, findLibraryOfRootNodeIfExist, findLibraryRootContent, findParentIfExists, simulateDeletion

Methods inherited from interface org.squashtest.tm.service.requirement.RequirementLibraryFinderService

findLinkableRequirementLibraries, findNodeIdByPath, findNodeIdByRemoteKey, findNodeIdsByPath, findNodeIdsByRemoteKeys, findRequirementIdsFromSelection, getPathAsString, getStatisticsForSelection

Field Detail

REQUIREMENT_ID

static final String REQUIREMENT_ID

See Also:

Constant Field Values

NODE_IDS

static final String NODE_IDS

See Also:

Constant Field Values

SOURCE_NODES_IDS

static final String SOURCE_NODES_IDS

See Also:

Constant Field Values

DESTINATION_ID

static final String DESTINATION_ID

See Also:

Constant Field Values

TARGET_ID

static final String TARGET_ID

See Also:

Constant Field Values

TARGET_IDS

static final String TARGET_IDS

See Also:

Constant Field Values

Method Detail

addRequirementToRequirementLibrary

@Deprecated
org.squashtest.tm.domain.requirement.Requirement addRequirementToRequirementLibrary(long libraryId,
                                                                                             @NotNull
                                                                                             org.squashtest.tm.domain.requirement.Requirement requirement,
                                                                                             List<Long> milestoneIds)

Deprecated. Looks like this method is useless

Will add a Requirement at the root of the given library and bind it to the given milestones. The custom fields for this requirement will be created with their default value.

addRequirementToRequirementLibrary

org.squashtest.tm.domain.requirement.Requirement addRequirementToRequirementLibrary(long libraryId,
                                                                                  @NotNull
                                                                                  org.squashtest.tm.domain.requirement.NewRequirementVersionDto newRequirement,
                                                                                  List<Long> milestoneIds)

Given a DTO that eventually generates a RequirementVersion, will create a Requirement using this version then add it to the given library with and bind it to the given milestones. The DTO may hold additional information for initialization of the custom fields. On the other hand this method is not suitable for creation of synchronized Requirements.

addRequirementToRequirementFolder

@Deprecated
org.squashtest.tm.domain.requirement.Requirement addRequirementToRequirementFolder(long folderId,
                                                                                            @NotNull
                                                                                            org.squashtest.tm.domain.requirement.Requirement requirement,
                                                                                            List<Long> milestoneIds)

Deprecated. Looks like this methid is useless

Same than addRequirementToRequirementLibrary(long, Requirement, List), except that the requirement will be added to the given folder.

addRequirementToRequirementFolder

org.squashtest.tm.domain.requirement.Requirement addRequirementToRequirementFolder(long folderId,
                                                                                 @NotNull
                                                                                 org.squashtest.tm.domain.requirement.NewRequirementVersionDto newRequirement,
                                                                                 List<Long> milestoneIds)

Same than {@link #addRequirementToRequirementLibrary(long, NewRequirementVersionDto, List), except that the requirement will be added to the given folder.

Parameters:

folderId -

requirement -

milestoneIds -

Returns:

addRequirementToRequirement

org.squashtest.tm.domain.requirement.Requirement addRequirementToRequirement(long requirementId,
                                                                           @NotNull
                                                                           org.squashtest.tm.domain.requirement.Requirement newRequirement,
                                                                           List<Long> milestoneIds)

Same than addRequirementToRequirementLibrary(long, Requirement, List), except that the requirement will be added to the given parent requirement.

addRequirementToRequirement

org.squashtest.tm.domain.requirement.Requirement addRequirementToRequirement(long requirementId,
                                                                           @NotNull
                                                                           org.squashtest.tm.domain.requirement.NewRequirementVersionDto newRequirement,
                                                                           List<Long> milestoneIds)

Same than {@link #addRequirementToRequirementLibrary(long, NewRequirementVersionDto, List), except that the requirement will be added to the given parent requirement.

Parameters:

folderId -

requirement -

milestoneIds -

Returns:

copyNodesToRequirement

List<org.squashtest.tm.domain.requirement.Requirement> copyNodesToRequirement(long requirementId,
                                                                            Long[] sourceNodesIds)

moveNodesToRequirement

void moveNodesToRequirement(long requirementId,
                          Long[] nodeIds)

moveNodesToRequirement

void moveNodesToRequirement(long requirementId,
                          Long[] nodeIds,
                          int position)

findRequirement

org.squashtest.tm.domain.requirement.Requirement findRequirement(long reqId)

findRequirementsToExportFromLibrary

List<org.squashtest.tm.domain.requirement.ExportRequirementData> findRequirementsToExportFromLibrary(@NotNull
                                                                                                   List<Long> libraryIds)

Will find all requirements found in the given projects and return their information as a list of ExportRequirementData

Parameters:

libraryIds - ids of Project

Returns:

a list of ExportRequirementData

findRequirementsToExportFromNodes

List<org.squashtest.tm.domain.requirement.ExportRequirementData> findRequirementsToExportFromNodes(@NotNull
                                                                                                 List<Long> nodesIds)

Will find all requirements of the given ids and contained in folders of the given ids, and return their information as a list of ExportRequirementData

Parameters:

nodesIds - ids of RequirementLibraryNode

Returns:

a list of ExportRequirementData

findChildrenRequirements

List<org.squashtest.tm.domain.requirement.Requirement> findChildrenRequirements(long requirementId)

getParentNodesAsStringList

List<String> getParentNodesAsStringList(Long elementId)

exportRequirementAsExcel

File exportRequirementAsExcel(List<Long> libraryIds,
                            List<Long> nodeIds,
                            boolean keepRteFormat,
                            org.springframework.context.MessageSource messageSource)

Generate a xls file to export requirements

Parameters:

libraryIds - List of libraryIds (ie project ids) selected for export

nodeIds - List of nodeIds (ie req id or folder id) selected for export

searchExportRequirementAsExcel

File searchExportRequirementAsExcel(List<Long> nodeIds,
                                  boolean keepRteFormat,
                                  org.springframework.context.MessageSource messageSource)

Generate a xls file to export requirements from research screen

Parameters:

nodeIds - List of nodeIds (ie req id or folder id) selected for export

simulateImportExcelRequirement

ImportLog simulateImportExcelRequirement(File xls)

importExcelRequirement

ImportLog importExcelRequirement(File xls)

mkdirs

Long mkdirs(String folderpath)

Create a hierarchy of requirement library node. The type of node depends of the first existing node in hierarchy :

• If no node exist before, all created node will be RequirementFolder
• If the last existing node on path is a RequirementFolder, all created node will be RequirementFolder
• If the last existing node on path is a Requirement, all created node will be Requirement

Parameters:

folderpath - the complete path

Returns:

the ID of the created node. Take care that it can be an ID corresponding to a RequirementFolder or a Requirement. See above...

changeCurrentVersionNumber

void changeCurrentVersionNumber(org.squashtest.tm.domain.requirement.Requirement requirement,
                              Integer noVersion)

Change the current version number. Used by import to change the last created version number. This method also modify the Requirement.getCurrentVersion() if needed.

initCUFvalues

void initCUFvalues(org.squashtest.tm.domain.requirement.RequirementVersion reqVersion,
                 Map<Long,org.squashtest.tm.domain.customfield.RawValue> initialCustomFieldValues)

Initialize the CUF values for a RequirementVersion

Parameters:

initialCustomFieldValues - map the id of the CUF to the value. Beware, it's not the id of the CUFValue entry in db but the id of the CUF itself

findRequirementLibraryNodeById

org.squashtest.tm.domain.requirement.RequirementLibraryNode findRequirementLibraryNodeById(Long id)

findNamesInNodeStartingWith

List<String> findNamesInNodeStartingWith(long folderId,
                                       String nameStart)

findNamesInLibraryStartingWith

List<String> findNamesInLibraryStartingWith(long libraryId,
                                          String nameStart)

findAllRequirementIdsInMilestone

List<Long> findAllRequirementIdsInMilestone(org.squashtest.tm.domain.milestone.Milestone activeMilestone)

copyNodesToFolder

List<org.squashtest.tm.domain.requirement.RequirementLibraryNode> copyNodesToFolder(long destinationId,
                                                                                  Long[] sourceNodesIds)

Description copied from interface: LibraryNavigationService

will create a deep copy of the given LibraryNodes, paste them in the destination folder, and return the copies.

Specified by:

copyNodesToFolder in interface LibraryNavigationService<org.squashtest.tm.domain.requirement.RequirementLibrary,org.squashtest.tm.domain.requirement.RequirementFolder,org.squashtest.tm.domain.requirement.RequirementLibraryNode>

Parameters:

destinationId - the id of the folder where you need to copy to.

sourceNodesIds - the list of the librarynodes we want copies of.

Returns:

the list of the copies themselves.

copyNodesToLibrary

List<org.squashtest.tm.domain.requirement.RequirementLibraryNode> copyNodesToLibrary(long destinationId,
                                                                                   Long[] targetId)

Description copied from interface: LibraryNavigationService

same, when the destination is a Library.

Specified by:

copyNodesToLibrary in interface LibraryNavigationService<org.squashtest.tm.domain.requirement.RequirementLibrary,org.squashtest.tm.domain.requirement.RequirementFolder,org.squashtest.tm.domain.requirement.RequirementLibraryNode>

Parameters:

destinationId - the id of the library where you need to copy to.

targetId - the list of the librarynodes we want copies of.

Returns:

the list of the copies themselves.

moveNodesToFolder

void moveNodesToFolder(long destinationId,
                     Long[] targetId)

Specified by:

moveNodesToFolder in interface LibraryNavigationService<org.squashtest.tm.domain.requirement.RequirementLibrary,org.squashtest.tm.domain.requirement.RequirementFolder,org.squashtest.tm.domain.requirement.RequirementLibraryNode>

moveNodesToFolder

void moveNodesToFolder(long destinationId,
                     Long[] targetId,
                     int position)

Specified by:

moveNodesToFolder in interface LibraryNavigationService<org.squashtest.tm.domain.requirement.RequirementLibrary,org.squashtest.tm.domain.requirement.RequirementFolder,org.squashtest.tm.domain.requirement.RequirementLibraryNode>

moveNodesToLibrary

void moveNodesToLibrary(long destinationId,
                      Long[] targetId)

Specified by:

moveNodesToLibrary in interface LibraryNavigationService<org.squashtest.tm.domain.requirement.RequirementLibrary,org.squashtest.tm.domain.requirement.RequirementFolder,org.squashtest.tm.domain.requirement.RequirementLibraryNode>

moveNodesToLibrary

void moveNodesToLibrary(long destinationId,
                      Long[] targetId,
                      int position)

Specified by:

moveNodesToLibrary in interface LibraryNavigationService<org.squashtest.tm.domain.requirement.RequirementLibrary,org.squashtest.tm.domain.requirement.RequirementFolder,org.squashtest.tm.domain.requirement.RequirementLibraryNode>

deleteNodes

OperationReport deleteNodes(List<Long> targetIds)

Description copied from interface: LibraryNavigationService

that method should delete the nodes. It still takes care of non deletable nodes so the implementation should filter out the ids who can't be deleted.

Specified by:

deleteNodes in interface LibraryNavigationService<org.squashtest.tm.domain.requirement.RequirementLibrary,org.squashtest.tm.domain.requirement.RequirementFolder,org.squashtest.tm.domain.requirement.RequirementLibraryNode>

Returns: