Merge pull request #1099 from TattsGroup/enterprise-ldap-api

Implement GitHub Enterprise LDAP API

Octokit.Reactive/Clients/Enterprise/IObservableEnterpriseClient.cs

@@ -16,6 +16,14 @@
         ///</remarks>
         IObservableEnterpriseAdminStatsClient AdminStats { get; }
 
+        /// <summary>
+        /// A client for GitHub's Enterprise LDAP API
+        /// </summary>
+        /// <remarks>
+        /// See the <a href="https://developer.github.com/v3/enterprise/ldap/">Enterprise LDAP API documentation</a> for more information.
+        ///</remarks>
+        IObservableEnterpriseLdapClient Ldap { get; }
+
         /// <summary>
         /// A client for GitHub's Enterprise License API
         /// </summary>

Octokit.Reactive/Clients/Enterprise/IObservableEnterpriseLdapClient.cs

@@ -0,0 +1,58 @@
+using System;
+using System.Diagnostics.CodeAnalysis;
+using System.Reactive;
+using System.Reactive.Threading.Tasks;
+
+namespace Octokit.Reactive
+{
+    /// <summary>
+    /// A client for GitHub's Enterprise LDAP API
+    /// </summary>
+    /// <remarks>
+    /// See the <a href="https://developer.github.com/v3/enterprise/ldap/">Enterprise LDAP API documentation</a> for more information.
+    ///</remarks>
+    public interface IObservableEnterpriseLdapClient
+    {
+        /// <summary>
+        /// Update the LDAP mapping for a user on a GitHub Enterprise appliance (must be Site Admin user).
+        /// </summary>
+        /// <remarks>
+        /// https://developer.github.com/v3/enterprise/ldap/#update-ldap-mapping-for-a-user
+        /// </remarks>
+        /// <param name="userName">The username to update LDAP mapping</param>
+        /// <param name="newLdapMapping">The <see cref="NewLdapMapping"/></param>
+        /// <returns>The <see cref="User"/> object.</returns>
+        IObservable<User> UpdateUserMapping(string userName, NewLdapMapping newLdapMapping);
+
+        /// <summary>
+        /// Queue an LDAP Sync job for a user on a GitHub Enterprise appliance (must be Site Admin user).
+        /// </summary>
+        /// <remarks>
+        /// https://developer.github.com/v3/enterprise/ldap/#sync-ldap-mapping-for-a-user
+        /// </remarks>
+        /// <param name="userName">The username to sync LDAP mapping</param>
+        /// <returns>The <see cref="LdapSyncResponse"/> of the queue request.</returns>
+        IObservable<LdapSyncResponse> QueueSyncUserMapping(string userName);
+        
+        /// <summary>
+        /// Update the LDAP mapping for a team on a GitHub Enterprise appliance (must be Site Admin user).
+        /// </summary>
+        /// <remarks>
+        /// https://developer.github.com/v3/enterprise/ldap/#update-ldap-mapping-for-a-team
+        /// </remarks>
+        /// <param name="teamId">The teamId to update LDAP mapping</param>
+        /// <param name="newLdapMapping">The <see cref="NewLdapMapping"/></param>
+        /// <returns>The <see cref="Team"/> object.</returns>
+        IObservable<Team> UpdateTeamMapping(int teamId, NewLdapMapping newLdapMapping);
+
+        /// <summary>
+        /// Queue an LDAP Sync job for a team on a GitHub Enterprise appliance (must be Site Admin user).
+        /// </summary>
+        /// <remarks>
+        /// https://developer.github.com/v3/enterprise/ldap/#sync-ldap-mapping-for-a-team
+        /// </remarks>
+        /// <param name="teamId">The teamId to update LDAP mapping</param>
+        /// <returns>The <see cref="LdapSyncResponse"/> of the queue request.</returns>
+        IObservable<LdapSyncResponse> QueueSyncTeamMapping(int teamId);
+    }
+}

Octokit.Reactive/Clients/Enterprise/ObservableEnterpriseClient.cs

@@ -13,6 +13,7 @@
             Ensure.ArgumentNotNull(client, "client");
 
             AdminStats = new ObservableEnterpriseAdminStatsClient(client);
+            Ldap = new ObservableEnterpriseLdapClient(client);
             License = new ObservableEnterpriseLicenseClient(client);
             Organization = new ObservableEnterpriseOrganizationClient(client);
             SearchIndexing = new ObservableEnterpriseSearchIndexingClient(client);
@@ -26,6 +27,14 @@
         ///</remarks>
         public IObservableEnterpriseAdminStatsClient AdminStats { get; private set; }
 
+        /// <summary>
+        /// A client for GitHub's Enterprise LDAP API
+        /// </summary>
+        /// <remarks>
+        /// See the <a href="https://developer.github.com/v3/enterprise/ldap/">Enterprise LDAP API documentation</a> for more information.
+        ///</remarks>
+        public IObservableEnterpriseLdapClient Ldap { get; private set; }
+
         /// <summary>
         /// A client for GitHub's Enterprise License API
         /// </summary>

Octokit.Reactive/Clients/Enterprise/ObservableEnterpriseLdapClient.cs

@@ -0,0 +1,80 @@
+using System;
+using System.Reactive;
+using System.Reactive.Threading.Tasks;
+using Octokit;
+
+
+namespace Octokit.Reactive
+{
+    /// <summary>
+    /// A client for GitHub's Enterprise LDAP API
+    /// </summary>
+    /// <remarks>
+    /// See the <a href="https://developer.github.com/v3/enterprise/ldap/">Enterprise LDAP API documentation</a> for more information.
+    ///</remarks>
+    public class ObservableEnterpriseLdapClient : IObservableEnterpriseLdapClient
+    {
+        readonly IEnterpriseLdapClient _client;
+
+        public ObservableEnterpriseLdapClient(IGitHubClient client)
+        {
+            Ensure.ArgumentNotNull(client, "client");
+
+            _client = client.Enterprise.Ldap;
+        }
+
+        /// <summary>
+        /// Update the LDAP mapping for a user on a GitHub Enterprise appliance (must be Site Admin user).
+        /// </summary>
+        /// <remarks>
+        /// https://developer.github.com/v3/enterprise/ldap/#update-ldap-mapping-for-a-user
+        /// </remarks>
+        /// <param name="userName">The username to update LDAP mapping</param>
+        /// <param name="newLdapMapping">The <see cref="NewLdapMapping"/></param>
+        /// <returns>The <see cref="User"/> object.</returns>
+        public IObservable<User> UpdateUserMapping(string userName, NewLdapMapping newLdapMapping)
+        {
+            return _client.UpdateUserMapping(userName, newLdapMapping).ToObservable();
+        }
+
+        /// <summary>
+        /// Queue an LDAP Sync job for a user on a GitHub Enterprise appliance (must be Site Admin user).
+        /// </summary>
+        /// <remarks>
+        /// https://developer.github.com/v3/enterprise/ldap/#sync-ldap-mapping-for-a-user
+        /// </remarks>
+        /// <param name="userName">The username to sync LDAP mapping</param>
+        /// <returns>The <see cref="LdapSyncResponse"/> of the queue request.</returns>
+        public IObservable<LdapSyncResponse> QueueSyncUserMapping(string userName)
+        {
+            return _client.QueueSyncUserMapping(userName).ToObservable();
+        }
+        
+        /// <summary>
+        /// Update the LDAP mapping for a team on a GitHub Enterprise appliance (must be Site Admin user).
+        /// </summary>
+        /// <remarks>
+        /// https://developer.github.com/v3/enterprise/ldap/#update-ldap-mapping-for-a-team
+        /// </remarks>
+        /// <param name="teamId">The teamId to update LDAP mapping</param>
+        /// <param name="newLdapMapping">The <see cref="NewLdapMapping"/></param>
+        /// <returns>The <see cref="Team"/> object.</returns>
+        public IObservable<Team> UpdateTeamMapping(int teamId, NewLdapMapping newLdapMapping)
+        {
+            return _client.UpdateTeamMapping(teamId, newLdapMapping).ToObservable();
+        }
+
+        /// <summary>
+        /// Queue an LDAP Sync job for a team on a GitHub Enterprise appliance (must be Site Admin user).
+        /// </summary>
+        /// <remarks>
+        /// https://developer.github.com/v3/enterprise/ldap/#sync-ldap-mapping-for-a-team
+        /// </remarks>
+        /// <param name="teamId">The teamId to update LDAP mapping</param>
+        /// <returns>The <see cref="LdapSyncResponse"/> of the queue request.</returns>
+        public IObservable<LdapSyncResponse> QueueSyncTeamMapping(int teamId)
+        {
+            return _client.QueueSyncTeamMapping(teamId).ToObservable();
+        }
+    }
+}

