added licensing apis, refactored some services

src/Api/Controllers/AccountsController.cs

@@ -421,7 +421,8 @@ namespace Bit.Api.Controllers
             {
                 var paymentService = user.GetPaymentService(_globalSettings);
                 var billingInfo = await paymentService.GetBillingAsync(user);
-                return new BillingResponseModel(user, billingInfo, _licenseService);
+                var license = await _userService.GenerateLicenseAsync(user, billingInfo);
+                return new BillingResponseModel(user, billingInfo, license);
             }
             else
             {

src/Api/Controllers/LicensesController.cs

@@ -0,0 +1,78 @@
+using Microsoft.AspNetCore.Mvc;
+using Bit.Core.Services;
+using Microsoft.AspNetCore.Authorization;
+using Bit.Core;
+using System.Threading.Tasks;
+using Bit.Api.Utilities;
+using Bit.Core.Models.Business;
+using Bit.Core.Exceptions;
+using Bit.Core.Repositories;
+using System;
+
+namespace Bit.Api.Controllers
+{
+    [Route("licenses")]
+    [Authorize("Licensing")]
+    [SelfHosted(NotSelfHostedOnly = true)]
+    public class LicensesController : Controller
+    {
+        private readonly ILicensingService _licensingService;
+        private readonly IUserRepository _userRepository;
+        private readonly IUserService _userService;
+        private readonly IOrganizationRepository _organizationRepository;
+        private readonly IOrganizationService _organizationService;
+        private readonly CurrentContext _currentContext;
+
+        public LicensesController(
+            ILicensingService licensingService,
+            IUserRepository userRepository,
+            IUserService userService,
+            IOrganizationRepository organizationRepository,
+            IOrganizationService organizationService,
+            CurrentContext currentContext)
+        {
+            _licensingService = licensingService;
+            _userRepository = userRepository;
+            _userService = userService;
+            _organizationRepository = organizationRepository;
+            _organizationService = organizationService;
+            _currentContext = currentContext;
+        }
+
+        [HttpGet("user/{id}")]
+        public async Task<UserLicense> GetUser(string id, [FromQuery]string key)
+        {
+            var user = await _userRepository.GetByIdAsync(new Guid(id));
+            if(user == null)
+            {
+                return null;
+            }
+            else if(!user.LicenseKey.Equals(key))
+            {
+                await Task.Delay(2000);
+                throw new BadRequestException("Invalid license key.");
+            }
+
+            var license = await _userService.GenerateLicenseAsync(user, null);
+            return license;
+        }
+
+        [HttpGet("organization/{id}")]
+        public async Task<OrganizationLicense> GetOrganization(string id, [FromQuery]string key)
+        {
+            var org = await _organizationRepository.GetByIdAsync(new Guid(id));
+            if(org == null)
+            {
+                return null;
+            }
+            else if(!org.LicenseKey.Equals(key))
+            {
+                await Task.Delay(2000);
+                throw new BadRequestException("Invalid license key.");
+            }
+
+            var license = await _organizationService.GenerateLicenseAsync(org, _currentContext.InstallationId.Value);
+            return license;
+        }
+    }
+}

src/Api/Startup.cs

@@ -97,6 +97,11 @@ namespace Bit.Api
                     policy.RequireAuthenticatedUser();
                     policy.RequireClaim(JwtClaimTypes.Scope, "api.push");
                 });
+                config.AddPolicy("Licensing", policy =>
+                {
+                    policy.RequireAuthenticatedUser();
+                    policy.RequireClaim(JwtClaimTypes.Scope, "api.licensing");
+                });
             });
 
             services.AddScoped<AuthenticatorTokenProvider>();
@@ -190,7 +195,7 @@ namespace Bit.Api
             var options = new IdentityServerAuthenticationOptions
             {
                 Authority = globalSettings.BaseServiceUri.InternalIdentity,
-                AllowedScopes = new string[] { "api", "api.push" },
+                AllowedScopes = new string[] { "api", "api.push", "api.licensing" },
                 RequireHttpsMetadata = !env.IsDevelopment() && globalSettings.BaseServiceUri.InternalIdentity.StartsWith("https"),
                 NameClaimType = ClaimTypes.Email,
                 // Suffix until we retire the old jwt schemes.