public async void Register_200()
        {
            var mockHandler = new MockHttpMessageHandler();

            var response = new LicenseRegisterResult
            {
                License = "200",
                Failure = new GeneralValidationFailure
                {
                    Code         = "code",
                    Message      = "message",
                    HowToResolve = "how-to-resolve"
                }
            };

            var str = JsonSerializer.Serialize(response);

            mockHandler
            .When("/api/license")
            .Respond("application/json", str);

            var client = mockHandler.ToHttpClient();

            var actx  = Substitute.For <IApplicationContext>();
            var appId = Guid.NewGuid().ToString();

            actx.GetAppId().Returns(appId);

            var service = new LicenseService(actx, client);

            var result = await service.RegisterHttpAsync(Guid.NewGuid(), Guid.NewGuid(), new Dictionary <string, string>(), LicenseGlobals.LicenseServerUrl);

            Assert.Equal("200", result.License);
            Assert.Equal("code", result.Failure.Code);
        }
Esempio n. 2
0
        public async Task <LicenseRegisterResult> CreateAsync(LicenseRegisterRequest request, string userName)
        {
            if (request == null)
            {
                throw new ArgumentNullException(nameof(request));
            }
            if (string.IsNullOrWhiteSpace(userName))
            {
                throw new ArgumentNullException(nameof(userName));
            }

            try
            {
                _logger.LogDebug(JsonSerializer.Serialize(request));

                var failure = await ValidateAsync(request);

                if (failure != null)
                {
                    return(new LicenseRegisterResult
                    {
                        Failure = (GeneralValidationFailure)failure
                    });
                }

                string attributesJson     = null;
                string attributesChecksum = null;

                if (request.Attributes != null && request.Attributes.Any())
                {
                    attributesJson     = JsonSerializer.Serialize(request.Attributes);
                    attributesChecksum = Utils.GetSha256HashFromString(attributesJson);
                }

                var activationId  = Guid.NewGuid();
                var product       = _context.Products.Single(x => x.LicenseProductId == request.ProductUuid);
                var registration  = _context.Registrations.Single(x => x.LicenseRegistrationId == request.LicenseUuid);
                var licenseString = await CreateLicenseAsync(request, registration, product, activationId);

                await CreateLicenseRecordAsync(registration, licenseString, attributesJson, attributesChecksum, userName, activationId);

                var result = new LicenseRegisterResult();
                result.License = licenseString;

                return(result);
            }
            catch (Exception ex)
            {
                _logger.LogError(ex, ex.Message);

                return(new LicenseRegisterResult
                {
                    Failure = (GeneralValidationFailure)FailureStrings.Get(FailureStrings.ACT06Code)
                });
            }
        }