PlanManagerImpl (Atlassian Bamboo 6.0.0 API)

java.lang.Object
- com.atlassian.bamboo.plan.PlanManagerImpl

All Implemented Interfaces:: PlanManager

public class PlanManagerImpl
extends Object
implements PlanManager

Constructor Summary

Constructors
Constructor and Description
`PlanManagerImpl(PlanDao planDao, BambooLicenseManager bambooLicenseManager, com.atlassian.event.api.EventPublisher eventPublisher, ProjectManager projectManager, PlanScheduler planScheduler)`

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`boolean`	`assertPlanPermission(PlanIdentifier plan)` Used to validate user permission for plan.
`void`	`createPlan(Plan plan)` Same as savePlan, but create permissions used instead of edit permissions.
`void`	`deletePlan(Plan plan)` Removes the plan object from the database.
`Set<ImmutableChain>`	`filterFavouritedPlans(Collection<? extends ImmutableChain> plans, com.atlassian.user.User user)` Return a set of `Plan`s that are a subset of the given `TopLevelPlan`s collection that are favourited by the `User`.
`List<Chain>`	`getAllChainsAndJobsUnrestricted()` WARNING this is probably a bad idea from a performance perspective, only do this if you're going to traverse through all the `ChainStage` and `Job` of all `Chain`s returned.
`<T extends Plan> List<PlanKey>`	`getAllPlanKeys(Class<T> planType)` Returns keys of all `Plan`'s filtered by `Class`.
`List<TopLevelPlan>`	`getAllPlans()` Returns all `TopLevelPlan`'s
`<T extends Plan> List<T>`	`getAllPlans(Class<T> planType)` Returns all `Plan`'s filtered by `Class`.
`<T extends Plan> List<T>`	`getAllPlans(Class<T> planType, int firstResult, int maxResults)` Returns all `Plan`'s filtered by `Class`.
`<T extends Plan> List<T>`	`getAllPlansByProject(Project project, Class<T> planType)` Returns all `Plan`'s filtered by `Project` and `Class`, including the plans marked for deletion.
`<T extends Plan> Collection<T>`	`getAllPlansMarkedForDeletion(Class<T> planType)` Returns a list of `Plan`s that are `ImmutableDeletable.isMarkedForDeletion()` for the given type
`List<TopLevelPlan>`	`getAllPlansUnrestricted()` Returns all `TopLevelPlan`'s ignoring permissions
`Set<ImmutableChain>`	`getFavouritePlans(com.atlassian.user.User user)`
`Plan`	`getPlanById(long id)` Returns a `Plan` by its id
`<T extends Plan> T`	`getPlanById(long id, Class<T> planType)` Returns a `Plan` by its id and `Class`
`Plan`	`getPlanByKey(PlanKey planKey)` Returns a `Plan` by its `PlanKey`
`<T extends Plan> T`	`getPlanByKey(PlanKey planKey, Class<T> planType)` Returns a `Plan` by its `PlanKey` and `Class`
`Plan`	`getPlanByKey(String planKey)` Returns a `Plan` by its planKey
`<T extends Plan> T`	`getPlanByKey(String planKey, Class<T> planType)` Returns a `Plan` by its planKey and `Class`
`<T extends Plan> T`	`getPlanByKeyIfOfType(PlanKey planKey, Class<T> planType)` Returns a `Plan` by its planKey and if it's of the type `Class`.
`<T extends Plan> T`	`getPlanByOid(BambooEntityOid oid, Class<T> planType)` Returns a `Plan` by its oid and `Class`
`<T extends Plan> T`	`getPlanByPartialKeyAndName(PlanKey partialPlanKey, String planName, Class<T> planType)` Used for Job validation.
`Class<? extends Plan>`	`getPlanClass(PlanKey planKey)`
`int`	`getPlanCount()`
`<T extends Plan> int`	`getPlanCount(Class<T> planType)` How many plans filtered by `Class` currently exist
`PlanIdentifier`	`getPlanIdentifierForPermissionCheckingByKey(String planKey)` Returns a `Plan` skeleton skeleton providing ONLY id and key, that matches the given key This method should be used only for permission checking using Acegi
`<T extends Plan> List<PlanIdentifier>`	`getPlanIdentifiersForProject(ProjectIdentifier project, Class<T> planType, boolean includeMarkedForDeletion)` Retrieve a list of plans for a given project.
`List<TopLevelPlan>`	`getPlansByProject(Project project)` Returns all `TopLevelPlan`'s filtered by `Project` Result of this method is filtered by Acegi.
`<T extends Plan> List<T>`	`getPlansByProject(Project project, Class<T> planType)` Returns all `Plan`'s filtered by `Project` and `Class`
`<T extends Plan> Map<Project,Collection<T>>`	`getProjectPlanMap(Class<T> planType, boolean includeEmptyProjects)` Return mapping of `Project` to `Plan` of given type
`boolean`	`isChainNameConflicting(String projectKey, long planIdToIgnore, String planName)` Verifies whether a `Chain` name is unique with the given project
`boolean`	`isPlanCreationAllowed()` Check whether or not a plan can be created or not (based on licensing etc) USE SPARINGLY!!!
`boolean`	`isPlanKeyConflicting(PlanKey planKey)` Verifies whether a `Plan` key is unique within whole Bamboo installation
`boolean`	`isPlanKeyConflicting(PlanKey planKey, long planIdToIgnore)` Verifies whether a `Plan` key is unique within whole Bamboo installation
`void`	`markPlansForDeletion(PlanKey planKey)` Efficiently marks a plan to be deleted
`void`	`removeStages(PlanKey key, Collection<Long> stageIds)` Remove the tages from the plan specified.
`void`	`savePlan(Plan plan)` Saves the `Plan`
`void`	`savePlanWithSchedulesStopped(Plan plan)` Saves the `Plan` while polling jobs are stopped.
`void`	`setPlanSuspendedState(PlanKey planKey, boolean isSuspended)`
`void`	`syncDeletionStatusOfJobs()` Performs a cleanup task to mark `Job` objects that have a `Plan` or `ChainStage` that is marked to be deleted, but it itself was not marked as deleted.
`void`	`triggerConfigUpdatedEventsForPlansInProject(Project project)` Triggers updated events for every plan in a project regardless of permissions.

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Constructor Detail
  - PlanManagerImpl