Octokit.Reactive/Octokit.Reactive-Mono.csproj

@@ -171,6 +171,8 @@
     <Compile Include="Clients\ObservableUserAdministrationClient.cs" />
     <Compile Include="Clients\Enterprise\IObservableEnterpriseSearchIndexingClient.cs" />
     <Compile Include="Clients\Enterprise\ObservableEnterpriseSearchIndexingClient.cs" />
+    <Compile Include="Clients\Enterprise\IObservableEnterpriseLdapClient.cs" />
+    <Compile Include="Clients\Enterprise\ObservableEnterpriseLdapClient.cs" />
   </ItemGroup>
   <Import Project="$(MSBuildBinPath)\Microsoft.CSharp.targets" />
   <ItemGroup>

Octokit.Reactive/Octokit.Reactive-MonoAndroid.csproj

@@ -179,6 +179,8 @@
     <Compile Include="Clients\ObservableUserAdministrationClient.cs" />
     <Compile Include="Clients\Enterprise\IObservableEnterpriseSearchIndexingClient.cs" />
     <Compile Include="Clients\Enterprise\ObservableEnterpriseSearchIndexingClient.cs" />
+    <Compile Include="Clients\Enterprise\IObservableEnterpriseLdapClient.cs" />
+    <Compile Include="Clients\Enterprise\ObservableEnterpriseLdapClient.cs" />
   </ItemGroup>
   <Import Project="$(MSBuildExtensionsPath)\Novell\Novell.MonoDroid.CSharp.targets" />
   <ItemGroup>

Octokit.Reactive/Octokit.Reactive-Monotouch.csproj

@@ -175,6 +175,8 @@
     <Compile Include="Clients\ObservableUserAdministrationClient.cs" />
     <Compile Include="Clients\Enterprise\IObservableEnterpriseSearchIndexingClient.cs" />
     <Compile Include="Clients\Enterprise\ObservableEnterpriseSearchIndexingClient.cs" />
+    <Compile Include="Clients\Enterprise\IObservableEnterpriseLdapClient.cs" />
+    <Compile Include="Clients\Enterprise\ObservableEnterpriseLdapClient.cs" />
   </ItemGroup>
   <Import Project="$(MSBuildBinPath)\Microsoft.CSharp.targets" />
   <ItemGroup>

Octokit.Reactive/Octokit.Reactive.csproj

@@ -75,6 +75,7 @@
     <Compile Include="..\SolutionInfo.cs">
       <Link>Properties\SolutionInfo.cs</Link>
     </Compile>
+    <Compile Include="Clients\Enterprise\IObservableEnterpriseLdapClient.cs" />
     <Compile Include="Clients\Enterprise\IObservableEnterpriseSearchIndexingClient.cs" />
     <Compile Include="Clients\Enterprise\IObservableEnterpriseOrganizationClient.cs" />
     <Compile Include="Clients\Enterprise\IObservableEnterpriseLicenseClient.cs" />
@@ -82,6 +83,7 @@
     <Compile Include="Clients\Enterprise\IObservableEnterpriseAdminStatsClient.cs" />
     <Compile Include="Clients\Enterprise\IObservableEnterpriseClient.cs" />
     <Compile Include="Clients\Enterprise\ObservableEnterpriseClient.cs" />
+    <Compile Include="Clients\Enterprise\ObservableEnterpriseLdapClient.cs" />
     <Compile Include="Clients\Enterprise\ObservableEnterpriseSearchIndexingClient.cs" />
     <Compile Include="Clients\Enterprise\ObservableEnterpriseOrganizationClient.cs" />
     <Compile Include="Clients\Enterprise\ObservableEnterpriseLicenseClient.cs" />

Octokit.Tests.Integration/Clients/Enterprise/EnterpriseLdapClientTests.cs

@@ -0,0 +1,89 @@
+using System;
+using System.Linq;
+using System.Threading.Tasks;
+using Octokit;
+using Octokit.Tests.Integration;
+using Octokit.Tests.Integration.Helpers;
+using Xunit;
+
+public class EnterpriseLdapClientTests : IDisposable
+{
+    readonly IGitHubClient _github;
+
+    readonly string _testUser = "test-user";
+    readonly string _distinguishedNameUser = "uid=test-user,ou=users,dc=company,dc=com";
+
+    readonly EnterpriseTeamContext _context;
+    readonly string _distinguishedNameTeam = "cn=test-team,ou=groups,dc=company,dc=com";
+
+    public EnterpriseLdapClientTests()
+    {
+        _github = EnterpriseHelper.GetAuthenticatedClient();
+        
+        NewTeam newTeam = new NewTeam(Helper.MakeNameWithTimestamp("test-team")) { Description = "Test Team" };
+        _context = _github.CreateEnterpriseTeamContext(EnterpriseHelper.Organization, newTeam).Result;
+    }
+
+    [GitHubEnterpriseTest]
+    public async Task CanUpdateUserMapping()
+    {
+        var newLDAPMapping = new NewLdapMapping(_distinguishedNameUser);
+        var ldapUser = await
+            _github.Enterprise.Ldap.UpdateUserMapping(_testUser, newLDAPMapping);
+
+        Assert.NotNull(ldapUser);
+        Assert.NotNull(ldapUser.LdapDistinguishedName);
+        Assert.Equal(ldapUser.LdapDistinguishedName, _distinguishedNameUser);
+
+        // Get user and check mapping was updated
+        var checkUser = await _github.User.Get(_testUser);
+        Assert.Equal(checkUser.Login, ldapUser.Login);
+        Assert.Equal(checkUser.LdapDistinguishedName, _distinguishedNameUser);
+    }
+
+    [GitHubEnterpriseTest]
+    public async Task CanQueueSyncUserMapping()
+    {
+        var response = await
+            _github.Enterprise.Ldap.QueueSyncUserMapping(_testUser);
+
+        // Check response message indicates LDAP sync was queued
+        Assert.NotNull(response);
+        Assert.NotNull(response.Status);
+        Assert.True(response.Status == "queued");
+    }
+
+    [GitHubEnterpriseTest]
+    public async Task CanUpdateTeamMapping()
+    {
+        var newLDAPMapping = new NewLdapMapping(_distinguishedNameTeam);
+        var ldapTeam = await
+            _github.Enterprise.Ldap.UpdateTeamMapping(_context.TeamId, newLDAPMapping);
+
+        Assert.NotNull(ldapTeam);
+        Assert.NotNull(ldapTeam.LdapDistinguishedName);
+        Assert.Equal(ldapTeam.LdapDistinguishedName, _distinguishedNameTeam);
+
+        // Get Team and check mapping was updated
+        var checkTeam = await _github.Organization.Team.Get(_context.TeamId);
+        Assert.Equal(checkTeam.Name, ldapTeam.Name);
+        Assert.Equal(checkTeam.LdapDistinguishedName, _distinguishedNameTeam);
+    }
+
+    [GitHubEnterpriseTest]
+    public async Task CanQueueSyncTeamMapping()
+    {
+        var response = await
+            _github.Enterprise.Ldap.QueueSyncTeamMapping(_context.TeamId);
+
+        // Check response message indicates LDAP sync was queued
+        Assert.NotNull(response);
+        Assert.NotNull(response.Status);
+        Assert.True(response.Status == "queued");
+    }
+
+    public void Dispose()
+    {
+        _context.Dispose();
+    }
+}

