/// <summary>
        /// Creates a fork for a repository. Specify organization in the fork parameter to create for an organization.
        /// </summary>
        /// <remarks>See <a href="http://developer.github.com/v3/repos/forks/#create-a-fork">API documentation</a> for more information.</remarks>
        /// <returns></returns>
        public IObservable<Repository> Create(string owner, string repositoryName, NewRepositoryFork fork)
        {
            Ensure.ArgumentNotNullOrEmptyString(owner, "owner");
            Ensure.ArgumentNotNullOrEmptyString(repositoryName, "repositoryName");
            Ensure.ArgumentNotNull(fork, "fork");

            return _client.Create(owner, repositoryName, fork).ToObservable();
        }
        /// <summary>
        /// Creates a fork for a repository. Specify organization in the fork parameter to create for an organization.
        /// </summary>
        /// <remarks>See <a href="http://developer.github.com/v3/repos/forks/#create-a-fork">API documentation</a> for more information.</remarks>
        /// <returns></returns>
        public IObservable <Repository> Create(string owner, string repositoryName, NewRepositoryFork fork)
        {
            Ensure.ArgumentNotNullOrEmptyString(owner, "owner");
            Ensure.ArgumentNotNullOrEmptyString(repositoryName, "repositoryName");
            Ensure.ArgumentNotNull(fork, "fork");

            return(_client.Create(owner, repositoryName, fork).ToObservable());
        }
Пример #3
0
        /// <summary>
        /// Creates a fork for a repository. Specify organization in the fork parameter to create for an organization.
        /// </summary>
        /// <remarks>
        /// See <a href="http://developer.github.com/v3/repos/forks/#create-a-fork">API documentation</a> for more information.
        /// </remarks>
        /// <param name="owner">The owner of the repository</param>
        /// <param name="name">The name of the repository</param>
        /// <param name="fork">Used to fork a repository</param>
        public IObservable <Repository> Create(string owner, string name, NewRepositoryFork fork)
        {
            Ensure.ArgumentNotNullOrEmptyString(owner, nameof(owner));
            Ensure.ArgumentNotNullOrEmptyString(name, nameof(name));
            Ensure.ArgumentNotNull(fork, nameof(fork));

            return(_client.Create(owner, name, fork).ToObservable());
        }
            public void RequestsCorrectUrl()
            {
                var connection        = Substitute.For <IApiConnection>();
                var client            = new RepositoriesClient(connection);
                var newRepositoryFork = new NewRepositoryFork();

                client.Forks.Create("fake", "repo", newRepositoryFork);

                connection.Received().Post <Repository>(Arg.Is <Uri>(u => u.ToString() == "repos/fake/repo/forks"), newRepositoryFork);
            }
Пример #5
0
        public IObservable<Repository> ForkRepository(string owner, string name, NewRepositoryFork repository)
        {
            Guard.ArgumentNotEmptyString(owner, nameof(owner));
            Guard.ArgumentNotEmptyString(name, nameof(name));
            Guard.ArgumentNotNull(repository, nameof(repository));

            var client = gitHubClient.Repository.Forks;

            return client.Create(owner, name, repository);
        }
            public void UsesTheSuppliedHook()
            {
                var connection = Substitute.For<IApiConnection>();
                var client = new RepositoriesClient(connection);
                var newRepositoryFork = new NewRepositoryFork { Organization = "aName" };

                client.Forks.Create("owner", "repo", newRepositoryFork);

                connection.Received().Post<Repository>(Arg.Any<Uri>(), newRepositoryFork);
            }
            public void RequestsCorrectUrl()
            {
                var connection = Substitute.For<IApiConnection>();
                var client = new RepositoriesClient(connection);
                var newRepositoryFork = new NewRepositoryFork();

                client.Forks.Create("fake", "repo", newRepositoryFork);

                connection.Received().Post<Repository>(Arg.Is<Uri>(u => u.ToString() == "repos/fake/repo/forks"), newRepositoryFork);
            }