```
public PlanManagerImpl(@NotNull
                       PlanDao planDao,
                       @NotNull
                       BambooLicenseManager bambooLicenseManager,
                       @NotNull
                       com.atlassian.event.api.EventPublisher eventPublisher,
                       @NotNull
                       ProjectManager projectManager,
                       @NotNull
                       PlanScheduler planScheduler)
```
- Method Detail
  - getPlanById
```
@Nullable
public Plan getPlanById(long id)
                           throws IncorrectPlanTypeException
```
    Description copied from interface: PlanManager
    
    Returns a Plan by its id
    
    Specified by:
    
    getPlanById in interface PlanManager
    
    Parameters:
    
    id - of the plan
    
    Returns:
    
    plan with the given id, null if it doesn't exist
    
    Throws:
    
    IncorrectPlanTypeException - if plan cannot be found
  - getPlanById
```
@Nullable
public <T extends Plan> T getPlanById(long id,
                                                Class<T> planType)
                                         throws IncorrectPlanTypeException
```
    Description copied from interface: PlanManager
    
    Returns a Plan by its id and Class
    
    Specified by:
    
    getPlanById in interface PlanManager
    
    Parameters:
    
    id - of the plan
    
    planType - - the type of the plan to retrieve
    
    Returns:
    
    plan with the given id, if found AND is of the correct type.
    
    Throws:
    
    IncorrectPlanTypeException - if plan cannot be found with the correct type
  - getPlanByOid
```
@Nullable
public <T extends Plan> T getPlanByOid(BambooEntityOid oid,
                                                 Class<T> planType)
                                          throws IncorrectPlanTypeException
```
    Description copied from interface: PlanManager
    
    Returns a Plan by its oid and Class
    
    Specified by:
    
    getPlanByOid in interface PlanManager
    
    Parameters:
    
    oid - of the plan
    
    planType - - the type of the plan to retrieve
    
    Returns:
    
    plan with the given oid, if found AND is of the correct type.
    
    Throws:
    
    IncorrectPlanTypeException - if plan cannot be found with the correct type
  - getPlanByKey
```
@Nullable
public Plan getPlanByKey(@NotNull
                                   String planKey)
                            throws IncorrectPlanTypeException
```
    Description copied from interface: PlanManager
    
    Returns a Plan by its planKey
    
    Specified by:
    
    getPlanByKey in interface PlanManager
    
    Parameters:
    
    planKey - of the plan to find
    
    Returns:
    
    plan by the id if found, otherwise null
    
    Throws:
    
    IncorrectPlanTypeException - if plan cannot be found with the correct type (should never happen)
  - getPlanByKey
