public async Task CanGetAllInvitations()
            {
                var github   = Helper.GetAuthenticatedClient();
                var repoName = Helper.MakeNameWithTimestamp("public-repo");

                using (var context = await github.CreateRepositoryContext(new NewRepository(repoName)))
                {
                    var fixture    = github.Repository.Collaborator;
                    var permission = new CollaboratorRequest(Permission.Push);

                    // invite a collaborator
                    var response = await fixture.Invite(context.RepositoryOwner, context.RepositoryName, owner, permission);

                    Assert.Equal(owner, response.Invitee.Login);
                    Assert.Equal(InvitationPermissionType.Write, response.Permissions);

                    var invitations = await github.Repository.Invitation.GetAllForRepository(context.Repository.Id);

                    Assert.Equal(1, invitations.Count);
                    Assert.Equal(invitations[0].CreatedAt, response.CreatedAt);
                    Assert.Equal(invitations[0].Id, response.Id);
                    Assert.Equal(invitations[0].Invitee.Login, response.Invitee.Login);
                    Assert.Equal(invitations[0].Inviter.Login, response.Inviter.Login);
                    Assert.Equal(invitations[0].Permissions, response.Permissions);
                    Assert.Equal(invitations[0].Repository.Id, response.Repository.Id);
                }
            }
Example #2
0
 public IActionResult RemoveCollaborator(int noteID, CollaboratorRequest collaborator)
 {
     try
     {
         bool   success = false;
         string message;
         var    idClaim = HttpContext.User.Claims.FirstOrDefault(id => id.Type.Equals("id", StringComparison.InvariantCultureIgnoreCase));
         int    userID  = Convert.ToInt32(idClaim.Value);
         bool   data    = _userNoteBusiness.RemoveCollaborator(noteID, collaborator);
         if (data)
         {
             success = true;
             message = "Collaborator Removed Successfully";
             return(Ok(new { success, message }));
         }
         else
         {
             message = "Enter Proper Collaborator ID";
             return(NotFound(new { success, message }));
         }
     }
     catch (Exception ex)
     {
         return(BadRequest(new { ex.Message }));
     }
 }
        public async Task ReturnsCorrectCountOfInvitationsWithoutStart()
        {
            var collaborator = Helper.CredentialsSecondUser.Login;
            var github       = Helper.GetAuthenticatedClient();
            var repoName     = Helper.MakeNameWithTimestamp("public-repo");

            using (var context = await github.CreateRepositoryContext(new NewRepository(repoName)))
            {
                var fixture    = github.Repository.Collaborator;
                var permission = new CollaboratorRequest(Permission.Push);

                // invite a collaborator
                var response = await fixture.Invite(context.RepositoryOwner, context.RepositoryName, collaborator, permission);

                Assert.Equal(collaborator, response.Invitee.Login);
                Assert.Equal(InvitationPermissionType.Write, response.Permissions);

                var options = new ApiOptions
                {
                    PageSize  = 1,
                    PageCount = 1,
                };

                var invitations = await github.Repository.Invitation.GetAllForRepository(context.Repository.Id, options);

                Assert.Equal(1, invitations.Count);
            }
        }