Octokit.Tests.Integration/EnterpriseHelper.cs

@@ -124,6 +124,22 @@ namespace Octokit.Tests.Integration
             catch { }
         }
 
+        public static void DeleteTeam(Team team)
+        {
+            if (team != null)
+                DeleteTeam(team.Id);
+        }
+
+        public static void DeleteTeam(int teamId)
+        {
+            var api = GetAuthenticatedClient();
+            try
+            {
+                api.Organization.Team.Delete(teamId).Wait(TimeSpan.FromSeconds(15));
+            }
+            catch { }
+        }
+
         public static IGitHubClient GetAuthenticatedClient()
         {
             return new GitHubClient(new ProductHeaderValue("OctokitEnterpriseTests"), GitHubEnterpriseUrl)

Octokit.Tests.Integration/Helpers/EnterpriseTeamContext.cs

@@ -0,0 +1,28 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace Octokit.Tests.Integration.Helpers
+{
+    internal sealed class EnterpriseTeamContext : IDisposable
+    {
+        internal EnterpriseTeamContext(Team team)
+        {
+            Team = team;
+            TeamId = team.Id;
+            TeamName = team.Name;
+        }
+
+        internal int TeamId { get; private set; }
+        internal string TeamName { get; private set; }
+
+        internal Team Team { get; private set; }
+
+        public void Dispose()
+        {
+            EnterpriseHelper.DeleteTeam(Team);
+        }
+    }
+}

Octokit.Tests.Integration/Helpers/GithubClientExtensions.cs

@@ -29,5 +29,12 @@ namespace Octokit.Tests.Integration.Helpers
 
             return new RepositoryContext(repo);
         }
+
+        internal async static Task<EnterpriseTeamContext> CreateEnterpriseTeamContext(this IGitHubClient client, string organization, NewTeam newTeam)
+        {
+            var team = await client.Organization.Team.Create(organization, newTeam);
+
+            return new EnterpriseTeamContext(team);
+        }
     }
 }

Octokit.Tests.Integration/Octokit.Tests.Integration.csproj

@@ -77,6 +77,7 @@
     <Compile Include="Clients\AuthorizationClientTests.cs" />
     <Compile Include="Clients\BlobClientTests.cs" />
     <Compile Include="Clients\BranchesClientTests.cs" />
+    <Compile Include="Clients\Enterprise\EnterpriseLdapClientTests.cs" />
     <Compile Include="Clients\Enterprise\EnterpriseLicenseClientTests.cs" />
     <Compile Include="Clients\Enterprise\EnterpriseAdminStatsClientTests.cs" />
     <Compile Include="Clients\Enterprise\EnterpriseSearchIndexingClientTests.cs" />
@@ -118,6 +119,7 @@
     <Compile Include="Helpers\PersonalAccessTokenTestAttribute.cs" />
     <Compile Include="Helpers\PaidAccountTestAttribute.cs" />
     <Compile Include="Helpers\ReferenceExtensionsTests.cs" />
+    <Compile Include="Helpers\EnterpriseTeamContext.cs" />
     <Compile Include="Helpers\RepositoryContext.cs" />
     <Compile Include="Helpers\RepositorySetupHelper.cs" />
     <Compile Include="HttpClientAdapterTests.cs" />
@@ -128,6 +130,7 @@
     <Compile Include="Clients\MiscellaneousClientTests.cs" />
     <Compile Include="Helpers\OrganizationTestAttribute.cs" />
     <Compile Include="Reactive\Enterprise\ObservableEnterpriseAdminStatsClientTests.cs" />
+    <Compile Include="Reactive\Enterprise\ObservableEnterpriseLdapClientTests.cs" />
     <Compile Include="Reactive\Enterprise\ObservableEnterpriseLicenseClientTests.cs" />
     <Compile Include="Reactive\Enterprise\ObservableEnterpriseSearchIndexingClientTests.cs" />
     <Compile Include="Reactive\Enterprise\ObservableEnterpriseOrganizationClientTests.cs" />

Octokit.Tests.Integration/Reactive/Enterprise/ObservableEnterpriseLdapClientTests.cs