```
@Nullable
public <T extends Plan> T getPlanByKey(@NotNull
                                                 String planKey,
                                                 Class<T> planType)
                                          throws IncorrectPlanTypeException
```
    Description copied from interface: PlanManager
    
    Returns a Plan by its planKey and Class
    
    Specified by:
    
    getPlanByKey in interface PlanManager
    
    Parameters:
    
    planKey - to search for
    
    planType - - the type of the plan to retrieve
    
    Returns:
    
    plan with the given plan key, if found AND is of the correct type.
    
    Throws:
    
    IncorrectPlanTypeException - if plan cannot be found with the correct type
  - getPlanIdentifierForPermissionCheckingByKey
```
public PlanIdentifier getPlanIdentifierForPermissionCheckingByKey(@NotNull
                                                                  String planKey)
```
    Description copied from interface: PlanManager
    
    Returns a Plan skeleton skeleton providing ONLY id and key, that matches the given key This method should be used only for permission checking using Acegi
    If Job key is provided as a parameter, parent Chain will be returned anyway, as Acegi assertions are defined only for TopLevelPlans
    
    Specified by:
    
    getPlanIdentifierForPermissionCheckingByKey in interface PlanManager
    
    Parameters:
    
    planKey - of the plan to find
    
    Returns:
    
    plan by the id if found, otherwise null
  - getPlanClass
```
public Class<? extends Plan> getPlanClass(@NotNull
                                          PlanKey planKey)
```
    Specified by:
    
    getPlanClass in interface PlanManager
  - getPlanByKeyIfOfType
```
public <T extends Plan> T getPlanByKeyIfOfType(@NotNull
                                               PlanKey planKey,
                                               @NotNull
                                               Class<T> planType)
```
    Description copied from interface: PlanManager
    
    Returns a Plan by its planKey and if it's of the type Class. Does not throw IncorrectPlanTypeException. Should only be used when the type of the plan can not be known.
    
    Specified by:
    
    getPlanByKeyIfOfType in interface PlanManager
    
    Parameters:
    
    planKey - to search for
    
    planType - the type of the plan to retrieve
    
    Returns:
    
    null if the plan doesn't exist, or it's not of the found type
  - getPlanByKey
```
public Plan getPlanByKey(@NotNull
                         PlanKey planKey)
                  throws IncorrectPlanTypeException
```
    Description copied from interface: PlanManager
    
    Returns a Plan by its PlanKey
    
    Specified by:
    
    getPlanByKey in interface PlanManager
    
    Parameters:
    
    planKey - to search for
    
    Returns:
    
    plan
    
    Throws:
    
    IncorrectPlanTypeException - if plan cannot be found with the correct type (should never happen)
  - assertPlanPermission
```
public boolean assertPlanPermission(@NotNull
                                    PlanIdentifier plan)
```
    Description copied from interface: PlanManager
    
    Used to validate user permission for plan.
    
    Specified by:
    
    assertPlanPermission in interface PlanManager
    
    Parameters:
    
    plan - to check the permissions of
    
    Returns:
    
    true if the current user has read(?) permissions on the plan
  - getPlanByKey
```
public <T extends Plan> T getPlanByKey(@NotNull
                                       PlanKey planKey,
                                       Class<T> planType)
                                throws IncorrectPlanTypeException
```
    Description copied from interface: PlanManager
    
    Returns a Plan by its PlanKey and Class
    
    Specified by:
    
    getPlanByKey in interface PlanManager
    
    Parameters:
    
    planKey - to search for
    
    planType - - the type of the plan to retrieve
    
    Returns:
    
    plan with the given key, if found AND is of the correct type.
    
    Throws:
    
    IncorrectPlanTypeException - if plan cannot be found with the correct type
  - isChainNameConflicting
