Java Repository类代码示例

import org.eclipse.che.plugin.pullrequest.shared.dto.Repository; //导入依赖的package包/类
/**
 * Converts an instance of {@link org.eclipse.che.ide.ext.bitbucket.shared.BitbucketRepository}
 * into a {@link Repository}.
 *
 * @param bitbucketRepository the Bitbucket repository to convert.
 * @return the corresponding {@link Repository} instance or {@code null} if given
 *     bitbucketRepository is {@code null}.
 */
private Repository valueOf(final BitbucketRepository bitbucketRepository) {
  if (bitbucketRepository == null) {
    return null;
  }

  final BitbucketRepository bitbucketRepositoryParent = bitbucketRepository.getParent();
  final Repository parent =
      bitbucketRepositoryParent == null
          ? null
          : dtoFactory
              .createDto(Repository.class)
              .withFork(bitbucketRepositoryParent.getParent() != null)
              .withName(bitbucketRepositoryParent.getName())
              .withParent(null)
              .withPrivateRepo(bitbucketRepositoryParent.isIsPrivate())
              .withCloneUrl(getParentCloneHttpsUrl(bitbucketRepositoryParent));

  return dtoFactory
      .createDto(Repository.class)
      .withFork(bitbucketRepositoryParent != null)
      .withName(bitbucketRepository.getName())
      .withParent(parent)
      .withPrivateRepo(bitbucketRepository.isIsPrivate())
      .withCloneUrl(getCloneHttpsUrl(bitbucketRepository));
}
 

import org.eclipse.che.plugin.pullrequest.shared.dto.Repository; //导入依赖的package包/类
@Override
public Promise<Repository> getUserFork(
    final String user, final String owner, final String repository) {
  return getForks(owner, repository)
      .thenPromise(
          new Function<List<Repository>, Promise<Repository>>() {
            @Override
            public Promise<Repository> apply(List<Repository> repositories)
                throws FunctionException {
              final Repository userFork = getUserFork(user, repositories);
              if (userFork != null) {
                return Promises.resolve(userFork);
              } else {
                return Promises.reject(JsPromiseError.create(new NoUserForkException(user)));
              }
            }
          });
}
 

import org.eclipse.che.plugin.pullrequest.shared.dto.Repository; //导入依赖的package包/类
/**
 * Returns the forks of the given repository for the given owner.
 *
 * @param owner the repository owner.
 * @param repository the repository name.
 * @param callback callback called when operation is done.
 */
private void getForks(
    @NotNull final String owner,
    @NotNull final String repository,
    @NotNull final AsyncCallback<List<Repository>> callback) {
  oAuthServiceClient
      .getToken(SERVICE_NAME.toLowerCase())
      .thenPromise(token -> gitHubClientService.getForks(token.getToken(), owner, repository))
      .then(
          gitHubRepositoryList -> {
            final List<Repository> repositories = new ArrayList<>();
            for (final GitHubRepository oneGitHubRepository :
                gitHubRepositoryList.getRepositories()) {
              repositories.add(valueOf(oneGitHubRepository));
            }
            callback.onSuccess(repositories);
          })
      .catchError(
          error -> {
            callback.onFailure(error.getCause());
          });
}
 

import org.eclipse.che.plugin.pullrequest.shared.dto.Repository; //导入依赖的package包/类
/**
 * Converts an instance of {@link org.eclipse.che.plugin.github.shared.GitHubRepository} into a
 * {@link Repository}.
 *
 * @param gitHubRepository the GitHub repository to convert.
 * @return the corresponding {@link Repository} instance or {@code null} if given gitHubRepository
 *     is {@code null}.
 */