@@ -0,0 +1,97 @@
+using System;
+using System.Linq;
+using System.Reactive.Linq;
+using System.Threading.Tasks;
+using Octokit.Reactive;
+using Octokit.Tests.Integration.Helpers;
+using Xunit;
+
+namespace Octokit.Tests.Integration
+{
+    public class ObservableEnterpriseLdapClientTests : IDisposable
+    {
+        readonly IObservableGitHubClient _github;
+
+        readonly string _testUser = "test-user";
+        readonly string _distinguishedNameUser = "uid=test-user,ou=users,dc=company,dc=com";
+        
+        readonly EnterpriseTeamContext _context;
+        readonly string _distinguishedNameTeam = "cn=test-team,ou=groups,dc=company,dc=com";
+        
+        public ObservableEnterpriseLdapClientTests()
+        {
+            var gitHub = EnterpriseHelper.GetAuthenticatedClient();
+            _github = new ObservableGitHubClient(gitHub);
+
+            NewTeam newTeam = new NewTeam(Helper.MakeNameWithTimestamp("test-team")) { Description = "Test Team" };
+            _context = gitHub.CreateEnterpriseTeamContext(EnterpriseHelper.Organization, newTeam).Result;
+        }
+
+        [GitHubEnterpriseTest]
+        public async Task CanUpdateUserMapping()
+        {
+            var newLDAPMapping = new NewLdapMapping(_distinguishedNameUser);
+            var observable =
+                _github.Enterprise.Ldap.UpdateUserMapping(_testUser, newLDAPMapping);
+            var ldapUser = await observable;
+
+            Assert.NotNull(ldapUser);
+            Assert.NotNull(ldapUser.LdapDistinguishedName);
+            Assert.Equal(ldapUser.LdapDistinguishedName, _distinguishedNameUser);
+
+            // Get user and check mapping was updated
+            var checkUser = await _github.User.Get(_testUser);
+            Assert.Equal(checkUser.Login, ldapUser.Login);
+            Assert.Equal(checkUser.LdapDistinguishedName, _distinguishedNameUser);
+        }
+
+        [GitHubEnterpriseTest]
+        public async Task CanQueueSyncUserMapping()
+        {
+            var observable =
+                _github.Enterprise.Ldap.QueueSyncUserMapping(_testUser);
+            var response = await observable;
+
+            // Check response message indicates LDAP sync was queued
+            Assert.NotNull(response);
+            Assert.NotNull(response.Status);
+            Assert.True(response.Status == "queued");
+        }
+
+        [GitHubEnterpriseTest]
+        public async Task CanUpdateTeamMapping()
+        {
+            var newLDAPMapping = new NewLdapMapping(_distinguishedNameTeam);
+            var observable =
+                _github.Enterprise.Ldap.UpdateTeamMapping(_context.TeamId, newLDAPMapping);
+            var ldapTeam = await observable;
+
+            Assert.NotNull(ldapTeam);
+            Assert.NotNull(ldapTeam.LdapDistinguishedName);
+            Assert.Equal(ldapTeam.LdapDistinguishedName, _distinguishedNameTeam);
+
+            // Get Team and check mapping was updated
+            var checkTeam = await _github.Organization.Team.Get(_context.TeamId);
+            Assert.Equal(checkTeam.Name, ldapTeam.Name);
+            Assert.Equal(checkTeam.LdapDistinguishedName, _distinguishedNameTeam);
+        }
+
+        [GitHubEnterpriseTest]
+        public async Task CanQueueSyncTeamMapping()
+        {
+            var observable =
+                _github.Enterprise.Ldap.QueueSyncTeamMapping(_context.TeamId);
+            var response = await observable;
+
+            // Check response message indicates LDAP sync was queued
+            Assert.NotNull(response);
+            Assert.NotNull(response.Status);
+            Assert.True(response.Status == "queued");
+        }
+
+        public void Dispose()
+        {
+            _context.Dispose();
+        }
+    }
+}

Octokit.Tests/Clients/Enterprise/EnterpriseLdapClientTests.cs

@@ -0,0 +1,134 @@
+using System;
+using System.Threading.Tasks;
+using NSubstitute;
+using Xunit;
+
+namespace Octokit.Tests.Clients
+{
+    public class EnterpriseLdapClientTests
+    {
+        public class TheUpdateUserMappingMethod
+        {
+            readonly string _distinguishedNameUser = "uid=test-user,ou=users,dc=company,dc=com";
+
+            [Fact]
+            public void RequestsCorrectUrl()
+            {
+                var connection = Substitute.For<IApiConnection>();
+                var client = new EnterpriseLdapClient(connection);
+
+                string expectedUri = "admin/ldap/users/test-user/mapping";
+                client.UpdateUserMapping("test-user", new NewLdapMapping(_distinguishedNameUser));
+
+                connection.Received().Patch<User>(Arg.Is<Uri>(u => u.ToString() == expectedUri), Arg.Any<object>());
+            }
+
+            [Fact]
+            public void PassesRequestObject()
+            {
+                var connection = Substitute.For<IApiConnection>();
+                var client = new EnterpriseLdapClient(connection);
+
+                client.UpdateUserMapping("test-user", new NewLdapMapping(_distinguishedNameUser));
+
+                connection.Received().Patch<User>(
+                    Arg.Any<Uri>(),
+                    Arg.Is<NewLdapMapping>(a =>
+                        a.LdapDistinguishedName == _distinguishedNameUser));
+            }
+
+            [Fact]
+            public async Task EnsuresNonNullArguments()
+            {
+                var connection = Substitute.For<IApiConnection>();
+                var client = new EnterpriseLdapClient(connection);
+
+                await Assert.ThrowsAsync<ArgumentNullException>(() => client.UpdateUserMapping(null, new NewLdapMapping(_distinguishedNameUser)));
+                await Assert.ThrowsAsync<ArgumentNullException>(() => client.UpdateUserMapping("test-user", null));
+            }
+        }
+
+        public class TheQueueSyncUserMappingMethod
+        {
+            [Fact]
+            public void RequestsCorrectUrl()
+            {
+                var connection = Substitute.For<IApiConnection>();
+                var client = new EnterpriseLdapClient(connection);
+
+                string expectedUri = "admin/ldap/users/test-user/sync";
+                client.QueueSyncUserMapping("test-user");
+
+                connection.Connection.Received().Post<LdapSyncResponse>(
+                    Arg.Is<Uri>(u => u.ToString() == expectedUri));
+            }
+
+            [Fact]
+            public async Task EnsuresNonNullArguments()
+            {
+                var connection = Substitute.For<IApiConnection>();
+                var client = new EnterpriseLdapClient(connection);
+
+                await Assert.ThrowsAsync<ArgumentNullException>(() => client.QueueSyncUserMapping(null));
+            }
+        }
+
+        public class TheUpdateTeamMappingMethod
+        {
+            readonly string _distinguishedNameTeam = "uid=DG-Test-Team,ou=groups,dc=company,dc=com";
+
+            [Fact]
+            public void RequestsCorrectUrl()
+            {
+                var connection = Substitute.For<IApiConnection>();
+                var client = new EnterpriseLdapClient(connection);
+
+                string expectedUri = "admin/ldap/teams/1/mapping";
+                client.UpdateTeamMapping(1, new NewLdapMapping(_distinguishedNameTeam));
+
+                connection.Received().Patch<Team>(
+                    Arg.Is<Uri>(u => u.ToString() == expectedUri),
+                    Arg.Any<object>());
+            }
+
+            [Fact]
+            public void PassesRequestObject()
+            {
+                var connection = Substitute.For<IApiConnection>();
+                var client = new EnterpriseLdapClient(connection);
+
+                client.UpdateTeamMapping(1, new NewLdapMapping(_distinguishedNameTeam));
+
+                connection.Received().Patch<Team>(
+                    Arg.Any<Uri>(),
+                    Arg.Is<NewLdapMapping>(a =>
+                        a.LdapDistinguishedName == _distinguishedNameTeam));
+            }
+
+            [Fact]
+            public async Task EnsuresNonNullArguments()
+            {
+                var connection = Substitute.For<IApiConnection>();
+                var client = new EnterpriseLdapClient(connection);
+
+                await Assert.ThrowsAsync<ArgumentNullException>(() => client.UpdateTeamMapping(1, null));
+            }
+        }
+
+        public class TheQueueSyncTeamMappingMethod
+        {
+            [Fact]
+            public void RequestsCorrectUrl()
+            {
+                var connection = Substitute.For<IApiConnection>();
+                var client = new EnterpriseLdapClient(connection);
+
+                string expectedUri = "admin/ldap/teams/1/sync";
+                client.QueueSyncTeamMapping(1);
+
+                connection.Connection.Received().Post<LdapSyncResponse>(
+                    Arg.Is<Uri>(u => u.ToString() == expectedUri));
+            }
+        }
+    }
+}

Octokit.Tests/Octokit.Tests.csproj

@@ -86,6 +86,7 @@
   <ItemGroup>
     <Compile Include="Authentication\CredentialsTests.cs" />
     <Compile Include="Clients\Enterprise\EnterpriseAdminStatsClientTests.cs" />
