use of org.eclipse.openvsx.entities.Namespace in project openvsx by eclipse.
the class LocalRegistryService method createNamespace.
@Transactional(rollbackOn = ErrorResultException.class)
public ResultJson createNamespace(NamespaceJson json, String tokenValue) {
var namespaceIssue = validator.validateNamespace(json.name);
if (namespaceIssue.isPresent()) {
throw new ErrorResultException(namespaceIssue.get().toString());
}
var token = users.useAccessToken(tokenValue);
if (token == null) {
throw new ErrorResultException("Invalid access token.");
}
eclipse.checkPublisherAgreement(token.getUser());
var namespace = repositories.findNamespace(json.name);
if (namespace != null) {
throw new ErrorResultException("Namespace already exists: " + namespace.getName());
}
// Create the requested namespace
namespace = new Namespace();
namespace.setName(json.name);
entityManager.persist(namespace);
// Assign the requesting user as contributor
var membership = new NamespaceMembership();
membership.setNamespace(namespace);
membership.setUser(token.getUser());
membership.setRole(NamespaceMembership.ROLE_CONTRIBUTOR);
entityManager.persist(membership);
return ResultJson.success("Created namespace " + namespace.getName());
}
use of org.eclipse.openvsx.entities.Namespace in project openvsx by eclipse.
the class LocalRegistryService method query.
@Override
public QueryResultJson query(QueryParamJson param) {
if (!Strings.isNullOrEmpty(param.extensionId)) {
var split = param.extensionId.split("\\.");
if (split.length != 2 || split[0].isEmpty() || split[1].isEmpty())
throw new ErrorResultException("The 'extensionId' parameter must have the format 'namespace.extension'.");
if (!Strings.isNullOrEmpty(param.namespaceName) && !param.namespaceName.equals(split[0]))
throw new ErrorResultException("Conflicting parameters 'extensionId' and 'namespaceName'");
if (!Strings.isNullOrEmpty(param.extensionName) && !param.extensionName.equals(split[1]))
throw new ErrorResultException("Conflicting parameters 'extensionId' and 'extensionName'");
param.namespaceName = split[0];
param.extensionName = split[1];
}
List<ExtensionVersionDTO> extensionVersions = new ArrayList<>();
// Add extension by UUID (public_id)
if (!Strings.isNullOrEmpty(param.extensionUuid)) {
extensionVersions.addAll(repositories.findActiveExtensionVersionDTOsByExtensionPublicId(param.extensionUuid));
}
// Add extensions by namespace UUID (public_id)
if (!Strings.isNullOrEmpty(param.namespaceUuid)) {
extensionVersions.addAll(repositories.findActiveExtensionVersionDTOsByNamespacePublicId(param.namespaceUuid));
}
// Add a specific version of an extension
if (!Strings.isNullOrEmpty(param.namespaceName) && !Strings.isNullOrEmpty(param.extensionName) && !Strings.isNullOrEmpty(param.extensionVersion) && !param.includeAllVersions) {
var extensionVersion = repositories.findActiveExtensionVersionDTOByVersion(param.extensionVersion, param.extensionName, param.namespaceName);
if (extensionVersion != null) {
extensionVersions.add(extensionVersion);
}
// Add extension by namespace and name
} else if (!Strings.isNullOrEmpty(param.namespaceName) && !Strings.isNullOrEmpty(param.extensionName)) {
extensionVersions.addAll(repositories.findActiveExtensionVersionDTOsByExtensionName(param.extensionName, param.namespaceName));
// Add extensions by namespace
} else if (!Strings.isNullOrEmpty(param.namespaceName)) {
extensionVersions.addAll(repositories.findActiveExtensionVersionDTOsByNamespaceName(param.namespaceName));
// Add extensions by name
} else if (!Strings.isNullOrEmpty(param.extensionName)) {
extensionVersions.addAll(repositories.findActiveExtensionVersionDTOsByExtensionName(param.extensionName));
}
extensionVersions = extensionVersions.stream().collect(Collectors.groupingBy(ExtensionVersionDTO::getId)).values().stream().map(l -> l.get(0)).filter(ev -> addToResult(ev, param)).collect(Collectors.toList());
if (Strings.isNullOrEmpty(param.extensionVersion) && !param.includeAllVersions) {
var latestIds = extensionVersions.stream().map(ExtensionVersionDTO::getExtension).map(ExtensionDTO::getLatestId).filter(Objects::nonNull).collect(Collectors.toList());
extensionVersions = extensionVersions.stream().filter(ev -> latestIds.contains(ev.getId())).collect(Collectors.toList());
}
var extensionIds = extensionVersions.stream().map(ExtensionVersionDTO::getExtensionId).collect(Collectors.toSet());
var reviewCounts = getReviewCounts(extensionIds);
var versionStrings = getVersionStrings(extensionIds);
var previewsByExtensionId = getPreviews(extensionIds);
var fileResourcesByExtensionVersionId = getFileResources(extensionVersions);
var membershipsByNamespaceId = getMemberships(extensionVersions);
var result = new QueryResultJson();
result.extensions = extensionVersions.stream().sorted(getExtensionVersionComparator()).map(ev -> {
var reviewCount = reviewCounts.getOrDefault(ev.getExtensionId(), 0);
var preview = previewsByExtensionId.get(ev.getExtensionId());
var versions = versionStrings.get(ev.getExtensionId());
var fileResources = fileResourcesByExtensionVersionId.getOrDefault(ev.getId(), Collections.emptyList());
return toExtensionVersionJson(ev, reviewCount, preview, versions, fileResources, membershipsByNamespaceId);
}).collect(Collectors.toList());
return result;
}
use of org.eclipse.openvsx.entities.Namespace in project openvsx by eclipse.
the class RegistryAPITest method mockForPublish.
private void mockForPublish(String mode) {
var token = mockAccessToken();
if (mode.equals("invalid")) {
token.setActive(false);
}
var namespace = new Namespace();
namespace.setName("foo");
Mockito.when(repositories.findNamespace("foo")).thenReturn(namespace);
if (mode.equals("existing")) {
var extension = new Extension();
extension.setName("bar");
var extVersion = new ExtensionVersion();
extVersion.setExtension(extension);
extVersion.setVersion("1");
extVersion.setActive(true);
Mockito.when(repositories.findExtension("bar", namespace)).thenReturn(extension);
Mockito.when(repositories.findVersion("1", extension)).thenReturn(extVersion);
}
Mockito.when(repositories.countActiveReviews(any(Extension.class))).thenReturn(0l);
Mockito.when(repositories.findVersions(any(Extension.class))).thenReturn(Streamable.empty());
Mockito.when(repositories.findActiveVersions(any(Extension.class))).thenReturn(Streamable.empty());
Mockito.when(repositories.getVersionStrings(any(Extension.class))).thenReturn(Streamable.empty());
Mockito.when(repositories.getActiveVersionStrings(any(Extension.class))).thenReturn(Streamable.empty());
Mockito.when(repositories.findFilesByType(any(ExtensionVersion.class), anyCollection())).thenReturn(Streamable.empty());
if (mode.equals("owner")) {
var ownerMem = new NamespaceMembership();
ownerMem.setUser(token.getUser());
ownerMem.setNamespace(namespace);
ownerMem.setRole(NamespaceMembership.ROLE_OWNER);
Mockito.when(repositories.findMemberships(namespace, NamespaceMembership.ROLE_OWNER)).thenReturn(Streamable.of(ownerMem));
Mockito.when(repositories.countMemberships(namespace, NamespaceMembership.ROLE_OWNER)).thenReturn(1l);
Mockito.when(repositories.findMembership(token.getUser(), namespace)).thenReturn(ownerMem);
Mockito.when(repositories.countMemberships(token.getUser(), namespace)).thenReturn(1l);
} else if (mode.equals("contributor") || mode.equals("sole-contributor") || mode.equals("existing")) {
var contribMem = new NamespaceMembership();
contribMem.setUser(token.getUser());
contribMem.setNamespace(namespace);
contribMem.setRole(NamespaceMembership.ROLE_CONTRIBUTOR);
Mockito.when(repositories.findMembership(token.getUser(), namespace)).thenReturn(contribMem);
Mockito.when(repositories.countMemberships(token.getUser(), namespace)).thenReturn(1l);
if (mode.equals("contributor")) {
var otherUser = new UserData();
otherUser.setLoginName("other_user");
var ownerMem = new NamespaceMembership();
ownerMem.setUser(otherUser);
ownerMem.setNamespace(namespace);
ownerMem.setRole(NamespaceMembership.ROLE_OWNER);
Mockito.when(repositories.findMemberships(namespace, NamespaceMembership.ROLE_OWNER)).thenReturn(Streamable.of(ownerMem));
Mockito.when(repositories.countMemberships(namespace, NamespaceMembership.ROLE_OWNER)).thenReturn(1l);
} else {
Mockito.when(repositories.findMemberships(namespace, NamespaceMembership.ROLE_OWNER)).thenReturn(Streamable.empty());
Mockito.when(repositories.countMemberships(namespace, NamespaceMembership.ROLE_OWNER)).thenReturn(0l);
}
} else if (mode.equals("privileged") || mode.equals("unrelated")) {
var otherUser = new UserData();
otherUser.setLoginName("other_user");
var ownerMem = new NamespaceMembership();
ownerMem.setUser(otherUser);
ownerMem.setNamespace(namespace);
ownerMem.setRole(NamespaceMembership.ROLE_OWNER);
Mockito.when(repositories.findMemberships(namespace, NamespaceMembership.ROLE_OWNER)).thenReturn(Streamable.of(ownerMem));
Mockito.when(repositories.countMemberships(namespace, NamespaceMembership.ROLE_OWNER)).thenReturn(1l);
if (mode.equals("privileged")) {
token.getUser().setRole(UserData.ROLE_PRIVILEGED);
}
} else {
Mockito.when(repositories.findMemberships(namespace, NamespaceMembership.ROLE_OWNER)).thenReturn(Streamable.empty());
Mockito.when(repositories.countMemberships(namespace, NamespaceMembership.ROLE_OWNER)).thenReturn(0l);
}
}
Aggregations