Examples with SUser jetbrains.buildServer.users.SUser used on opensource projects

Example 1 with SUser

use of jetbrains.buildServer.users.SUser in project teamcity-rest by JetBrains.

the class ChangeFinder method getPrefilteredItems.

@NotNull
@Override
public ItemHolder<SVcsModificationOrChangeDescriptor> getPrefilteredItems(@NotNull final Locator locator) {
    final String internalVersion = locator.getSingleDimensionValue(INTERNAL_VERSION);
    if (internalVersion != null) {
        return wrapModifications(((VcsModificationHistoryEx) myVcsModificationHistory).findModificationsByVersion(internalVersion));
    }
    ValueCondition displayVersionCondition = ParameterCondition.createValueCondition(locator.lookupSingleDimensionValue(VERSION));
    final String displayVersion = displayVersionCondition != null ? displayVersionCondition.getConstantValueIfSimpleEqualsCondition() : null;
    if (displayVersion != null) {
        locator.markUsed(Collections.singleton(VERSION));
        return wrapModifications(((VcsModificationHistoryEx) myVcsModificationHistory).findModificationsByDisplayVersion(displayVersion));
    }
    Boolean personal = locator.lookupSingleDimensionValueAsBoolean(PERSONAL);
    if (personal != null && personal) {
        if (locator.lookupSingleDimensionValue(BUILD) == null && locator.lookupSingleDimensionValue(USER) == null) {
            throw new BadRequestException("Filtering personal changes is supported only when '" + DIMENSION_ID + "', '" + USER + "' or '" + BUILD + "' dimensions are specified");
        }
    }
    final String buildLocator = locator.getSingleDimensionValue(BUILD);
    if (buildLocator != null) {
        BuildPromotion buildFromBuildFinder;
        try {
            buildFromBuildFinder = myBuildPromotionFinder.getItem(buildLocator);
        } catch (Exception e) {
            if (!TeamCityProperties.getBoolean("rest.request.changes.legacySingleBuildSearch")) {
                throw e;
            }
            // support for finished builds
            // todo: use buildPromotionFinder here (ensure it also supports finished builds)
            // THIS SHOULD NEVER HAPPEN
            buildFromBuildFinder = myBuildFinder.getBuildPromotion(null, buildLocator);
        }
        return wrapDescriptors(getBuildChangeDescriptors(buildFromBuildFinder, locator));
    }
    // pre-9.0 compatibility
    final Long promotionLocator = locator.getSingleDimensionValueAsLong(PROMOTION);
    if (promotionLocator != null) {
        // noinspection ConstantConditions
        return wrapDescriptors(getBuildChangeDescriptors(BuildFinder.getBuildPromotion(promotionLocator, myServiceLocator.findSingletonService(BuildPromotionManager.class)), locator));
    }
    final String parentChangeLocator = locator.getSingleDimensionValue(CHILD_CHANGE);
    if (parentChangeLocator != null) {
        final SVcsModification parentChange = getItem(parentChangeLocator).getSVcsModification();
        return wrapModifications(getChangesWhichHasChild(parentChange, locator.getSingleDimensionValueAsLong(DIMENSION_LOOKUP_LIMIT)));
    // todo: return iterator instead of processing lookup limit here
    }
    final String childChangeLocator = locator.getSingleDimensionValue(PARENT_CHANGE);
    if (childChangeLocator != null) {
        final SVcsModification parentChange = getItem(childChangeLocator).getSVcsModification();
        return wrapModifications(getChangesWhichHasParent(parentChange, locator.getSingleDimensionValueAsLong(DIMENSION_LOOKUP_LIMIT)));
    }
    final String graphLocator = locator.getSingleDimensionValue(DAG_TRAVERSE);
    if (graphLocator != null) {
        final GraphFinder<SVcsModification> graphFinder = new GraphFinder<SVcsModification>(locatorText -> getItems(locatorText).myEntries.stream().map(SVcsModificationOrChangeDescriptor::getSVcsModification).collect(Collectors.toList()), new ChangesGraphTraverser());
        graphFinder.setDefaultLookupLimit(1000L);
        return wrapModifications(graphFinder.getItems(graphLocator).myEntries);
    }
    final String userLocator = locator.getSingleDimensionValue(USER);
    if (userLocator != null) {
        final SUser user = myUserFinder.getItem(userLocator);
        return wrapModifications(myServiceLocator.getSingletonService(UserChangesFacade.class).getAllVcsModifications(user));
    }
    final String username = locator.getSingleDimensionValue(USERNAME);
    if (username != null) {
        return wrapModifications(myServiceLocator.getSingletonService(VcsModificationsStorage.class).findModificationsByUsername(username));
    }
    Long sinceChangeId = null;
    final String sinceChangeLocator = locator.getSingleDimensionValue(SINCE_CHANGE);
    if (sinceChangeLocator != null) {
        sinceChangeId = getChangeIdBySinceChangeLocator(sinceChangeLocator);
    }
    final String vcsRootInstanceLocator = locator.getSingleDimensionValue(VCS_ROOT_INSTANCE);
    if (vcsRootInstanceLocator != null) {
        final VcsRootInstance vcsRootInstance = myVcsRootInstanceFinder.getItem(vcsRootInstanceLocator);
        if (sinceChangeId != null) {
            // todo: use lookupLimit here or otherwise limit processing
            return wrapModifications(myVcsModificationHistory.getModificationsInRange(vcsRootInstance, sinceChangeId, null));
        } else {
            // todo: highly inefficient!
            return wrapModifications(myVcsModificationHistory.getAllModifications(vcsRootInstance));
        }
    }
    SBuildType buildType = null;
    // todo: support multiple buildTypes here
    final String buildTypeLocator = locator.getSingleDimensionValue(BUILD_TYPE);
    if (buildTypeLocator != null) {
        buildType = myBuildTypeFinder.getBuildType(null, buildTypeLocator, false);
    }
    Boolean pending = locator.getSingleDimensionValueAsBoolean(PENDING);
    if (pending != null) {
        if (pending) {
            Stream<SVcsModificationOrChangeDescriptor> changes = getPendingChanges(buildType, locator);
            return processor -> changes.allMatch(processor::processItem);
        } else {
            locator.markUnused(PENDING);
        }
    }
    if (buildType != null) {
        Stream<SVcsModificationOrChangeDescriptor> changes = getBranchChanges(buildType, SelectPrevBuildPolicy.SINCE_NULL_BUILD, locator);
        return processor -> changes.allMatch(processor::processItem);
    }
    if (locator.lookupSingleDimensionValue(BRANCH) != null) {
        throw new BadRequestException("Filtering changes by branch is only supported when buildType is specified.");
    }
    final String projectLocator = locator.getSingleDimensionValue(PROJECT);
    if (projectLocator != null) {
        return wrapModifications(getProjectChanges(myProjectFinder.getItem(projectLocator), sinceChangeId));
    }
    if (sinceChangeId != null) {
        // todo: use lookupLimit here or otherwise limit processing
        return wrapModifications(myVcsModificationHistory.getModificationsInRange(null, sinceChangeId, null));
    }
    // ItemHolder
    return wrapModifications(((VcsModificationHistoryEx) myVcsModificationHistory)::processModifications);
}