+    <Compile Include="Clients\Enterprise\EnterpriseLdapClientTests.cs" />
     <Compile Include="Clients\Enterprise\EnterpriseOrganizationClientTests.cs" />
     <Compile Include="Clients\Enterprise\EnterpriseLicenseClientTests.cs" />
     <Compile Include="Clients\Enterprise\EnterpriseSearchIndexingClientTests.cs" />
@@ -191,6 +192,7 @@
     <Compile Include="Helpers\StringExtensionsTests.cs" />
     <Compile Include="Clients\RepositoriesClientTests.cs" />
     <Compile Include="Reactive\AuthorizationExtensionsTests.cs" />
+    <Compile Include="Reactive\Enterprise\ObservableEnterpriseLdapClientTests.cs" />
     <Compile Include="Reactive\Enterprise\ObservableEnterpriseSearchIndexingClientTests.cs" />
     <Compile Include="Reactive\Enterprise\ObservableEnterpriseOrganizationClientTests.cs" />
     <Compile Include="Reactive\Enterprise\ObservableEnterpriseLicenseClientTests.cs" />

Octokit.Tests/Reactive/Enterprise/ObservableEnterpriseLdapClientTests.cs

@@ -0,0 +1,74 @@
+using System;
+using NSubstitute;
+using Octokit.Reactive;
+using Xunit;
+
+namespace Octokit.Tests
+{
+    public class ObservableEnterpriseLDAPClientTests
+    {
+        public class TheUpdateUserMappingMethod
+        {
+            readonly string _distinguishedName = "uid=test-user,ou=users,dc=company,dc=com";
+            
+            [Fact]
+            public void CallsIntoClient()
+            {
+                var github = Substitute.For<IGitHubClient>();
+                var client = new ObservableEnterpriseLdapClient(github);
+
+                client.UpdateUserMapping("test-user", new NewLdapMapping(_distinguishedName));
+                github.Enterprise.Ldap.Received(1).UpdateUserMapping(
+                    Arg.Is<string>(a => a == "test-user"),
+                    Arg.Is<NewLdapMapping>(a => 
+                        a.LdapDistinguishedName == _distinguishedName));
+            }
+        }
+        
+        public class TheQueueSyncUserMappingMethod
+        {
+            [Fact]
+            public void CallsIntoClient()
+            {
+                var github = Substitute.For<IGitHubClient>();
+                var client = new ObservableEnterpriseLdapClient(github);
+
+                client.QueueSyncUserMapping("test-user");
+                github.Enterprise.Ldap.Received(1).QueueSyncUserMapping(
+                    Arg.Is<string>(a => a == "test-user"));
+            }
+        }
+        
+        public class TheUpdateTeamMappingMethod
+        {
+            readonly string _distinguishedName = "cn=test-team,ou=groups,dc=company,dc=com";
+            
+            [Fact]
+            public void CallsIntoClient()
+            {
+                var github = Substitute.For<IGitHubClient>();
+                var client = new ObservableEnterpriseLdapClient(github);
+
+                client.UpdateTeamMapping(1, new NewLdapMapping(_distinguishedName));
+                github.Enterprise.Ldap.Received(1).UpdateTeamMapping(
+                    Arg.Is<int>(a => a == 1),
+                    Arg.Is<NewLdapMapping>(a => 
+                        a.LdapDistinguishedName == _distinguishedName));
+            }
+        }
+        
+        public class TheQueueSyncTeamMappingMethod
+        {
+            [Fact]
+            public void CallsIntoClient()
+            {
+                var github = Substitute.For<IGitHubClient>();
+                var client = new ObservableEnterpriseLdapClient(github);
+
+                client.QueueSyncTeamMapping(1);
+                github.Enterprise.Ldap.Received(1).QueueSyncTeamMapping(
+                    Arg.Is<int>(a => a == 1));
+            }
+        }
+    }
+}

Octokit/Clients/Enterprise/EnterpriseClient.cs