Example #4
0
        /// <summary>
        /// Adds a new collaborator to the repository.
        /// </summary>
        /// <remarks>
        /// See the <a href="http://developer.github.com/v3/repos/collaborators/#list">API documentation</a> for more information.
        /// </remarks>
        /// <param name="repositoryId">The id of the repository</param>
        /// <param name="user">Username of the new collaborator</param>
        /// <param name="permission">The permission to set. Only valid on organization-owned repositories.</param>
        /// <exception cref="ApiException">Thrown when a general API error occurs.</exception>
        public IObservable <bool> Add(long repositoryId, string user, CollaboratorRequest permission)
        {
            Ensure.ArgumentNotNullOrEmptyString(user, nameof(user));
            Ensure.ArgumentNotNull(permission, nameof(permission));

            return(_client.Add(repositoryId, user, permission).ToObservable());
        }
            public async Task CanUpdateInvitation()
            {
                var github = Helper.GetAuthenticatedClient();

                var repoName = Helper.MakeNameWithTimestamp("public-repo");

                using (var context = await github.CreateRepositoryContext(new NewRepository(repoName)))
                {
                    var fixture    = github.Repository.Collaborator;
                    var permission = new CollaboratorRequest(Permission.Push);

                    // invite a collaborator
                    var response = await fixture.Invite(context.RepositoryOwner, context.RepositoryName, context.RepositoryOwner, permission);

                    Assert.Equal(context.RepositoryOwner, response.Invitee.Login);
                    Assert.Equal(InvitationPermissionType.Write, response.Permissions);

                    var updatedInvitation = new InvitationUpdate(InvitationPermissionType.Admin);

                    var update = await github.Repository.Invitation.Edit(response.Repository.Id, response.Id, updatedInvitation);

                    Assert.Equal(updatedInvitation.Permissions, update.Permissions);
                    Assert.Equal(response.Id, update.Id);
                    Assert.Equal(response.Repository.Id, update.Repository.Id);
                    Assert.Equal(response.Invitee.Login, update.Invitee.Login);
                    Assert.Equal(response.Inviter.Login, update.Inviter.Login);
                }
            }
            public async Task CanGetAllInvitations()
            {
                var github   = Helper.GetAuthenticatedClient();
                var repoName = Helper.MakeNameWithTimestamp("public-repo");

                using (var context = await github.CreateRepositoryContext(new NewRepository(repoName)))
                {
                    var fixture    = github.Repository.Collaborator;
                    var permission = new CollaboratorRequest(Permission.Push);

                    // invite a collaborator
                    var response = await fixture.Invite(context.RepositoryOwner, context.RepositoryName, context.RepositoryOwner, permission);

                    Assert.Equal(context.RepositoryOwner, response.Invitee.Login);
                    Assert.Equal(InvitationPermissionType.Write, response.Permissions);

                    var invitations = await github.Repository.Invitation.GetAllForCurrent();

                    Assert.True(invitations.Count >= 1);
                    Assert.NotNull(invitations.FirstOrDefault(i => i.CreatedAt == response.CreatedAt));
                    Assert.NotNull(invitations.FirstOrDefault(i => i.Id == response.Id));
                    Assert.NotNull(invitations.FirstOrDefault(i => i.Inviter.Login == response.Inviter.Login));
                    Assert.NotNull(invitations.FirstOrDefault(i => i.Invitee.Login == response.Invitee.Login));
                    Assert.NotNull(invitations.FirstOrDefault(i => i.Permissions == response.Permissions));
                    Assert.NotNull(invitations.FirstOrDefault(i => i.Repository.Id == response.Repository.Id));
                }
            }
            public void EnsuresNonEmptyArguments()
            {
                SetupWithNonReactiveClient();
                var permission = new CollaboratorRequest(Permission.Push);

                Assert.Throws <ArgumentException>(() => _client.Invite("", "repo", "user", permission));
                Assert.Throws <ArgumentException>(() => _client.Invite("owner", "", "user", permission));
                Assert.Throws <ArgumentException>(() => _client.Invite("owner", "repo", "", permission));
            }