Пример #8
0
            public void RequestsCorrectUrl()
            {
                var gitHubClient = Substitute.For <IGitHubClient>();
                var client       = new ObservableRepositoryForksClient(gitHubClient);

                var newRepositoryFork = new NewRepositoryFork();

                client.Create("fake", "repo", newRepositoryFork);

                gitHubClient.Received().Repository.Forks.Create("fake", "repo", newRepositoryFork);
            }
            public void UsesTheSuppliedHook()
            {
                var connection        = Substitute.For <IApiConnection>();
                var client            = new RepositoriesClient(connection);
                var newRepositoryFork = new NewRepositoryFork {
                    Organization = "aName"
                };

                client.Forks.Create("owner", "repo", newRepositoryFork);

                connection.Received().Post <Repository>(Arg.Any <Uri>(), newRepositoryFork);
            }
        IObservable <Repository> OnCreateFork()
        {
            var newRepositoryFork = new NewRepositoryFork
            {
                Organization = !DestinationAccount.IsUser ? DestinationAccount.Login : null
            };

            return(repositoryForkService
                   .ForkRepository(apiClient, SourceRepository, newRepositoryFork, UpdateOrigin, CanAddUpstream && AddUpstream, CanResetMasterTracking && ResetMasterTracking)
                   .Catch <Repository, Exception>(ex =>
            {
                log.Error(ex, "Error Creating Fork");

                var apiEx = ex as ApiException;
                Error = apiEx != null ? apiEx.Message : "An unexpected error occurred.";

                return Observable.Return <Repository>(null);
            }));
        }
        /// <summary>
        /// Creates a fork for a repository. Specify organization in the fork parameter to create for an organization.
        /// </summary>
        /// <remarks>
        /// See <a href="http://developer.github.com/v3/repos/forks/#create-a-fork">API documentation</a> for more information.
        /// </remarks>
        /// <param name="repositoryId">The Id of the repository</param>
        /// <param name="fork">Used to fork a repository</param>
        public IObservable<Repository> Create(int repositoryId, NewRepositoryFork fork)
        {
            Ensure.ArgumentNotNull(fork, "fork");

            return _client.Create(repositoryId, fork).ToObservable();
        }
        /// <summary>
        /// Creates a fork for a repository. Specify organization in the fork parameter to create for an organization.
        /// </summary>
        /// <remarks>
        /// See <a href="http://developer.github.com/v3/repos/forks/#create-a-fork">API documentation</a> for more information.
        /// </remarks>
        /// <param name="repositoryId">The Id of the repository</param>
        /// <param name="fork">Used to fork a repository</param>
        public IObservable <Repository> Create(long repositoryId, NewRepositoryFork fork)
        {
            Ensure.ArgumentNotNull(fork, "fork");

            return(_client.Create(repositoryId, fork).ToObservable());
        }
Пример #13
0
        public IObservable <Repository> ForkRepository(IApiClient apiClient, IRepositoryModel sourceRepository, NewRepositoryFork repositoryFork, bool updateOrigin, bool addUpstream, bool trackMasterUpstream)
        {
            log.Verbose("ForkRepository Source:{SourceOwner}/{SourceName} To:{DestinationOwner}", sourceRepository.Owner, sourceRepository.Name, repositoryFork.Organization ?? "[Current User]");
            log.Verbose("ForkRepository updateOrigin:{UpdateOrigin} addUpstream:{AddUpstream} trackMasterUpstream:{TrackMasterUpstream}", updateOrigin, addUpstream, trackMasterUpstream);

            usageTracker.IncrementCounter(model => model.NumberOfReposForked).Forget();

            return(Observable.Defer(() => apiClient.ForkRepository(sourceRepository.Owner, sourceRepository.Name, repositoryFork)
                                    .ObserveOn(RxApp.MainThreadScheduler)
                                    .Select(remoteRepo => new { RemoteRepo = remoteRepo, ActiveRepo = updateOrigin ? vsGitServices.GetActiveRepo() : null }))
                   .SelectMany(async repo =>
            {
                if (repo.ActiveRepo != null)
                {
                    using (repo.ActiveRepo)
                    {
                        var originUri = repo.RemoteRepo != null ? new Uri(repo.RemoteRepo.CloneUrl) : null;
                        var upstreamUri = addUpstream ? sourceRepository.CloneUrl.ToUri() : null;

                        await SwitchRemotes(repo.ActiveRepo, originUri, upstreamUri, trackMasterUpstream);
                    }
                }

                return repo.RemoteRepo;
            }));
        }
            public void RequestsCorrectUrlWithRepositoryId()
            {
                var gitHubClient = Substitute.For<IGitHubClient>();
                var client = new ObservableRepositoryForksClient(gitHubClient);

                var newRepositoryFork = new NewRepositoryFork();

                client.Create(1, newRepositoryFork);

                gitHubClient.Received().Repository.Forks.Create(1, newRepositoryFork);
            }