@@ -15,6 +15,7 @@
         public EnterpriseClient(IApiConnection apiConnection) : base(apiConnection)
         {
             AdminStats = new EnterpriseAdminStatsClient(apiConnection);
+            Ldap = new EnterpriseLdapClient(apiConnection);
             License = new EnterpriseLicenseClient(apiConnection);
             Organization = new EnterpriseOrganizationClient(apiConnection);
             SearchIndexing = new EnterpriseSearchIndexingClient(apiConnection);
@@ -28,6 +29,14 @@
         ///</remarks>
         public IEnterpriseAdminStatsClient AdminStats { get; private set; }
 
+        /// <summary>
+        /// A client for GitHub's Enterprise LDAP API
+        /// </summary>
+        /// <remarks>
+        /// See the <a href="https://developer.github.com/v3/enterprise/ldap/">Enterprise LDAP API documentation</a> for more information.
+        ///</remarks>
+        public IEnterpriseLdapClient Ldap { get; private set; }
+
         /// <summary>
         /// A client for GitHub's Enterprise License API
         /// </summary>

Octokit/Clients/Enterprise/EnterpriseLdapClient.cs

@@ -0,0 +1,102 @@
+using System.Net;
+using System.Threading.Tasks;
+
+namespace Octokit
+{
+    /// <summary>
+    /// A client for GitHub's Enterprise LDAP API
+    /// </summary>
+    /// <remarks>
+    /// See the <a href="https://developer.github.com/v3/enterprise/ldap/">Enterprise LDAP API documentation</a> for more information.
+    ///</remarks>
+    public class EnterpriseLdapClient : ApiClient, IEnterpriseLdapClient
+    {
+        public EnterpriseLdapClient(IApiConnection apiConnection)
+            : base(apiConnection)
+        { }
+
+        /// <summary>
+        /// Update the LDAP mapping for a user on a GitHub Enterprise appliance (must be Site Admin user).
+        /// </summary>
+        /// <remarks>
+        /// https://developer.github.com/v3/enterprise/ldap/#update-ldap-mapping-for-a-user
+        /// </remarks>
+        /// <param name="userName">The username to update LDAP mapping</param>
+        /// <param name="newLdapMapping">The <see cref="NewLdapMapping"/></param>
+        /// <returns>The <see cref="User"/> object.</returns>
+        public Task<User> UpdateUserMapping(string userName, NewLdapMapping newLdapMapping)
+        {
+            Ensure.ArgumentNotNull(userName, "userName");
+            Ensure.ArgumentNotNull(newLdapMapping, "newLdapMapping");
+
+            var endpoint = ApiUrls.EnterpriseLdapUserMapping(userName);
+
+            return ApiConnection.Patch<User>(endpoint, newLdapMapping);
+        }
+
+        /// <summary>
+        /// Queue an LDAP Sync job for a user on a GitHub Enterprise appliance (must be Site Admin user).
+        /// </summary>
+        /// <remarks>
+        /// https://developer.github.com/v3/enterprise/ldap/#sync-ldap-mapping-for-a-user
+        /// </remarks>
+        /// <param name="userName">The userName to sync LDAP mapping</param>
+        /// <returns>The <see cref="LdapSyncResponse"/> of the queue request.</returns>
+        public async Task<LdapSyncResponse> QueueSyncUserMapping(string userName)
+        {
+            Ensure.ArgumentNotNull(userName, "userName");
+            
+            var endpoint = ApiUrls.EnterpriseLdapUserSync(userName);
+
+            var response = await Connection.Post<LdapSyncResponse>(endpoint);
+            if (response.HttpResponse.StatusCode != HttpStatusCode.Created)
+            {
+                throw new ApiException("Invalid Status Code returned. Expected a 201", response.HttpResponse.StatusCode);
+            }
+
+            return response.Body;
+        }
+        
+        /// <summary>
+        /// Update the LDAP mapping for a team on a GitHub Enterprise appliance (must be Site Admin user).
+        /// </summary>
+        /// <remarks>
+        /// https://developer.github.com/v3/enterprise/ldap/#update-ldap-mapping-for-a-team
+        /// </remarks>
+        /// <param name="teamId">The teamId to update LDAP mapping</param>
+        /// <param name="newLdapMapping">The <see cref="NewLdapMapping"/></param>
+        /// <returns>The <see cref="Team"/> object.</returns>
+        public Task<Team> UpdateTeamMapping(int teamId, NewLdapMapping newLdapMapping)
+        {
+            Ensure.ArgumentNotNull(teamId, "teamId");
+            Ensure.ArgumentNotNull(newLdapMapping, "newLdapMapping");
+
+            var endpoint = ApiUrls.EnterpriseLdapTeamMapping(teamId);
+
+            return ApiConnection.Patch<Team>(endpoint, newLdapMapping);
+        }
+
+        /// <summary>
+        /// Queue an LDAP Sync job for a team on a GitHub Enterprise appliance (must be Site Admin user).
+        /// </summary>
+        /// <remarks>
+        /// https://developer.github.com/v3/enterprise/ldap/#sync-ldap-mapping-for-a-team
+        /// </remarks>
+        /// <param name="teamId">The teamId to update LDAP mapping</param>
+        /// <returns>The <see cref="LdapSyncResponse"/> of the queue request.</returns>
+        public async Task<LdapSyncResponse> QueueSyncTeamMapping(int teamId)
+        {
+            Ensure.ArgumentNotNull(teamId, "teamId");
+            
+            var endpoint = ApiUrls.EnterpriseLdapTeamSync(teamId);
+
+            var response = await Connection.Post<LdapSyncResponse>(endpoint);
+            if (response.HttpResponse.StatusCode != HttpStatusCode.Created)
+            {
+                throw new ApiException("Invalid Status Code returned. Expected a 201", response.HttpResponse.StatusCode);
+            }
+
+            return response.Body;
+        }
+    }
+}

Octokit/Clients/Enterprise/IEnterpriseClient.cs

@@ -16,6 +16,14 @@
         ///</remarks>
         IEnterpriseAdminStatsClient AdminStats { get; }
 
+        /// <summary>
+        /// A client for GitHub's Enterprise LDAP API
+        /// </summary>
+        /// <remarks>
+        /// See the <a href="https://developer.github.com/v3/enterprise/ldap/">Enterprise LDAP API documentation</a> for more information.
+        ///</remarks>
+        IEnterpriseLdapClient Ldap { get; }
+
         /// <summary>
         /// A client for GitHub's Enterprise License API
         /// </summary>

Octokit/Clients/Enterprise/IEnterpriseLdapClient.cs

@@ -0,0 +1,55 @@
+using System.Threading.Tasks;
+
+namespace Octokit
+{
+    /// <summary>
+    /// A client for GitHub's Enterprise LDAP API
+    /// </summary>
+    /// <remarks>
+    /// See the <a href="https://developer.github.com/v3/enterprise/ldap/">Enterprise LDAP API documentation</a> for more information.
+    ///</remarks>
+    public interface IEnterpriseLdapClient
+    {
+        /// <summary>
+        /// Update the LDAP mapping for a user on a GitHub Enterprise appliance (must be Site Admin user).
+        /// </summary>
+        /// <remarks>
+        /// https://developer.github.com/v3/enterprise/ldap/#update-ldap-mapping-for-a-user
+        /// </remarks>
+        /// <param name="userName">The username to update LDAP mapping</param>
+        /// <param name="newLdapMapping">The <see cref="NewLdapMapping"/></param>
+        /// <returns>The <see cref="User"/> object.</returns>
+        Task<User> UpdateUserMapping(string userName, NewLdapMapping newLdapMapping);
+
+        /// <summary>
+        /// Queue an LDAP Sync job for a user on a GitHub Enterprise appliance (must be Site Admin user).
+        /// </summary>
+        /// <remarks>
+        /// https://developer.github.com/v3/enterprise/ldap/#sync-ldap-mapping-for-a-user
+        /// </remarks>
+        /// <param name="userName">The username to sync LDAP mapping</param>
+        /// <returns>The <see cref="LdapSyncResponse"/> of the queue request.</returns>
+        Task<LdapSyncResponse> QueueSyncUserMapping(string userName);
+
+        /// <summary>
+        /// Update the LDAP mapping for a team on a GitHub Enterprise appliance (must be Site Admin user).
+        /// </summary>
+        /// <remarks>
+        /// https://developer.github.com/v3/enterprise/ldap/#update-ldap-mapping-for-a-team
+        /// </remarks>
+        /// <param name="teamId">The teamId to update LDAP mapping</param>
+        /// <param name="newLdapMapping">The <see cref="NewLdapMapping"/></param>
+        /// <returns>The <see cref="Team"/> object.</returns>
+        Task<Team> UpdateTeamMapping(int teamId, NewLdapMapping newLdapMapping);
+
+        /// <summary>
+        /// Queue an LDAP Sync job for a team on a GitHub Enterprise appliance (must be Site Admin user).
+        /// </summary>
+        /// <remarks>
+        /// https://developer.github.com/v3/enterprise/ldap/#sync-ldap-mapping-for-a-team
+        /// </remarks>
+        /// <param name="teamId">The teamId to update LDAP mapping</param>
+        /// <returns>The <see cref="LdapSyncResponse"/> of the queue request.</returns>
+        Task<LdapSyncResponse> QueueSyncTeamMapping(int teamId);
+    }
+}

Octokit/Helpers/ApiUrls.cs

@@ -1664,6 +1664,26 @@ namespace Octokit
             return EnterpriseAdminStats("all");
         }
 
+        public static Uri EnterpriseLdapTeamMapping(int teamId)
+        {
+            return "admin/ldap/teams/{0}/mapping".FormatUri(teamId);
+        }
+
+        public static Uri EnterpriseLdapTeamSync(int teamId)
+        {
+            return "admin/ldap/teams/{0}/sync".FormatUri(teamId);
+        }
+
+        public static Uri EnterpriseLdapUserMapping(string userName)
+        {
+            return "admin/ldap/users/{0}/mapping".FormatUri(userName);
+        }
+
+        public static Uri EnterpriseLdapUserSync(string userName)
+        {
+            return "admin/ldap/users/{0}/sync".FormatUri(userName);
+        }
+
         public static Uri EnterpriseLicense()
         {
             return "enterprise/settings/license".FormatUri();

Octokit/Http/ApiConnection.cs

@@ -161,6 +161,21 @@ namespace Octokit
             return Connection.Post(uri);
         }
 
+        /// <summary>
+        /// Creates a new API resource in the list at the specified URI.
+        /// </summary>
+        /// <typeparam name="T">The API resource's type.</typeparam>
+        /// <param name="uri">URI of the API resource to get</param>
+        /// <returns>The created API resource.</returns>
+        /// <exception cref="ApiException">Thrown when an API error occurs.</exception>
+        public async Task<T> Post<T>(Uri uri)
+        {
+            Ensure.ArgumentNotNull(uri, "uri");
+
+            var response = await Connection.Post<T>(uri).ConfigureAwait(false);
+            return response.Body;
+        }
+
         /// <summary>
         /// Creates a new API resource in the list at the specified URI.
         /// </summary>