Example 2 with SUser

use of jetbrains.buildServer.users.SUser in project teamcity-rest by JetBrains.

the class ProjectFinder method getPrefilteredItems.

@NotNull
@Override
public ItemHolder<SProject> getPrefilteredItems(@NotNull final Locator locator) {
    // this should be the first one as the order returned here is important!
    final String selectedForUser = locator.getSingleDimensionValue(DIMENSION_SELECTED);
    if (selectedForUser != null) {
        Locator selectedByUserLocator = new Locator(selectedForUser, "user", "mode");
        String userLocator = selectedByUserLocator.getSingleDimensionValue("user");
        String modeLocator = selectedByUserLocator.getSingleDimensionValue("mode");
        if (userLocator == null && modeLocator == null) {
            // assume it's user locator - the only supported way before 2017.1
            userLocator = selectedForUser;
        } else {
            selectedByUserLocator.checkLocatorFullyProcessed();
        }
        final SUser user = myServiceLocator.getSingletonService(UserFinder.class).getItem(userLocator);
        return getItemHolder(getSelectedProjects(user, getSelectedByUserMode(modeLocator, SelectedByUserMode.SELECTED_AND_UNKNOWN)));
    }
    final SProject parentProject;
    try {
        parentProject = getParentProject(locator);
    } catch (AccessDeniedException e) {
        // workaround for https://youtrack.jetbrains.com/issue/TW-46290
        // note: finding affectedProject under system is a bad approach as that can be used to probe server data without due permissions, so support only some hardcoded cases here
        String affectedProjectDimension = locator.lookupSingleDimensionValue(DIMENSION_AFFECTED_PROJECT);
        if (getRootProject().getExternalId().equals(affectedProjectDimension) || getLocator(getRootProject()).equals(affectedProjectDimension)) {
            // it was a request with affectedProject==_Root, but user got access denied on finding, returning empty collection instead of 403/Forbidden
            return getItemHolder(Collections.emptyList());
        }
        // throw original error
        throw e;
    }
    final String name = locator.getSingleDimensionValue(DIMENSION_NAME);
    if (name != null) {
        if (parentProject != null) {
            return getItemHolder(findProjectsByName(parentProject, name, true));
        }
        String directParent = locator.getSingleDimensionValue(DIMENSION_PROJECT);
        if (directParent != null) {
            return getItemHolder(findProjectsByName(getItem(directParent), name, false));
        }
    }
    final String directParent = locator.getSingleDimensionValue(DIMENSION_PROJECT);
    if (directParent != null) {
        return getItemHolder(getItem(directParent).getOwnProjects());
    }
    if (parentProject != null) {
        return getItemHolder(parentProject.getProjects());
    }
    return getItemHolder(myProjectManager.getProjects());
}

Example 3 with SUser

