How to use

ApplicationManager

in

com.atlassian.application.api

  @Override
  public Application get()
  {
    return appManager.getPlatform();
  }
};

private Stream<Application> getNonPlatformApplications()
{
  Stream<Application> applications = stream(applicationManager.getApplications().spliterator(), false);
  return applications.filter(input -> !(input instanceof PlatformApplication));
}

@Override
@Nonnull
public Option<String> getHelpSpace(@Nonnull final ApplicationKey applicationKey)
{
  return applicationManager.getApplication(applicationKey)
      .flatMap(app -> featureManager.isOnDemand() ? app.getProductHelpCloudSpaceURI() : app.getProductHelpServerSpaceURI())
      .map(uri -> uri.toString());
}

private String getDefaultGroupName(final ApplicationKey applicationKey)
{
  return toGroupName(applicationManager.getApplication(applicationKey).map(Application::getDefaultGroup)
      .getOrElse((Supplier<String>) () -> String.format("%s-users", applicationKey.value())));
}

private String getApplicationDisplayName(final ApplicationKey applicationKey)
{
  return applicationManager.getApplication(applicationKey).map(Application::getName)
      .getOrElse(applicationRoleManager.getRole(applicationKey).map(ApplicationRole::getName)
          .getOrElse(applicationKey.toString()));
}

private Stream<JiraApplication> getJiraAppForPlatformApp()
{
  PlatformApplication platform = applicationManager.getPlatform();
  return Stream.of(new JiraApplication(platform, asList(BUSINESS_TYPE)));
}

@Override
public ValidationResult validateApplicationLicense(@Nonnull final I18nHelper i18nHelper, @Nonnull final String licenseString)
{
  final Set<ApplicationKey> appKeys = newHashSet();
  for (Application application : applicationManager.getApplications())
  {
    appKeys.add(application.getKey());
  }
  return validate(appKeys, licenseString, i18nHelper);
}

  @Override
  public boolean test(@Nonnull final LicenseDetails details)
  {
    notNull("details", details);

    final Set<ApplicationKey> licensedApplicationKeys = details.getLicensedApplications().getKeys();
    for (final ApplicationKey key : licensedApplicationKeys)
    {
      final Option<Application> appOption = applicationManager.getApplication(key);
      if (appOption.isDefined())
      {
        final Date buildDate = appOption.get().buildDate().toDate();
        if (!details.isMaintenanceValidForBuildDate(buildDate))
        {
          return false;
        }
      }
    }
    // We need to also check against the platform build.
    return details.isMaintenanceValidForBuildDate(info.getCurrentBuildDate());
  }
}

private boolean isPlatformApplication(final JiraApplication application)
{
  return application.getKey().equals(applicationManager.getPlatform().getKey());
}

private Option<Application> getApplicationWithPostInstall()
  final Option<Iterable<Application>> applications = Option.option(applicationManager.getApplications());

  /**
   * Checks maintenance for given application keys if they are installed.
   */
  public Function<LicenseDetails, Either<String, LicenseDetails>> validateMaintenanceForApplications(@Nonnull final Set<ApplicationKey> installedAppKeys,
      @Nonnull final ApplicationManager applicationManager)
  {
    return jiraLicenseDetails ->
    {
      for (ApplicationKey appKey : installedAppKeys)
      {
        final Option<Application> application = applicationManager.getApplication(appKey);
        if (application.isDefined())
        {
          if (!jiraLicenseDetails.isMaintenanceValidForBuildDate(application.get().buildDate().toDate()))
          {
            final LicenseDetails.LicenseStatusMessage maintenanceMessage =
                jiraLicenseDetails.getMaintenanceMessage(i18nHelper, application.get().getName());
            //Subscription license does not have any messages and are valid
            if (maintenanceMessage.hasAnyMessages())
            {
              return Either.left(maintenanceMessage.getAllMessages("<br/><br/>"));
            }
          }
        }
      }
      return Either.right(jiraLicenseDetails);
    };
  }
}

private boolean isNonCoreApplicationDefinition(final ApplicationRoleDefinitions.ApplicationRoleDefinition definition)
{
  return !applicationManager.getPlatform().getKey().equals(definition.key());
}

@ActionViewData ("success")
public Map<String, Object> getData()
{
  Application application = StreamSupport.stream(applicationManager.getApplications().spliterator(), false)
      .filter(app -> !ApplicationKeys.CORE.equals(app.getKey()))
      .findFirst()
      .orElseGet(applicationManager::getPlatform);
  return MapBuilder.<String, Object>newBuilder()
      .add("productName", application.getName())
      .add("productVersion", application.getVersion())
      .add("notMigratedGroups", notMigratedGroups())
      .add("notDefinedRoles", notDefinedRoles())
      .toMap();
}

public ApplicationRoleBean roleBean(ApplicationRole role)
{
  final ApplicationKey key = role.getKey();
  final int userCount = roleManager.getUserCount(key);
  final Application application = appManager.getApplication(key).getOrElse(platform);
  final String userCountDescription = application.getUserCountDescription(Option.some(userCount));
  final int remainingSeats = roleManager.getRemainingSeats(key);
  return new ApplicationRoleBean(
      key.value(),
      role.getName(),
      toNames(role.getGroups()),
      toNames(role.getDefaultGroups()),
      role.isSelectedByDefault(),
      role.isDefined(),
      role.getNumberOfSeats(),
      remainingSeats,
      userCount,
      userCountDescription,
      remainingSeats == UNLIMITED_USERS,
      role.isPlatform());
}