private Repository valueOf(final GitHubRepository gitHubRepository) {
  if (gitHubRepository == null) {
    return null;
  }

  final GitHubRepository gitHubRepositoryParent = gitHubRepository.getParent();
  final Repository parent =
      gitHubRepositoryParent == null
          ? null
          : dtoFactory
              .createDto(Repository.class)
              .withFork(gitHubRepositoryParent.isFork())
              .withName(gitHubRepositoryParent.getName())
              .withParent(null)
              .withPrivateRepo(gitHubRepositoryParent.isPrivateRepo())
              .withCloneUrl(gitHubRepositoryParent.getCloneUrl());

  return dtoFactory
      .createDto(Repository.class)
      .withFork(gitHubRepository.isFork())
      .withName(gitHubRepository.getName())
      .withParent(parent)
      .withPrivateRepo(gitHubRepository.isPrivateRepo())
      .withCloneUrl(gitHubRepository.getCloneUrl());
}
 

import org.eclipse.che.plugin.pullrequest.shared.dto.Repository; //导入依赖的package包/类
@Override
public Promise<Repository> getRepository(String owner, String repositoryName) {
  return bitbucketClientService
      .getRepository(owner, repositoryName)
      .then(
          new Function<BitbucketRepository, Repository>() {
            @Override
            public Repository apply(BitbucketRepository bbRepo) throws FunctionException {
              return valueOf(bbRepo);
            }
          });
}
 

import org.eclipse.che.plugin.pullrequest.shared.dto.Repository; //导入依赖的package包/类
@Override
public Promise<Repository> getRepository(String owner, String repositoryName) {
  return microsoftClient
      .getRepository(account, collection, owner, repositoryName)
      .then(
          new Function<MicrosoftRepository, Repository>() {
            @Override
            public Repository apply(MicrosoftRepository msRepo) throws FunctionException {
              return valueOf(msRepo);
            }
          });
}
 

import org.eclipse.che.plugin.pullrequest.shared.dto.Repository; //导入依赖的package包/类
/**
 * Converts an instance of {@link
 * org.eclipse.che.ide.ext.microsoft.shared.dto.MicrosoftRepository} into a {@link Repository}.
 *
 * @param microsoftRepository the MicrosoftVstsRestClient repository to convert.
 * @return the corresponding {@link Repository} instance or {@code null} if given
 *     microsoftRepository is {@code null}.
 */
private Repository valueOf(final MicrosoftRepository microsoftRepository) {
  if (microsoftRepository == null) {
    return null;
  }

  return dtoFactory
      .createDto(Repository.class)
      .withFork(false)
      .withName(microsoftRepository.getName())
      .withParent(null)
      .withPrivateRepo(false)
      .withCloneUrl(microsoftRepository.getUrl());
}
 

import org.eclipse.che.plugin.pullrequest.shared.dto.Repository; //导入依赖的package包/类
@Override
public Promise<Repository> getRepository(String owner, String repositoryName) {
  return oAuthServiceClient
      .getToken(SERVICE_NAME.toLowerCase())
      .thenPromise(
          token -> gitHubClientService.getRepository(token.getToken(), owner, repositoryName))
      .then((Function<GitHubRepository, Repository>) this::valueOf);
}
 

import org.eclipse.che.plugin.pullrequest.shared.dto.Repository; //导入依赖的package包/类
@Override
public void execute(final WorkflowExecutor executor, final Context context) {
  final VcsHostingService hostingService = context.getVcsHostingService();
  hostingService
      .getRepository(context.getOriginRepositoryOwner(), context.getOriginRepositoryName())
      .then(
          new Operation<Repository>() {
            @Override
            public void apply(Repository repo) throws OperationException {
              if (repo.isFork()
                  && context
                      .getOriginRepositoryOwner()
                      .equalsIgnoreCase(context.getHostUserLogin())) {
                final String upstreamUrl = repo.getParent().getCloneUrl();
                context.setUpstreamRepositoryName(
                    hostingService.getRepositoryNameFromUrl(upstreamUrl));
                context.setUpstreamRepositoryOwner(
                    hostingService.getRepositoryOwnerFromUrl(upstreamUrl));
              } else {
                context.setUpstreamRepositoryName(context.getOriginRepositoryName());
                context.setUpstreamRepositoryOwner(context.getOriginRepositoryOwner());
              }
              executor.done(DetermineUpstreamRepositoryStep.this, context);
            }
          })
      .catchError(
          new Operation<PromiseError>() {
            @Override
            public void apply(PromiseError error) throws OperationException {
              notificationManager.notify(error.getMessage(), FAIL, FLOAT_MODE);
              executor.fail(DetermineUpstreamRepositoryStep.this, context, error.getMessage());
            }
          });
}
 