Octokit/Http/Connection.cs

@@ -237,6 +237,13 @@ namespace Octokit
             return response.HttpResponse.StatusCode;
         }
 
+        public Task<IApiResponse<T>> Post<T>(Uri uri)
+        {
+            Ensure.ArgumentNotNull(uri, "uri");
+
+            return SendData<T>(uri, HttpMethod.Post, null, null, null, CancellationToken.None);
+        }
+
         public Task<IApiResponse<T>> Post<T>(Uri uri, object body, string accepts, string contentType)
         {
             Ensure.ArgumentNotNull(uri, "uri");

Octokit/Http/IApiConnection.cs

@@ -100,6 +100,15 @@ namespace Octokit
         /// <exception cref="ApiException">Thrown when an API error occurs.</exception>
         Task Post(Uri uri);
 
+        /// <summary>
+        /// Creates a new API resource in the list at the specified URI.
+        /// </summary>
+        /// <typeparam name="T">The API resource's type.</typeparam>
+        /// <param name="uri">URI endpoint to send request to</param>
+        /// <returns>The created API resource.</returns>
+        /// <exception cref="ApiException">Thrown when an API error occurs.</exception>
+        Task<T> Post<T>(Uri uri);
+        
         /// <summary>
         /// Creates a new API resource in the list at the specified URI.
         /// </summary>

Octokit/Http/IConnection.cs

@@ -105,6 +105,15 @@ namespace Octokit
         /// <returns><seealso cref="IResponse"/> representing the received HTTP response</returns>
         Task<HttpStatusCode> Post(Uri uri);
 
+        /// <summary>
+        /// Performs an asynchronous HTTP POST request.
+        /// Attempts to map the response body to an object of type <typeparamref name="T"/>
+        /// </summary>
+        /// <typeparam name="T">The type to map the response to</typeparam>
+        /// <param name="uri">URI endpoint to send request to</param>
+        /// <returns><seealso cref="IResponse"/> representing the received HTTP response</returns>
+        Task<IApiResponse<T>> Post<T>(Uri uri);
+
         /// <summary>
         /// Performs an asynchronous HTTP POST request.
         /// Attempts to map the response body to an object of type <typeparamref name="T"/>

Octokit/Models/Request/Enterprise/NewLdapMapping.cs

@@ -0,0 +1,41 @@
+using System;
+using System.Collections.ObjectModel;
+using System.Diagnostics;
+using System.Diagnostics.CodeAnalysis;
+using System.Globalization;
+using Octokit.Internal;
+
+namespace Octokit
+{
+    /// <summary>
+    /// Describes a new organization to create via the <see cref="IEnterpriseOrganizationClient.Create(NewOrganization)" /> method.
+    /// </summary>
+    [DebuggerDisplay("{DebuggerDisplay,nq}")]
+    public class NewLdapMapping
+    {
+        /// <summary>
+        /// Initializes a new instance of the <see cref="NewLdapMapping"/> class.
+        /// </summary>
+        /// <param name="ldapDistinguishedName">The LDAP Distinguished Name</param>
+        public NewLdapMapping(string ldapDistinguishedName)
+        {
+            Ensure.ArgumentNotNullOrEmptyString(ldapDistinguishedName, "ldapDistinguishedName");
+
+            LdapDistinguishedName = ldapDistinguishedName;
+        }
+
+        /// <summary>
+        /// The LDAP Distinguished Name (required)
+        /// </summary>
+        [Parameter(Key = "ldap_dn")]
+        public string LdapDistinguishedName { get; private set; }
+
+        internal string DebuggerDisplay
+        {
+            get
+            {
+                return string.Format(CultureInfo.InvariantCulture, "LdapDistinguishedName: {0}", LdapDistinguishedName);
+            }
+        }
+    }
+}

Octokit/Models/Response/Enterprise/LdapSyncResponse.cs

@@ -0,0 +1,33 @@
+using System;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.Globalization;
+using System.Linq;
+
+namespace Octokit
+{
+    [DebuggerDisplay("{DebuggerDisplay,nq}")]
+    public class LdapSyncResponse
+    {
+        public LdapSyncResponse() { }
+
+        public LdapSyncResponse(string status)
+        {
+            Status = status;
+        }
+
+        public string Status
+        {
+            get;
+            private set;
+        }
+
+        internal string DebuggerDisplay
+        {
+            get
+            {
+                return String.Format(CultureInfo.InvariantCulture, "Status: {0}", Status);
+            }
+        }
+    }
+}

Octokit/Models/Response/Team.cs

@@ -1,6 +1,8 @@
 using System;
 using System.Diagnostics;
+using System.Diagnostics.CodeAnalysis;
 using System.Globalization;
+using Octokit.Internal;
 
 namespace Octokit
 {
@@ -12,7 +14,7 @@ namespace Octokit
     {
         public Team() { }
 
-        public Team(Uri url, int id, string name, Permission permission, int membersCount, int reposCount, Organization organization)
+        public Team(Uri url, int id, string name, Permission permission, int membersCount, int reposCount, Organization organization, string ldapDistinguishedName)
         {
             Url = url;
             Id = id;
@@ -21,6 +23,7 @@ namespace Octokit
             MembersCount = membersCount;
             ReposCount = reposCount;
             Organization = organization;
+            LdapDistinguishedName = ldapDistinguishedName;
         }
 
         /// <summary>
@@ -58,6 +61,12 @@ namespace Octokit
         /// </summary>
         public Organization Organization { get; protected set; }
 
+        /// <summary>
+        /// LDAP Binding (GitHub Enterprise only)
+        /// </summary>
+        [Parameter(Key = "ldap_dn")]
+        public string LdapDistinguishedName { get; protected set; }
+
         internal string DebuggerDisplay
         {
             get { return string.Format(CultureInfo.InvariantCulture, "Name: {0} ", Name); }

Octokit/Models/Response/User.cs

@@ -1,6 +1,8 @@
 using System;
 using System.Diagnostics;
+using System.Diagnostics.CodeAnalysis;
 using System.Globalization;
+using Octokit.Internal;
 
 namespace Octokit
 {
@@ -12,10 +14,11 @@ namespace Octokit
     {
         public User() { }
 
-        public User(string avatarUrl, string bio, string blog, int collaborators, string company, DateTimeOffset createdAt, int diskUsage, string email, int followers, int following, bool? hireable, string htmlUrl, int totalPrivateRepos, int id, string location, string login, string name, int ownedPrivateRepos, Plan plan, int privateGists, int publicGists, int publicRepos, string url, bool siteAdmin)
+        public User(string avatarUrl, string bio, string blog, int collaborators, string company, DateTimeOffset createdAt, int diskUsage, string email, int followers, int following, bool? hireable, string htmlUrl, int totalPrivateRepos, int id, string location, string login, string name, int ownedPrivateRepos, Plan plan, int privateGists, int publicGists, int publicRepos, string url, bool siteAdmin, string ldapDistinguishedName)
             : base(avatarUrl, bio, blog, collaborators, company, createdAt, diskUsage, email, followers, following, hireable, htmlUrl, totalPrivateRepos, id, location, login, name, ownedPrivateRepos, plan, privateGists, publicGists, publicRepos, AccountType.User, url)
         {
             SiteAdmin = siteAdmin;
+            LdapDistinguishedName = ldapDistinguishedName;
         }
 
         /// <summary>
@@ -23,6 +26,12 @@ namespace Octokit
         /// </summary>
         public bool SiteAdmin { get; protected set; }
 
+        /// <summary>
+        /// LDAP Binding (GitHub Enterprise only)
+        /// </summary>
+        [Parameter(Key = "ldap_dn")]
+        public string LdapDistinguishedName { get; protected set; }
+
         internal string DebuggerDisplay
         {
             get

Octokit/Octokit-Mono.csproj

@@ -448,6 +448,10 @@
     <Compile Include="Models\Request\Enterprise\NewOrganization.cs" />
     <Compile Include="Models\Request\Enterprise\SearchIndexingTarget.cs" />
     <Compile Include="Models\Response\Enterprise\SearchIndexingResponse.cs" />
+    <Compile Include="Clients\Enterprise\EnterpriseLdapClient.cs" />
+    <Compile Include="Clients\Enterprise\IEnterpriseLdapClient.cs" />
+    <Compile Include="Models\Request\Enterprise\NewLdapMapping.cs" />
+    <Compile Include="Models\Response\Enterprise\LdapSyncResponse.cs" />
   </ItemGroup>
   <Import Project="$(MSBuildBinPath)\Microsoft.CSharp.targets" />
 </Project>

Octokit/Octokit-MonoAndroid.csproj

@@ -456,6 +456,10 @@
     <Compile Include="Models\Request\Enterprise\NewOrganization.cs" />
     <Compile Include="Models\Request\Enterprise\SearchIndexingTarget.cs" />
     <Compile Include="Models\Response\Enterprise\SearchIndexingResponse.cs" />
+    <Compile Include="Clients\Enterprise\EnterpriseLdapClient.cs" />
+    <Compile Include="Clients\Enterprise\IEnterpriseLdapClient.cs" />
+    <Compile Include="Models\Request\Enterprise\NewLdapMapping.cs" />
+    <Compile Include="Models\Response\Enterprise\LdapSyncResponse.cs" />
   </ItemGroup>
   <Import Project="$(MSBuildExtensionsPath)\Novell\Novell.MonoDroid.CSharp.targets" />
 </Project>

Octokit/Octokit-Monotouch.csproj

@@ -452,6 +452,10 @@
     <Compile Include="Models\Request\Enterprise\NewOrganization.cs" />
     <Compile Include="Models\Request\Enterprise\SearchIndexingTarget.cs" />
     <Compile Include="Models\Response\Enterprise\SearchIndexingResponse.cs" />
+    <Compile Include="Clients\Enterprise\EnterpriseLdapClient.cs" />
+    <Compile Include="Clients\Enterprise\IEnterpriseLdapClient.cs" />
+    <Compile Include="Models\Request\Enterprise\NewLdapMapping.cs" />
+    <Compile Include="Models\Response\Enterprise\LdapSyncResponse.cs" />
   </ItemGroup>
   <Import Project="$(MSBuildExtensionsPath)\Xamarin\iOS\Xamarin.MonoTouch.CSharp.targets" />
   <Import Project="$(MSBuildBinPath)\Microsoft.CSharp.targets" />

Octokit/Octokit-Portable.csproj

@@ -445,6 +445,10 @@
     <Compile Include="Models\Request\Enterprise\NewOrganization.cs" />
     <Compile Include="Models\Request\Enterprise\SearchIndexingTarget.cs" />
     <Compile Include="Models\Response\Enterprise\SearchIndexingResponse.cs" />
+    <Compile Include="Clients\Enterprise\EnterpriseLdapClient.cs" />
+    <Compile Include="Clients\Enterprise\IEnterpriseLdapClient.cs" />
+    <Compile Include="Models\Request\Enterprise\NewLdapMapping.cs" />
+    <Compile Include="Models\Response\Enterprise\LdapSyncResponse.cs" />
   </ItemGroup>
   <ItemGroup>
     <CodeAnalysisDictionary Include="..\CustomDictionary.xml">

Octokit/Octokit-netcore45.csproj

@@ -452,6 +452,10 @@
     <Compile Include="Models\Request\Enterprise\NewOrganization.cs" />
     <Compile Include="Models\Request\Enterprise\SearchIndexingTarget.cs" />
     <Compile Include="Models\Response\Enterprise\SearchIndexingResponse.cs" />
+    <Compile Include="Clients\Enterprise\EnterpriseLdapClient.cs" />
+    <Compile Include="Clients\Enterprise\IEnterpriseLdapClient.cs" />
+    <Compile Include="Models\Request\Enterprise\NewLdapMapping.cs" />
+    <Compile Include="Models\Response\Enterprise\LdapSyncResponse.cs" />
   </ItemGroup>
   <ItemGroup>
     <CodeAnalysisDictionary Include="..\CustomDictionary.xml">

Octokit/Octokit.csproj

@@ -59,10 +59,12 @@
     </Compile>
     <Compile Include="Clients\ActivitiesClient.cs" />
     <Compile Include="Clients\Enterprise\EnterpriseAdminStatsClient.cs" />
+    <Compile Include="Clients\Enterprise\EnterpriseLdapClient.cs" />
     <Compile Include="Clients\Enterprise\EnterpriseOrganizationClient.cs" />
     <Compile Include="Clients\Enterprise\EnterpriseLicenseClient.cs" />
     <Compile Include="Clients\Enterprise\EnterpriseClient.cs" />
     <Compile Include="Clients\Enterprise\EnterpriseSearchIndexingClient.cs" />
+    <Compile Include="Clients\Enterprise\IEnterpriseLdapClient.cs" />
     <Compile Include="Clients\Enterprise\IEnterpriseOrganizationClient.cs" />
     <Compile Include="Clients\Enterprise\IEnterpriseLicenseClient.cs" />
     <Compile Include="Clients\Enterprise\IEnterpriseAdminStatsClient.cs" />
@@ -111,6 +113,7 @@
     <Compile Include="Http\ProductHeaderValue.cs" />
     <Compile Include="Http\RequestBody.cs" />
     <Compile Include="Models\Request\BranchUpdate.cs" />
+    <Compile Include="Models\Request\Enterprise\NewLdapMapping.cs" />
     <Compile Include="Models\Request\GistFileUpdate.cs" />
     <Compile Include="Models\Request\NewArbitraryMarkDown.cs" />
     <Compile Include="Models\Request\Enterprise\NewOrganization.cs" />
@@ -151,6 +154,7 @@
     <Compile Include="Models\Response\Enterprise\AdminStatsPages.cs" />
     <Compile Include="Models\Response\Enterprise\AdminStatsPulls.cs" />
     <Compile Include="Models\Response\Enterprise\AdminStatsRepos.cs" />
+    <Compile Include="Models\Response\Enterprise\LdapSyncResponse.cs" />
     <Compile Include="Models\Response\Enterprise\SearchIndexingResponse.cs" />
     <Compile Include="Models\Response\Enterprise\LicenseInfo.cs" />
     <Compile Include="Models\Response\Enterprise\AdminStatsUsers.cs" />
@@ -484,4 +488,4 @@
   <Target Name="AfterBuild">
   </Target>
   -->
-</Project>
+</Project>