Example #8
0
        /// <summary>
        /// Adds a new collaborator to the repository.
        /// </summary>
        /// <remarks>
        /// See the <a href="http://developer.github.com/v3/repos/collaborators/#add-collaborator">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="user">Username of the new collaborator</param>
        /// <param name="permission">The permission to set. Only valid on organization-owned repositories.</param>
        /// <exception cref="ApiException">Thrown when a general API error occurs.</exception>
        public IObservable <bool> Add(string owner, string name, string user, CollaboratorRequest permission)
        {
            Ensure.ArgumentNotNullOrEmptyString(owner, nameof(owner));
            Ensure.ArgumentNotNullOrEmptyString(name, nameof(name));
            Ensure.ArgumentNotNullOrEmptyString(user, nameof(user));
            Ensure.ArgumentNotNull(permission, nameof(permission));

            return(_client.Add(owner, name, user, permission).ToObservable());
        }
            public void RequestsCorrectUrl()
            {
                var connection = Substitute.For <IApiConnection>();
                var client     = new RepoCollaboratorsClient(connection);

                var permission = new CollaboratorRequest(Permission.Push);

                client.Invite("owner", "test", "user1", permission);
                connection.Received().Put <RepositoryInvitation>(Arg.Is <Uri>(u => u.ToString() == "repos/owner/test/collaborators/user1"), Arg.Is <CollaboratorRequest>(permission), Arg.Any <string>(), Arg.Is <string>("application/vnd.github.swamp-thing-preview+json"));
            }
            public void CallsInviteOnRegularDeploymentsClient()
            {
                SetupWithoutNonReactiveClient();
                var permission = new CollaboratorRequest(Permission.Push);

                _client.Invite("owner", "repo", "user", permission);

                _githubClient.Repository.Collaborator.Received(1).Invite(Arg.Is("owner"),
                                                                         Arg.Is("repo"),
                                                                         Arg.Is("user"),
                                                                         Arg.Is(permission));
            }
            public async Task EnsuresNonWhitespaceArguments()
            {
                SetupWithNonReactiveClient();
                var permission = new CollaboratorRequest(Permission.Push);

                await AssertEx.ThrowsWhenGivenWhitespaceArgument(
                    async whitespace => await _client.Invite(whitespace, "repo", "user", permission));

                await AssertEx.ThrowsWhenGivenWhitespaceArgument(
                    async whitespace => await _client.Invite("owner", whitespace, "user", permission));

                await AssertEx.ThrowsWhenGivenWhitespaceArgument(
                    async whitespace => await _client.Invite("owner", "repo", whitespace, permission));
            }
        public async Task ReturnsCorrectCountOfInvitationsWithStart()
        {
            var github    = Helper.GetAuthenticatedClient();
            var repoNames = Enumerable.Range(0, 2).Select(i => Helper.MakeNameWithTimestamp($"public-repo{i}")).ToList();

            var contexts = new List <RepositoryContext>();

            try
            {
                foreach (var repoName in repoNames)
                {
                    contexts.Add(await github.CreateRepositoryContext(new NewRepository(repoName)));
                }
                var fixture    = github.Repository.Collaborator;
                var permission = new CollaboratorRequest(Permission.Push);

                // invite a collaborator to all repos
                foreach (var context in contexts)
                {
                    var response = await fixture.Invite(context.RepositoryOwner, context.RepositoryName, context.RepositoryOwner, permission);

                    Assert.Equal(context.RepositoryOwner, response.Invitee.Login);
                    Assert.Equal(InvitationPermissionType.Write, response.Permissions);
                }

                var startOptions = new ApiOptions
                {
                    PageSize  = 1,
                    PageCount = 1,
                    StartPage = 2
                };


                var invitations = await github.Repository.Invitation.GetAllForCurrent(startOptions);

                Assert.Equal(1, invitations.Count);
            }
            finally
            {
                if (contexts != null)
                {
                    foreach (var context in contexts)
                    {
                        context?.Dispose();
                    }
                }
            }
        }
            public async Task EnsuresNonNullArguments()
            {
                var client     = new RepoCollaboratorsClient(Substitute.For <IApiConnection>());
                var permission = new CollaboratorRequest(Permission.Push);

                await Assert.ThrowsAsync <ArgumentNullException>(() => client.Invite(null, "test", "user1", permission));

                await Assert.ThrowsAsync <ArgumentException>(() => client.Invite("", "test", "user1", permission));

                await Assert.ThrowsAsync <ArgumentNullException>(() => client.Invite("owner", null, "user1", permission));

                await Assert.ThrowsAsync <ArgumentException>(() => client.Invite("owner", "", "user1", permission));

                await Assert.ThrowsAsync <ArgumentException>(() => client.Invite("owner", "test", "", permission));

                await Assert.ThrowsAsync <ArgumentNullException>(() => client.Invite("owner", "test", null, permission));

                await Assert.ThrowsAsync <ArgumentNullException>(() => client.Invite("owner", "test", "user1", null));
            }
        public async Task ReturnsDistinctInvitationsBasedOnStart()
        {
            var collaborator1 = Helper.CredentialsSecondUser.Login;
            var github        = Helper.GetAuthenticatedClient();
            var repoName      = Helper.MakeNameWithTimestamp("public-repo");

            using (var context = await github.CreateRepositoryContext(new NewRepository(repoName)))
            {
                var fixture    = github.Repository.Collaborator;
                var permission = new CollaboratorRequest(Permission.Push);

                // invite a collaborator
                var response1 = await fixture.Invite(context.RepositoryOwner, context.RepositoryName, collaborator1, permission);

                Assert.Equal(collaborator1, response1.Invitee.Login);
                Assert.Equal(InvitationPermissionType.Write, response1.Permissions);

                var response2 = await fixture.Invite(context.RepositoryOwner, context.RepositoryName, context.RepositoryOwner, permission);

                Assert.Equal(context.RepositoryOwner, response2.Invitee.Login);
                Assert.Equal(InvitationPermissionType.Write, response2.Permissions);

                var startOptions = new ApiOptions
                {
                    PageSize  = 1,
                    PageCount = 1
                };

                var skipStartOptions = new ApiOptions
                {
                    PageSize  = 1,
                    PageCount = 1,
                    StartPage = 2
                };

                var firstInvitations = await github.Repository.Invitation.GetAllForRepository(context.Repository.Id, startOptions);

                var secondInvitations = await github.Repository.Invitation.GetAllForRepository(context.Repository.Id, skipStartOptions);

                Assert.NotEqual(firstInvitations[0].Invitee.Login, secondInvitations[0].Invitee.Login);
            }
        }
 public bool RemoveCollaborator(int noteID, CollaboratorRequest collaborator)
 {
     try
     {
         var collaboratorsData = _context.Collaborators.
                                 Where(collab => collab.UserID == collaborator.UserID && collab.NoteID == noteID).FirstOrDefault();
         if (collaboratorsData != null)
         {
             _context.Remove(collaboratorsData);
             _context.SaveChanges();
             return(true);
         }
         else
         {
             return(false);
         }
     }
     catch (Exception ex)
     {
         throw new Exception(ex.Message);
     }
 }