import org.eclipse.che.plugin.pullrequest.shared.dto.Repository; //导入依赖的package包/类
@Override
public void execute(final WorkflowExecutor executor, final Context context) {
  final String originRepositoryOwner = context.getOriginRepositoryOwner();
  final String originRepositoryName = context.getOriginRepositoryName();
  final String upstreamRepositoryOwner = context.getUpstreamRepositoryOwner();
  final String upstreamRepositoryName = context.getUpstreamRepositoryName();

  // the upstream repository has been cloned a fork must be created
  if (originRepositoryOwner.equalsIgnoreCase(upstreamRepositoryOwner)
      && originRepositoryName.equalsIgnoreCase(upstreamRepositoryName)) {

    context
        .getVcsHostingService()
        .getUserFork(context.getHostUserLogin(), upstreamRepositoryOwner, upstreamRepositoryName)
        .then(
            new Operation<Repository>() {
              @Override
              public void apply(Repository fork) throws OperationException {
                proceed(fork.getName(), executor, context);
              }
            })
        .catchError(
            new Operation<PromiseError>() {
              @Override
              public void apply(PromiseError error) throws OperationException {
                if (error.getCause() instanceof NoUserForkException) {
                  createFork(executor, context, upstreamRepositoryOwner, upstreamRepositoryName);
                  return;
                }

                executor.fail(CreateForkStep.this, context, error.getCause().getMessage());
              }
            });
  } else {
    // user fork has been cloned
    proceed(originRepositoryName, executor, context);
  }
}
 

import org.eclipse.che.plugin.pullrequest.shared.dto.Repository; //导入依赖的package包/类
private void createFork(
    final WorkflowExecutor executor,
    final Context context,
    final String upstreamRepositoryOwner,
    final String upstreamRepositoryName) {
  context
      .getVcsHostingService()
      .fork(upstreamRepositoryOwner, upstreamRepositoryName)
      .then(
          new Operation<Repository>() {
            @Override
            public void apply(Repository result) throws OperationException {
              proceed(result.getName(), executor, context);
            }
          })
      .catchError(
          new Operation<PromiseError>() {
            @Override
            public void apply(PromiseError err) throws OperationException {
              final String errorMessage =
                  messages.stepCreateForkErrorCreatingFork(
                      upstreamRepositoryOwner,
                      upstreamRepositoryName,
                      err.getCause().getMessage());
              executor.fail(CreateForkStep.this, context, errorMessage);
            }
          });
}
 

import org.eclipse.che.plugin.pullrequest.shared.dto.Repository; //导入依赖的package包/类
@Override
public Promise<Repository> fork(String owner, String repository) {
  return Promises.reject(JsPromiseError.create("Fork is not supported for " + getName()));
}
 

import org.eclipse.che.plugin.pullrequest.shared.dto.Repository; //导入依赖的package包/类
@Override
public Promise<Repository> getUserFork(
    final String user, final String owner, final String repository) {
  return Promises.reject(JsPromiseError.create("User forks is not supported for " + getName()));
}
 

import org.eclipse.che.plugin.pullrequest.shared.dto.Repository; //导入依赖的package包/类
/**
 * Forks the given repository for the current user.
 *
 * @param owner the repository owner.
 * @param repository the repository name.
 */
Promise<Repository> fork(String owner, String repository);
 

import org.eclipse.che.plugin.pullrequest.shared.dto.Repository; //导入依赖的package包/类
/**
 * Returns the promise which either resolves repository or rejects with an error.
 *
 * @param owner the owner of the repositoryName
 * @param repositoryName the name of the repository
 */
Promise<Repository> getRepository(String owner, String repositoryName);