use of jetbrains.buildServer.users.SUser in project teamcity-rest by JetBrains.

the class TagFinder method getFilter.

@NotNull
@Override
public ItemFilter<TagData> getFilter(@NotNull final Locator locator) {
    if (locator.isSingleValue()) {
        final String singleValue = locator.getSingleValue();
        final MultiCheckerFilter<TagData> result = new MultiCheckerFilter<TagData>();
        result.add(new FilterConditionChecker<TagData>() {

            public boolean isIncluded(@NotNull final TagData item) {
                // the code should correspond to TagFinder.isIncluded method
                return item.isPublic() && item.getLabel().equals(singleValue);
            }
        });
        return result;
    }
    final MultiCheckerFilter<TagData> result = new MultiCheckerFilter<TagData>();
    final String nameDimension = locator.getSingleDimensionValue(NAME);
    if (nameDimension != null) {
        result.add(new FilterConditionChecker<TagData>() {

            public boolean isIncluded(@NotNull final TagData item) {
                // conditions are supported via "condition" dimension
                return nameDimension.equalsIgnoreCase(item.getLabel());
            }
        });
    }
    final Boolean privateDimension = locator.getSingleDimensionValueAsBoolean(PRIVATE);
    if (privateDimension != null) {
        result.add(new FilterConditionChecker<TagData>() {

            public boolean isIncluded(@NotNull final TagData item) {
                return FilterUtil.isIncludedByBooleanFilter(privateDimension, item.getOwner() != null);
            }
        });
    }
    final String ownerLocator = locator.getSingleDimensionValue(OWNER);
    if (ownerLocator != null) {
        final SUser user = myUserFinder.getItem(ownerLocator);
        result.add(new FilterConditionChecker<TagData>() {

            public boolean isIncluded(@NotNull final TagData item) {
                final SUser owner = item.getOwner();
                if (privateDimension == null && owner == null) {
                    // locator "private:any,owner:<user>" should return all public and private of the user (the defaults)
                    return true;
                }
                return user.equals(owner);
            }
        });
    }
    final String condition = locator.getSingleDimensionValue(CONDITION);
    if (condition != null) {
        final ValueCondition parameterCondition = ParameterCondition.createValueCondition(condition);
        result.add(new FilterConditionChecker<TagData>() {

            public boolean isIncluded(@NotNull final TagData item) {
                return parameterCondition.matches(item.getLabel());
            }
        });
    }
    return result;
}

Example 4 with SUser

use of jetbrains.buildServer.users.SUser in project teamcity-rest by JetBrains.

the class TestOccurrenceFinder method getPersonalBuildsFilter.

/**
 * Filters out personal builds by default.
 */
@NotNull
private Filter<STestRun> getPersonalBuildsFilter(@NotNull final Locator locator) {
    final boolean includePersonal = locator.getSingleDimensionValueAsStrictBoolean(INCLUDE_PERSONAL, false);
    if (!includePersonal) {
        locator.markUsed(INCLUDE_ALL_PERSONAL);
        return testRun -> !testRun.getBuild().isPersonal();
    }
    boolean includeAllPersonalPreference = false;
    SUser currentUser = (SUser) mySecurityContext.getAuthorityHolder().getAssociatedUser();
    if (currentUser != null) {
        String showAllPersonalBuildsPreferense = currentUser.getPropertyValue(StandardProperties.SHOW_ALL_PERSONAL_BUILDS);
        if (StringUtil.isTrue(showAllPersonalBuildsPreferense)) {
            includeAllPersonalPreference = true;
        }
    }
    boolean includeAllPersonal = locator.getSingleDimensionValueAsStrictBoolean(INCLUDE_ALL_PERSONAL, includeAllPersonalPreference);
    if (includeAllPersonal) {
        return testRun -> true;
    }
    if (currentUser == null) {
        return testRun -> !testRun.getBuild().isPersonal();
    }
    // noinspection ConstantConditions
    return testRun -> !testRun.getBuild().isPersonal() || currentUser.getId() == testRun.getBuild().getOwner().getId();
}

Example 5 with SUser

use of jetbrains.buildServer.users.SUser in project teamcity-rest by JetBrains.

the class BuildTest method testBuildOnAgentTriggering.

@Test
public void testBuildOnAgentTriggering() {
    myFixture.addService(new AgentRestrictorFactoryImpl());
    final MockBuildAgent agent2 = myFixture.createEnabledAgent("agent2", "Ant");
    final Build build = new Build();
    final BuildType buildType = new BuildType();
    buildType.setId(myBuildType.getExternalId());
    build.setBuildType(buildType);
    final Agent submittedAgent = new Agent();
    submittedAgent.id = agent2.getId();
    build.setAgent(submittedAgent);
    final SUser triggeringUser = getOrCreateUser("user");
    final SQueuedBuild queuedBuild = build.triggerBuild(triggeringUser, myFixture, new HashMap<Long, Long>());
    assertEquals(Integer.valueOf(agent2.getId()), queuedBuild.getBuildAgentId());
}