How to use

EntityIdentifier

in

com.atlassian.streams.spi

@Test
public void assertThatIdentifierOfUnknownTypeReturnsNoFilterKey()
{
  assertThat(provider.getFilterKey(new EntityIdentifier(UNKNOWN_ENTITY_TYPE, PROJECT_ENTITY_KEY, URI.create(UNKNOWN_BASE_URL))),
        equalTo(none(String.class)));
}

@Override
public Option<URI> getEntityURI(EntityIdentifier identifier)
{
  if (identifier.getType().equals(project().iri()))
  {
    return some(URI.create(applicationProperties.getBaseUrl() + PROJECT_URL_PREFIX + identifier.getValue()));
  }
  return none();
}

@Override
protected boolean matchesSafely(EntityIdentifier identifier, Description mismatchDescription)
{
  if (!matcher.matches(identifier.getUri()))
  {
    mismatchDescription.appendText("uri ");
    matcher.describeMismatch(identifier.getUri(), mismatchDescription);
    return false;
  }
  return true;
}

@Override
protected boolean matchesSafely(EntityIdentifier identifier, Description mismatchDescription)
{
  if (!matcher.matches(identifier.getType()))
  {
    mismatchDescription.appendText("type ");
    matcher.describeMismatch(identifier.getType(), mismatchDescription);
    return false;
  }
  return true;
}

@Override
protected boolean matchesSafely(EntityIdentifier identifier, Description mismatchDescription)
{
  if (!matcher.matches(identifier.getValue()))
  {
    mismatchDescription.appendText("value ");
    matcher.describeMismatch(identifier.getValue(), mismatchDescription);
    return false;
  }
  return true;
}

@Override
public Option<String> getFilterKey(EntityIdentifier identifier)
{
  if (identifier.getType().equals(space().iri()))
  {
    return some(PROJECT_KEY);
  }
  return none();
}

@Override
public Option<URI> getEntityURI(EntityIdentifier identifier)
{
  if (identifier.getType().equals(repository().iri()))
  {
    return some(URI.create(applicationProperties.getBaseUrl() + PROJECT_URL_PREFIX + identifier.getValue()));
  }
  return none();
}

protected EntityIdentifier getIssueEntityIdentifier(String key)
{
  return new EntityIdentifier(getIssueEntityType(),
                key,
                getIssueUri(key));
}

@Override
public Option<String> getFilterKey(EntityIdentifier identifier)
{
  if (identifier.getType().equals(repository().iri()))
  {
    return some(PROJECT_KEY);
  }
  return none();
}

@Override
public Option<URI> getEntityURI(EntityIdentifier identifier)
{
  if (identifier.getType().equals(project().iri())
    || identifier.getType().equals(issue().iri()))
  {
    return some(URI.create(applicationProperties.getBaseUrl() + BROWSE + identifier.getValue()));
  }
  return none();
}

protected EntityIdentifier getProjectEntityIdentifier(String key)
{
  return new EntityIdentifier(getProjectEntityType(),
                key,
                getProjectUri(key));
}

@Override
public Option<Boolean> getCurrentUserEditPermission(EntityIdentifier identifier)
{
  if (identifier.getType().equals(issue().iri()))
  {
    // JIRA only defines an Edit permission for issues, not for projects
    return getCurrentUserPermission(identifier, Permissions.EDIT_ISSUE);
  }
  return getCurrentUserViewPermission(identifier);
}

@Override
public Option<URI> getEntityURI(EntityIdentifier identifier)
{
  if (identifier.getType().equals(space().iri()))
  {
    return some(URI.create(applicationProperties.getBaseUrl(UrlMode.CANONICAL) + URL_PREFIX + encode(identifier.getValue())));
  }
  return none();
}

  private Iterable<EntityIdentifier> matchEntities(String input)
  {
    Matcher matcher = PROJECT_PATTERN.matcher(input);
    //the target URI is of an unknown format
    if (!matcher.matches())
    {
      return ImmutableList.of();
    }

    String repoKey = matcher.group(1);
    RepositoryHandle repo = repositoryManager.getRepository(repoKey);
    if (repo != null)
    {
      URI canonicalUri = URI.create(applicationProperties.getBaseUrl() + PROJECT_URL_PREFIX + repoKey);
      return ImmutableList.of(new EntityIdentifier(repository().iri(),
                             repoKey,
                             canonicalUri));
    }
    else
    {
      return ImmutableList.of();
    }
  }
}

@Override
public Option<String> getFilterKey(EntityIdentifier identifier)
{
  if (identifier.getType().equals(project().iri()))
  {
    return some(PROJECT_KEY);
  }
  return none();
}

@Override
public Option<Boolean> getCurrentUserViewPermission(EntityIdentifier identifier)
{
  if (identifier.getType().equals(repository().iri()))
  {
    RepositoryHandle repo = repositoryManager.getRepository(identifier.getValue());
    if (repo != null)
    {
      return some(Boolean.valueOf(permissionAccessor.currentUserCanView(repo)));
    }
  }
  return none();
}

  private Iterable<EntityIdentifier> matchEntities(String input)
  {   
    Matcher matcher = PROJECT_PATTERN.matcher(input);
    //the target URI is of an unknown format
    if (!matcher.matches())
    {
      return ImmutableList.of();
    }

    String projectKey = matcher.group(1);
    ProjectData project = projectService.getProject(projectKey);
    if (project != null)
    {
      URI canonicalUri = URI.create(applicationProperties.getBaseUrl()+ PROJECT_URL_PREFIX + projectKey);
      return ImmutableList.of(new EntityIdentifier(project().iri(),
                             projectKey,
                             canonicalUri));
    }
    else
    {
      return ImmutableList.of();
    }
  }
}

@Override
public Option<String> getFilterKey(EntityIdentifier identifier)
{
  if (identifier.getType().equals(project().iri()))
  {
    return some(PROJECT_KEY);
  }
  else if (identifier.getType().equals(issue().iri()))
  {
    return some(ISSUE_KEY.getKey());
  }
  return none();
}

@Override
public Option<Boolean> getCurrentUserViewPermission(EntityIdentifier identifier)
{
  if (identifier.getType().equals(project().iri()))
  {
    ProjectData projectData = projectService.getProject(identifier.getValue());
    if (projectData != null)
    {
      return some(Boolean.valueOf(projectService.hasPermission(projectData.getKey(), UserActionManager.ACTION_VIEW)));
    }
  }
  return none();
}

  private Iterable<EntityIdentifier> matchEntities(String input)
  {
    Matcher spaceMatcher = SPACE_PATTERN.matcher(input);
    if (spaceMatcher.matches())
    {
      String spaceKey = spaceMatcher.group(1);
      Space space = spaceManager.getSpace(spaceKey);
      if (space != null)
      {
        URI canonicalUri = URI.create(applicationProperties.getBaseUrl(UrlMode.CANONICAL) + URL_PREFIX + encode(spaceKey));
        return ImmutableList.of(new EntityIdentifier(space().iri(),
                               spaceKey,
                               canonicalUri));
      }
    }

    return ImmutableList.of();
  }
}