```
public boolean isChainNameConflicting(@NotNull
                                      String projectKey,
                                      long planIdToIgnore,
                                      @NotNull
                                      String planName)
```
    Description copied from interface: PlanManager
    
    Verifies whether a Chain name is unique with the given project
    
    Specified by:
    
    isChainNameConflicting in interface PlanManager
    
    Parameters:
    
    projectKey - of the project to look for the plan in
    
    planIdToIgnore - the id of the plan that has to be ignored during lookup (when you're saving a Plan, you should supply the plan id here)
    
    planName - - name of the plan inside the project: this is just the plan component of the name (i.e does not include the project component)
    
    Returns:
    
    true if the name is in conflict
  - isPlanKeyConflicting
```
public boolean isPlanKeyConflicting(@NotNull
                                    PlanKey planKey)
```
    Description copied from interface: PlanManager
    
    Verifies whether a Plan key is unique within whole Bamboo installation
    
    Specified by:
    
    isPlanKeyConflicting in interface PlanManager
    
    Parameters:
    
    planKey - key of the plan to be searched for in the database
    
    Returns:
    
    true if plan key is conflicting
  - isPlanKeyConflicting
```
public boolean isPlanKeyConflicting(@NotNull
                                    PlanKey planKey,
                                    long planIdToIgnore)
```
    Description copied from interface: PlanManager
    
    Verifies whether a Plan key is unique within whole Bamboo installation
    
    Specified by:
    
    isPlanKeyConflicting in interface PlanManager
    
    planIdToIgnore - id of plan which we want to set key for, if the key is used by that plan, it's not really conflicting
    
    Returns:
    
    true if plan key is conflicting
  - getPlanByPartialKeyAndName
```
@Nullable
public <T extends Plan> T getPlanByPartialKeyAndName(@NotNull
                                                               PlanKey partialPlanKey,
                                                               @NotNull
                                                               String planName,
                                                               Class<T> planType)
                                                        throws IncorrectPlanTypeException
```
    Description copied from interface: PlanManager
    
    Used for Job validation. Should update to be a specialised method
    
    Specified by:
    
    getPlanByPartialKeyAndName in interface PlanManager
    
    Throws:
    
    IncorrectPlanTypeException - if plan cannot be found with the correct type
  - getAllPlans
```
@NotNull
public List<TopLevelPlan> getAllPlans()
```
    Description copied from interface: PlanManager
    
    Returns all TopLevelPlan's
    
    Specified by:
    
    getAllPlans in interface PlanManager
    
    Returns:
    
    plans
  - getAllPlansUnrestricted
```
@NotNull
public List<TopLevelPlan> getAllPlansUnrestricted()
```
    Description copied from interface: PlanManager
    
    Returns all TopLevelPlan's ignoring permissions
    
    Specified by:
    
    getAllPlansUnrestricted in interface PlanManager
    
    Returns:
  - getAllPlans
```
@NotNull
public <T extends Plan> List<T> getAllPlans(Class<T> planType)
```
    Description copied from interface: PlanManager
    
    Returns all Plan's filtered by Class. Does not include plans marked for deletion.
    
    Specified by:
    
    getAllPlans in interface PlanManager
    
    Parameters:
    
    planType - - the type of the plan to retrieve
    
    Returns:
    
    plans sorted by DescriptionProvider.getName()
  - getAllPlanKeys
```
@NotNull
public <T extends Plan> List<PlanKey> getAllPlanKeys(Class<T> planType)
```
    Description copied from interface: PlanManager
    
    Returns keys of all Plan's filtered by Class. Does not include plans marked for deletion.
    
    Specified by:
    
    getAllPlanKeys in interface PlanManager
    
    Parameters:
    
    planType - - the type of the plan to retrieve
    
    Returns:
    
    plan keys
  - getAllPlans
```
@NotNull
public <T extends Plan> List<T> getAllPlans(Class<T> planType,
                                                     int firstResult,
                                                     int maxResults)
```
    Description copied from interface: PlanManager
    
    Returns all Plan's filtered by Class. Does not include plans marked for deletion.
    
    Specified by:
    
    getAllPlans in interface PlanManager
    
    Parameters:
    
    planType - - the type of the plan to retrieve
    
    firstResult - firstResult for a paginated results
    
    maxResults - maximum number of results to return
    
    Returns:
    
    plans sorted by DescriptionProvider.getName()
  - getAllChainsAndJobsUnrestricted
```
@NotNull
public List<Chain> getAllChainsAndJobsUnrestricted()
```
    Description copied from interface: PlanManager
    
    WARNING this is probably a bad idea from a performance perspective, only do this if you're going to traverse through all the ChainStage and Job of all Chains returned.
    
    Specified by:
    
    getAllChainsAndJobsUnrestricted in interface PlanManager
    
    Returns:
  - getPlansByProject
```
@NotNull
public List<TopLevelPlan> getPlansByProject(Project project)
```
    Description copied from interface: PlanManager
    
    Returns all TopLevelPlan's filtered by Project Result of this method is filtered by Acegi.
    
    Specified by:
    
    getPlansByProject in interface PlanManager
    
    Parameters:
    
    project - - that the plans will belong to
    
    Returns:
    
    TopLevelPlan plans contained within the given project
  - getPlansByProject
```
@NotNull
public <T extends Plan> List<T> getPlansByProject(Project project,
                                                           Class<T> planType)
```
    Description copied from interface: PlanManager
    
    Returns all Plan's filtered by Project and Class
    
    Specified by:
    
    getPlansByProject in interface PlanManager
    
    Parameters:
    
    project - - that the plans will belong to
    
    planType - - the type of the plan to retrieve
    
    Returns:
    
    plans contained within the given project and of the given type
  - getAllPlansByProject
```
@NotNull
public <T extends Plan> List<T> getAllPlansByProject(Project project,
                                                              Class<T> planType)
```
    Description copied from interface: PlanManager
    
    Returns all Plan's filtered by Project and Class, including the plans marked for deletion.
    
    Specified by:
    
    getAllPlansByProject in interface PlanManager
    
    Parameters:
    
    project - - that the plans will belong to
    
    planType - - the type of the plan to retrieve
    
    Returns:
    
    plans contained within the given project and of the given type
  - getPlanIdentifiersForProject
```
@NotNull
public <T extends Plan> List<PlanIdentifier> getPlanIdentifiersForProject(@NotNull
                                                                                   ProjectIdentifier project,
                                                                                   @NotNull
                                                                                   Class<T> planType,
                                                                                   boolean includeMarkedForDeletion)
```
    Description copied from interface: PlanManager
    
    Retrieve a list of plans for a given project. Only minimal data about the plans is returned.
    
    Specified by:
    
    getPlanIdentifiersForProject in interface PlanManager
    
    Parameters:
    
    project - to get plans for
    
    planType - to filter plans by
    
    includeMarkedForDeletion - set to true if you want to return plans marked for deletion
    
    Returns:
    
    PlanIdentifiers meeting the above criteria.
  - getProjectPlanMap
```
@NotNull
public <T extends Plan> Map<Project,Collection<T>> getProjectPlanMap(Class<T> planType,
                                                                              boolean includeEmptyProjects)
```
    Description copied from interface: PlanManager
    
    Return mapping of Project to Plan of given type
    
    Specified by:
    
    getProjectPlanMap in interface PlanManager
    
    Parameters:
    
    planType - type of plan to be selected from DB
    
    includeEmptyProjects - should empty projects be included in result
    
    Returns:
    
    mapping of Project to Plan of given type
  - getPlanCount
```
public int getPlanCount()
```
    Specified by:
    
    getPlanCount in interface PlanManager
    
    Returns:
    
    How many Buildable's exists
  - getPlanCount
```
public <T extends Plan> int getPlanCount(Class<T> planType)
```
    Description copied from interface: PlanManager
    
    How many plans filtered by Class currently exist
    
    Specified by:
    
    getPlanCount in interface PlanManager
    
    Parameters:
    
    planType - - the type of the plan to retrieve
    
    Returns:
    
    how many plans exist in the datbase
  - savePlan
```
public void savePlan(@NotNull
                     Plan plan)
```
    Description copied from interface: PlanManager
    
    Saves the Plan
    
    Specified by:
    
    savePlan in interface PlanManager
    
    Parameters:
    
    plan - to be saved
  - savePlanWithSchedulesStopped
```
public void savePlanWithSchedulesStopped(@NotNull
                                         Plan plan)
```
    Description copied from interface: PlanManager
    
    Saves the Plan while polling jobs are stopped.
    
    Specified by:
    
    savePlanWithSchedulesStopped in interface PlanManager
  - createPlan
```
public void createPlan(@NotNull
                       Plan plan)
```
    Description copied from interface: PlanManager
    
    Same as savePlan, but create permissions used instead of edit permissions.
    
    Specified by:
    
    createPlan in interface PlanManager
  - setPlanSuspendedState
```
public void setPlanSuspendedState(PlanKey planKey,
                                  boolean isSuspended)
```
    Specified by:
    
    setPlanSuspendedState in interface PlanManager
  - isPlanCreationAllowed
```
public boolean isPlanCreationAllowed()
```
    Check whether or not a plan can be created or not (based on licensing etc) USE SPARINGLY!!!
    
    Specified by:
    
    isPlanCreationAllowed in interface PlanManager
    
    Returns:
    
    true if a plan can be created otherwise false;
  - triggerConfigUpdatedEventsForPlansInProject
```
public void triggerConfigUpdatedEventsForPlansInProject(@NotNull
                                                        Project project)
```
    Description copied from interface: PlanManager
    
    Triggers updated events for every plan in a project regardless of permissions.
    
    Specified by:
    
    triggerConfigUpdatedEventsForPlansInProject in interface PlanManager
    
    Parameters:
    
    project - to trigger event for.
  - deletePlan
```
public void deletePlan(@NotNull
                       Plan plan)
```
    Description copied from interface: PlanManager
    
    Removes the plan object from the database. Does not do any other clean up work at all Please use the DeletionService rather than using this method directly
    
    Specified by:
    
    deletePlan in interface PlanManager
    
    Parameters:
    
    plan - to delete.
  - getAllPlansMarkedForDeletion
```
@NotNull
public <T extends Plan> Collection<T> getAllPlansMarkedForDeletion(Class<T> planType)
```
    Description copied from interface: PlanManager
    
    Returns a list of Plans that are ImmutableDeletable.isMarkedForDeletion() for the given type
    
    Specified by:
    
    getAllPlansMarkedForDeletion in interface PlanManager
    
    Returns:
    
    plansMarkedForDeletion
  - markPlansForDeletion
```
public void markPlansForDeletion(PlanKey planKey)
```
    Description copied from interface: PlanManager
    
    Efficiently marks a plan to be deleted
    
    Specified by:
    
    markPlansForDeletion in interface PlanManager
  - syncDeletionStatusOfJobs
```
public void syncDeletionStatusOfJobs()
```
    Description copied from interface: PlanManager
    
    Performs a cleanup task to mark Job objects that have a Plan or ChainStage that is marked to be deleted, but it itself was not marked as deleted.
    
    Specified by:
    
    syncDeletionStatusOfJobs in interface PlanManager
  - removeStages
```
public void removeStages(@NotNull
                         PlanKey key,
                         @NotNull
                         Collection<Long> stageIds)
```
    Description copied from interface: PlanManager
    
    Remove the tages from the plan specified. key must be for a Chain
    
    Specified by:
    
    removeStages in interface PlanManager
  - filterFavouritedPlans
```
@NotNull
public Set<ImmutableChain> filterFavouritedPlans(@NotNull
                                                          Collection<? extends ImmutableChain> plans,
                                                          @NotNull
                                                          com.atlassian.user.User user)
```
    Description copied from interface: PlanManager
    
    Return a set of Plans that are a subset of the given TopLevelPlans collection that are favourited by the User. Plans are not filtered by read permission.
    
    Specified by:
    
    filterFavouritedPlans in interface PlanManager
    
    Parameters:
    
    plans - to filter
    
    user - to return the favourites of
    
    Returns:
    
    a set of Chains that are a subset of the given TopLevelPlans collection that are favourited by the User
  - getFavouritePlans
```
public Set<ImmutableChain> getFavouritePlans(@NotNull
                                             com.atlassian.user.User user)
```
    Specified by:
    
    getFavouritePlans in interface PlanManager

Class PlanManagerImpl

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Constructor Detail

PlanManagerImpl

Method Detail

getPlanById

getPlanById

getPlanByOid

getPlanByKey

getPlanByKey

getPlanIdentifierForPermissionCheckingByKey

getPlanClass

getPlanByKeyIfOfType

getPlanByKey

assertPlanPermission

getPlanByKey

isChainNameConflicting

isPlanKeyConflicting

isPlanKeyConflicting

getPlanByPartialKeyAndName

getAllPlans

getAllPlansUnrestricted

getAllPlans

getAllPlanKeys

getAllPlans

getAllChainsAndJobsUnrestricted

getPlansByProject

getPlansByProject

getAllPlansByProject

getPlanIdentifiersForProject

getProjectPlanMap

getPlanCount

getPlanCount

savePlan

savePlanWithSchedulesStopped

createPlan

setPlanSuspendedState

isPlanCreationAllowed

triggerConfigUpdatedEventsForPlansInProject

deletePlan

getAllPlansMarkedForDeletion

markPlansForDeletion

syncDeletionStatusOfJobs

removeStages

filterFavouritedPlans

getFavouritePlans