Example #16
0
        /// <summary>
        /// Invites a user as a collaborator to a repository.
        /// </summary>
        /// <remarks>
        /// See the <a href="http://developer.github.com/v3/repos/collaborators/#list">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="user">The username of the prospective collaborator</param>
        /// <param name="permission">The permission to set. Only valid on organization-owned repositories.</param>
        public IObservable <RepositoryInvitation> Invite(string owner, string name, string user, CollaboratorRequest permission)
        {
            Ensure.ArgumentNotNullOrEmptyString(owner, nameof(owner));
            Ensure.ArgumentNotNullOrEmptyString(name, nameof(name));
            Ensure.ArgumentNotNullOrEmptyString(user, nameof(user));
            Ensure.ArgumentNotNull(permission, nameof(permission));

            return(_client.Invite(owner, name, user, permission).ToObservable());
        }
        public bool RemoveCollaborator(int noteID, CollaboratorRequest collaborator)
        {
            bool data = _userNoteRepository.RemoveCollaborator(noteID, collaborator);

            return(data);
        }
        /// <summary>
        /// Adds a new collaborator to the repository.
        /// </summary>
        /// <remarks>
        /// See the <a href="http://developer.github.com/v3/repos/collaborators/#list">API documentation</a> for more information.
        /// </remarks>
        /// <param name="repositoryId">The id of the repository</param>
        /// <param name="user">Username of the new collaborator</param>
        /// <param name="permission">The permission to set. Only valid on organization-owned repositories.</param>
        /// <exception cref="ApiException">Thrown when a general API error occurs.</exception>
        public IObservable<bool> Add(long repositoryId, string user, CollaboratorRequest permission)
        {
            Ensure.ArgumentNotNullOrEmptyString(user, "user");
            Ensure.ArgumentNotNull(permission, "permission");

            return _client.Add(repositoryId, user, permission).ToObservable();
        }
        /// <summary>
        /// Invites a user as a collaborator to a repository.
        /// </summary>
        /// <remarks>
        /// See the <a href="http://developer.github.com/v3/repos/collaborators/#list">API documentation</a> for more information.
        /// </remarks>
        /// <param name="repositoryId">The id of the repository</param>
        /// <param name="user">The username of the prospective collaborator</param>
        /// <param name="permission">The permission to set. Only valid on organization-owned repositories.</param>
        public IObservable <RepositoryInvitation> Invite(long repositoryId, string user, CollaboratorRequest permission)
        {
            Ensure.ArgumentNotNullOrEmptyString(user, "user");
            Ensure.ArgumentNotNull(permission, "psermission");

            return(_client.Invite(repositoryId, user, permission).ToObservable());
        }
        /// <summary>
        /// Invites a user as a collaborator to a repository.
        /// </summary>
        /// <remarks>
        /// See the <a href="http://developer.github.com/v3/repos/collaborators/#list">API documentation</a> for more information.
        /// </remarks>
        /// <param name="repositoryId">The id of the repository</param>
        /// <param name="user">The username of the prospective collaborator</param>   
        /// <param name="permission">The permission to set. Only valid on organization-owned repositories.</param>
        public IObservable<RepositoryInvitation> Invite(int repositoryId, string user, CollaboratorRequest permission)
        {
            Ensure.ArgumentNotNullOrEmptyString(user, "user");
            Ensure.ArgumentNotNull(permission, "psermission");

            return _client.Invite(repositoryId, user, permission).ToObservable();
        }
        /// <summary>
        /// Invites a user as a collaborator to a repository.
        /// </summary>
        /// <remarks>
        /// See the <a href="http://developer.github.com/v3/repos/collaborators/#list">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="user">The username of the prospective collaborator</param>
        /// <param name="permission">The permission to set. Only valid on organization-owned repositories.</param>
        public IObservable<RepositoryInvitation> Invite(string owner, string name, string user, CollaboratorRequest permission)
        {
            Ensure.ArgumentNotNullOrEmptyString(owner, "owner");
            Ensure.ArgumentNotNullOrEmptyString(name, "name");
            Ensure.ArgumentNotNullOrEmptyString(user, "user");
            Ensure.ArgumentNotNull(permission, "psermission");

            return _client.Invite(owner, name, user, permission).ToObservable();
        }
        /// <summary>
        /// Adds a new collaborator to the repository.
        /// </summary>
        /// <remarks>
        /// See the <a href="http://developer.github.com/v3/repos/collaborators/#add-collaborator">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="user">Username of the new collaborator</param>
        /// <param name="permission">The permission to set. Only valid on organization-owned repositories.</param>
        /// <exception cref="ApiException">Thrown when a general API error occurs.</exception>
        public IObservable<bool> Add(string owner, string name, string user, CollaboratorRequest permission)
        {
            Ensure.ArgumentNotNullOrEmptyString(owner, "owner");
            Ensure.ArgumentNotNullOrEmptyString(name, "name");
            Ensure.ArgumentNotNullOrEmptyString(user, "user");
            Ensure.ArgumentNotNull(permission, "permission");

            return _client.Add(owner, name, user, permission).ToObservable();
        }
            public void CallsInviteOnRegularDeploymentsClient()
            {
                SetupWithoutNonReactiveClient();
                var permission = new CollaboratorRequest(Permission.Push);

                _client.Invite("owner", "repo", "user", permission);

                _githubClient.Repository.Collaborator.Received(1).Invite(Arg.Is("owner"),
                    Arg.Is("repo"),
                    Arg.Is("user"),
                    Arg.Is(permission));
            }
            public async Task EnsuresNonWhitespaceArguments()
            {
                SetupWithNonReactiveClient();
                var permission = new CollaboratorRequest(Permission.Push);

                await AssertEx.ThrowsWhenGivenWhitespaceArgument(
                    async whitespace => await _client.Invite(whitespace, "repo", "user", permission));
                await AssertEx.ThrowsWhenGivenWhitespaceArgument(
                    async whitespace => await _client.Invite("owner", whitespace, "user", permission));
                await AssertEx.ThrowsWhenGivenWhitespaceArgument(
                    async whitespace => await _client.Invite("owner", "repo", whitespace, permission));
            }
            public async Task EnsuresNonNullArguments()
            {
                var client = new RepoCollaboratorsClient(Substitute.For<IApiConnection>());
                var permission = new CollaboratorRequest(Permission.Push);

                await Assert.ThrowsAsync<ArgumentNullException>(() => client.Invite(null, "test", "user1", permission));
                await Assert.ThrowsAsync<ArgumentException>(() => client.Invite("", "test", "user1", permission));
                await Assert.ThrowsAsync<ArgumentNullException>(() => client.Invite("owner", null, "user1", permission));
                await Assert.ThrowsAsync<ArgumentException>(() => client.Invite("owner", "", "user1", permission));
                await Assert.ThrowsAsync<ArgumentException>(() => client.Invite("owner", "test", "", permission));
                await Assert.ThrowsAsync<ArgumentNullException>(() => client.Invite("owner", "test", null, permission));
                await Assert.ThrowsAsync<ArgumentNullException>(() => client.Invite("owner", "test", "user1", null));
            }
        public async Task ReturnsDistinctInvitationsBasedOnStart()
        {
            var github    = Helper.GetAuthenticatedClient();
            var repoNames = Enumerable.Range(0, 2).Select(i => Helper.MakeNameWithTimestamp($"public-repo{i}")).ToList();

            var contexts = new List <RepositoryContext>();

            try
            {
                foreach (var repoName in repoNames)
                {
                    contexts.Add(await github.CreateRepositoryContext(new NewRepository(repoName)));
                }
                var fixture    = github.Repository.Collaborator;
                var permission = new CollaboratorRequest(Permission.Push);

                // invite a collaborator to all repos
                foreach (var context in contexts)
                {
                    var response = await fixture.Invite(context.RepositoryOwner, context.RepositoryName, context.RepositoryOwner, permission);

                    Assert.Equal(context.RepositoryOwner, response.Invitee.Login);
                    Assert.Equal(InvitationPermissionType.Write, response.Permissions);
                }

                var startOptions = new ApiOptions
                {
                    PageSize  = 1,
                    PageCount = 1
                };

                var skipStartOptions = new ApiOptions
                {
                    PageSize  = 1,
                    PageCount = 1,
                    StartPage = 2
                };

                var firstInvitations = await github.Repository.Invitation.GetAllForCurrent(startOptions);

                var secondInvitations = await github.Repository.Invitation.GetAllForCurrent(skipStartOptions);

                var invitations       = firstInvitations.Concat(secondInvitations).ToArray();
                var invitationsLength = invitations.Length;
                for (int i = 0; i < invitationsLength; i++)
                {
                    for (int j = i + 1; j < invitationsLength; j++)
                    {
                        Assert.NotEqual(invitations[i].Repository.FullName, invitations[j].Repository.FullName);
                    }
                }
            }
            finally
            {
                if (contexts != null)
                {
                    foreach (var context in contexts)
                    {
                        context?.Dispose();
                    }
                }
            }
        }
            public void EnsuresNonEmptyArguments()
            {
                SetupWithNonReactiveClient();
                var permission = new CollaboratorRequest(Permission.Push);

                Assert.Throws<ArgumentException>(() => _client.Invite("", "repo", "user", permission));
                Assert.Throws<ArgumentException>(() => _client.Invite("owner", "", "user", permission));
                Assert.Throws<ArgumentException>(() => _client.Invite("owner", "repo", "", permission));
            }
            public void RequestsCorrectUrl()
            {
                var connection = Substitute.For<IApiConnection>();
                var client = new RepoCollaboratorsClient(connection);

                var permission = new CollaboratorRequest(Permission.Push);

                client.Invite("owner", "test", "user1", permission);
                connection.Received().Put<RepositoryInvitation>(Arg.Is<Uri>(u => u.ToString() == "repos/owner/test/collaborators/user1"), Arg.Is<CollaboratorRequest>(permission), Arg.Any<string>(), Arg.Is<string>("application/vnd.github.swamp-thing-preview+json"));
            }