public string Build(CertificateData data)
{
var jpgPath = this.jpgCertificateBuilder.Build(data);
var pdfPath = BuildPdf(jpgPath);
return(pdfPath);
}
public Certificate GetCertificateFromViewModel(Certificate certificate, CertificateData certData)
{
certificate.StandardUId = StandardUId;
certData.Version = Version;
certificate.CertificateData = JsonConvert.SerializeObject(certData);
return(certificate);
}
private async Task <Certificate> UpdateExistingCertificate(StartCertificateRequest request, Organisation organisation, Certificate certificate)
{
_logger.LogDebug($"Updating existing certificate for Uln:{request.Uln} StandardCode:{request.StandardCode} StandardUId{request.StandardUId}");
var certData = JsonConvert.DeserializeObject <CertificateData>(certificate.CertificateData);
if (certificate.Status == CertificateStatus.Deleted)
{
// Rehydrate cert data when the certificate is deleted
certData = new CertificateData();
}
;
certificate = await PopulateCertificateData(certificate, certData, request, organisation);
// If the certificate was a fail, reset back to draft and reset achievement date and grade
if (certificate.Status == CertificateStatus.Submitted && certData.OverallGrade == CertificateGrade.Fail)
{
certData.AchievementDate = null;
certData.OverallGrade = null;
certificate.Status = CertificateStatus.Draft;
certificate.CertificateData = JsonConvert.SerializeObject(certData);
certificate = await _certificateRepository.Update(certificate, request.Username, CertificateActions.Restart, updateLog : true);
}
else
{
certificate = await _certificateRepository.Update(certificate, request.Username, null);
}
return(certificate);
}
private void Generate(object parameter)
{
this.IsLoading = true;
string error = null;
try
{
var builder = (this.IsImageFormat)
? CertificateBuilderFactory.CreateJpg()
: CertificateBuilderFactory.CreatePdf();
var data = new CertificateData(this.Fullname, this.Birthday, this.Activity, this.Date.Value, this.IsFemale);
var filePath = builder.Build(data);
Process.Start(Path.GetDirectoryName(filePath));
}
catch (Exception e)
{
error = $"Error while creating the certificate: {e.Message}";
}
finally
{
this.IsLoading = false;
}
if (!string.IsNullOrEmpty(error))
{
MessageBox.Show(error, "Error!", MessageBoxButton.OK, MessageBoxImage.Error);
}
}
public async Task WhenCallingCreateCertificate_ExistingEPARecord_VersionIsNotSupplied_GetStandardVersionRequestSent_AndFieldsPopulated(
Standard standard,
Certificate certificate,
CertificateData certData,
CreateBatchCertificateRequest request)
{
//Arrange
certificate.CertificateData = JsonConvert.SerializeObject(certData);
request.StandardCode = 0;
request.CertificateData.Version = null;
_mockMediator.Setup(s => s.Send(It.IsAny <GetCalculatedStandardVersionForApprenticeshipRequest>(), new System.Threading.CancellationToken())).ReturnsAsync(standard);
_mockMediator.Setup(t => t.Send(It.Is <GetCertificateForUlnRequest>(s => s.Uln == request.Uln && s.StandardCode == standard.LarsCode), new System.Threading.CancellationToken())).ReturnsAsync(certificate);
_mockCreateBatchValidator.Setup(s => s.ValidateAsync(request, new System.Threading.CancellationToken())).ReturnsAsync(new ValidationResult());
//Act
var controllerResult = await _certificateBatchController.Create(new List <CreateBatchCertificateRequest> {
request
}) as ObjectResult;
//Assert
_mockMediator.Verify(a => a.Send(It.Is <GetCalculatedStandardVersionForApprenticeshipRequest>(b => b.StandardId == request.StandardReference && b.Uln == request.Uln), new System.Threading.CancellationToken()), Times.Once);
request.StandardCode.Should().Be(standard.LarsCode);
request.StandardReference.Should().NotBe(standard.IfateReferenceNumber);
// Making sure the EPA record populates the data on the request
request.CertificateData.Version.Should().Be(certData.Version);
request.StandardUId.Should().Be(certificate.StandardUId);
}
public async Task AndCreatesNewCertificate_SetsCertificateDataForFail(
CreateBatchEpaRequest request,
CertificateData certificateData,
Certificate certificate)
{
//Arrange
certificateData.EpaDetails = new EpaDetails {
Epas = new List <EpaRecord>()
}; // reset details for fail.
certificate.CertificateData = JsonConvert.SerializeObject(certificateData);
_mockCertificateRepository.Setup(s => s.GetCertificate(request.Uln, request.StandardCode)).ReturnsAsync((Certificate)null);
_mockMediator.Setup(s => s.Send(It.IsAny <StartCertificateRequest>(), new CancellationToken())).ReturnsAsync(certificate);
var latestEpa = request.EpaDetails.Epas.OrderByDescending(s => s.EpaDate).FirstOrDefault();
latestEpa.EpaOutcome = EpaOutcome.Fail;
var epaAction = CertificateActions.Submit;
//Act
var result = await _sut.Handle(request, new CancellationToken());
//Assert
var data = JsonConvert.DeserializeObject <CertificateData>(certificate.CertificateData);
data.AchievementDate.Should().Be(latestEpa.EpaDate);
data.OverallGrade.Should().Be(latestEpa.EpaOutcome);
certificate.Status.Should().Be(CertificateStatus.Submitted);
_mockCertificateRepository.Verify(s => s.Update(It.IsAny <Certificate>(), "API", epaAction, true, null), Times.Once);
}
public async Task AndCreatesNewCertificate_UpdatesEpaDetails(
CreateBatchEpaRequest request,
CertificateData certificateData,
Certificate certificate)
{
//Arrange
// Reset EpaDetails
certificateData.EpaDetails = new EpaDetails {
Epas = new System.Collections.Generic.List <EpaRecord>()
};
certificate.CertificateData = JsonConvert.SerializeObject(certificateData);
_mockCertificateRepository.Setup(s => s.GetCertificate(request.Uln, request.StandardCode)).ReturnsAsync((Certificate)null);
_mockMediator.Setup(s => s.Send(It.IsAny <StartCertificateRequest>(), new CancellationToken())).ReturnsAsync(certificate);
//Act
var result = await _sut.Handle(request, new CancellationToken());
//Assert
var latestEpa = request.EpaDetails.Epas.OrderByDescending(s => s.EpaDate).FirstOrDefault();
result.LatestEpaDate.Should().Be(latestEpa.EpaDate);
result.LatestEpaOutcome.Should().Be(latestEpa.EpaOutcome);
result.Epas.Should().BeEquivalentTo(request.EpaDetails.Epas);
_mockCertificateRepository.Verify(s => s.Update(It.IsAny <Certificate>(), "API", It.IsAny <string>(), true, null), Times.Once);
}
public override int GetHashCode()
{
int hash = 1;
if (RegistryId.Length != 0)
{
hash ^= RegistryId.GetHashCode();
}
if (Fingerprint.Length != 0)
{
hash ^= Fingerprint.GetHashCode();
}
if (CertificateData.Length != 0)
{
hash ^= CertificateData.GetHashCode();
}
if (createdAt_ != null)
{
hash ^= CreatedAt.GetHashCode();
}
if (_unknownFields != null)
{
hash ^= _unknownFields.GetHashCode();
}
return(hash);
}
public async Task WhenCallingUpdateEpa_WithExistingCertificate_VersionIsNotSupplied_CertificateUsedToPopulateFields(
Standard standard,
Certificate certificate,
CertificateData certificateData,
UpdateBatchEpaRequest request)
{
//Arrange
request.Version = null;
request.StandardReference = null;
certificate.CertificateData = JsonConvert.SerializeObject(certificateData);
_mockMediator.Setup(s => s.Send(It.IsAny <GetCalculatedStandardVersionForApprenticeshipRequest>(), new System.Threading.CancellationToken())).ReturnsAsync(standard);
_mockMediator.Setup(t => t.Send(It.Is <GetCertificateForUlnRequest>(s => s.Uln == request.Uln && s.StandardCode == standard.LarsCode), new System.Threading.CancellationToken())).ReturnsAsync(certificate);
_mockUpdateBatchValidator.Setup(s => s.ValidateAsync(request, new System.Threading.CancellationToken())).ReturnsAsync(new ValidationResult());
//Act
var controllerResult = await _epaBatchController.Update(new List <UpdateBatchEpaRequest> {
request
}) as ObjectResult;
//Assert
_mockMediator.Verify(a => a.Send(It.Is <GetCalculatedStandardVersionForApprenticeshipRequest>(b => b.StandardId == request.StandardCode.ToString() && b.Uln == request.Uln), new System.Threading.CancellationToken()), Times.Once);
request.Version.Should().Be(certificateData.Version);
request.StandardUId.Should().Be(certificate.StandardUId);
request.StandardReference.Should().Be(standard.IfateReferenceNumber);
request.StandardCode.Should().NotBe(standard.LarsCode);
}
public Certificate GetCertificateFromViewModel(Certificate certificate, CertificateData certData)
{
certData.CourseOption = SelectedOption;
certificate.CertificateData = JsonConvert.SerializeObject(certData);
return(certificate);
}
private async Task <Certificate> CreateNewCertificate(StartCertificateRequest request)
{
_logger.LogInformation("CreateNewCertificate Before Get Ilr from db");
var ilr = await _ilrRepository.Get(request.Uln, request.StandardCode);
_logger.LogInformation("CreateNewCertificate Before Get Organisation from db");
var organisation = await _organisationQueryRepository.GetByUkPrn(request.UkPrn);
_logger.LogInformation("CreateNewCertificate Before Get Standard from API");
var standard = await _standardService.GetStandard(ilr.StdCode);
_logger.LogInformation("CreateNewCertificate Before Get Provider from API");
var provider = await GetProviderFromUkprn(ilr.UkPrn);
var certData = new CertificateData()
{
LearnerGivenNames = ilr.GivenNames,
LearnerFamilyName = ilr.FamilyName,
LearningStartDate = ilr.LearnStartDate,
StandardReference = standard.ReferenceNumber,
StandardName = standard.Title,
StandardLevel = standard.StandardData.Level.GetValueOrDefault(),
StandardPublicationDate = standard.StandardData.EffectiveFrom.GetValueOrDefault(),
FullName = $"{ilr.GivenNames} {ilr.FamilyName}",
ProviderName = provider.ProviderName,
EpaDetails = new EpaDetails {
Epas = new List <EpaRecord>()
}
};
_logger.LogInformation("CreateNewCertificate Before create new Certificate");
var newCertificate = await _certificateRepository.New(
new Certificate()
{
Uln = request.Uln,
StandardCode = request.StandardCode,
ProviderUkPrn = ilr.UkPrn,
OrganisationId = organisation.Id,
CreatedBy = request.Username,
CertificateData = JsonConvert.SerializeObject(certData),
Status = CertificateStatus.Draft,
CertificateReference = "",
LearnRefNumber = ilr.LearnRefNumber,
CreateDay = DateTime.UtcNow.Date
});
newCertificate.CertificateReference = newCertificate.CertificateReferenceId.ToString().PadLeft(8, '0');
// need to update EPA Reference too
certData.EpaDetails.EpaReference = newCertificate.CertificateReference;
newCertificate.CertificateData = JsonConvert.SerializeObject(certData);
_logger.LogInformation("CreateNewCertificate Before Update Cert in db");
await _certificateRepository.Update(newCertificate, request.Username, null);
_logger.LogInformation(LoggingConstants.CertificateStarted);
_logger.LogInformation($"Certificate with ID: {newCertificate.Id} Started with reference of {newCertificate.CertificateReference}");
return(newCertificate);
}
public async Task WhenHandlingStartCertificateRequest_AndThereIsExistingCertificate_NotDeleted_UpdatesCertificateForNewGrade(
StartCertificateRequest request,
Organisation organisationRecord,
Certificate existingCertificate,
CertificateData certificateData,
Standard standard,
Provider provider,
Domain.Entities.Learner learnerRecord)
{
// Arrange
existingCertificate.Status = CertificateStatus.Submitted;
certificateData.OverallGrade = CertificateGrade.Fail;
existingCertificate.CertificateData = JsonConvert.SerializeObject(certificateData);
_mockOrganisationQueryRepository.Setup(s => s.GetByUkPrn(request.UkPrn)).ReturnsAsync(organisationRecord);
_mockCertificateRepository.Setup(s => s.GetCertificate(request.Uln, request.StandardCode)).ReturnsAsync(existingCertificate);
_mockStandardService.Setup(s => s.GetStandardVersionById(request.StandardUId, null)).ReturnsAsync(standard);
_mockLearnerRepository.Setup(s => s.Get(request.Uln, request.StandardCode)).ReturnsAsync(learnerRecord);
_mockProvidersRepository.Setup(s => s.GetProvider(learnerRecord.UkPrn)).ReturnsAsync(provider);
Certificate updatedCertficate = null;
_mockCertificateRepository.Setup(s => s.Update(It.IsAny <Certificate>(), It.IsAny <string>(), It.IsAny <string>(), true, null))
.Callback <Certificate, string, string, bool, string>((cert, username, action, updateLogs, reason) =>
{
updatedCertficate = cert;
}).ReturnsAsync(updatedCertficate);
// Act
var response = await _sut.Handle(request, new CancellationToken());
// Assertions
updatedCertficate.Status.Should().Be(CertificateStatus.Draft);
_mockCertificateRepository.Verify(s => s.Update(existingCertificate, request.Username, CertificateActions.Restart, true, null), Times.Once);
}
private Certificate RedactCertificateInformation(Certificate certificate, bool showEpaDetails)
{
// certificate is track-able entity. So we have to do this in order to stop it from updating in the database
var json = JsonConvert.SerializeObject(certificate);
var cert = JsonConvert.DeserializeObject <Certificate>(json);
var certData = JsonConvert.DeserializeObject <CertificateData>(certificate.CertificateData);
CertificateData redactedData = new CertificateData
{
LearnerGivenNames = certData.LearnerGivenNames,
LearnerFamilyName = certData.LearnerFamilyName,
StandardReference = certData.StandardReference,
StandardName = certData.StandardName,
StandardLevel = certData.StandardLevel,
StandardPublicationDate = certData.StandardPublicationDate,
EpaDetails = showEpaDetails ? certData.EpaDetails : null
};
cert.CertificateData = JsonConvert.SerializeObject(redactedData);
cert.CertificateReference = null;
cert.CertificateReferenceId = null;
cert.CreateDay = DateTime.MinValue;
cert.CreatedAt = DateTime.MinValue;
cert.CreatedBy = null;
cert.UpdatedAt = null;
cert.UpdatedBy = null;
cert.DeletedBy = null;
cert.DeletedAt = null;
return(cert);
}
internal static CertificateCollection DeserializeCertificateCollection(JsonElement element)
{
IReadOnlyList <CertificateData> value = default;
Optional <string> nextLink = default;
foreach (var property in element.EnumerateObject())
{
if (property.NameEquals("value"))
{
List <CertificateData> array = new List <CertificateData>();
foreach (var item in property.Value.EnumerateArray())
{
array.Add(CertificateData.DeserializeCertificateData(item));
}
value = array;
continue;
}
if (property.NameEquals("nextLink"))
{
nextLink = property.Value.GetString();
continue;
}
}
return(new CertificateCollection(value, nextLink.Value));
}
static void CertificateUpdate(CertificateData cert, SelectableMenuOptions options)
{
Console.Clear();
Console.ForegroundColor = ConsoleColor.Magenta;
Console.WriteLine($"Certificate edit : {cert.Businessname}");
var certificatesoptions = new SelectableMenu <Action>(options);
var props = cert.GetType().GetProperties();
foreach (var prop in props)
{
var name = prop.Name;
var value = prop.GetValue(cert);
value = name == "Password" ? "****" : value;
certificatesoptions.Add($"{name} : {value}", () =>
{
if (name != "Id")
{
UpdateCertificateValue(cert, name, options);
}
else
{
CertificateUpdate(cert, options);
}
});
}
certificatesoptions.Add("Back", () =>
{
Console.Clear();
});
certificatesoptions.Draw().Invoke();
}
public void SetUp()
{
_mockCertificateApiClient = new Mock <ICertificateApiClient>();
_mockContextAccessor = new Mock <IHttpContextAccessor>();
_mockSessionService = new Mock <ISessionService>();
_mockContextAccessor.Setup(s => s.HttpContext.User.FindFirst("http://schemas.portal.com/ukprn")).Returns(new Claim("", Ukprn.ToString()));
_mockContextAccessor.Setup(s => s.HttpContext.User.FindFirst("http://schemas.xmlsoap.org/ws/2005/05/identity/claims/upn")).Returns(new Claim("", Username));
_mockContextAccessor.Setup(s => s.HttpContext.User.FindFirst("http://schemas.portal.com/epaoid")).Returns(new Claim("", EpaoId));
_mockContextAccessor.Setup(s => s.HttpContext.Request.Query).Returns(Mock.Of <IQueryCollection>());
var certData = new CertificateData();
var certDataString = JsonConvert.SerializeObject(certData);
_mockCertificateApiClient.Setup(s => s.GetCertificate(It.IsAny <Guid>(), false)).ReturnsAsync(
new Certificate
{
Id = CertificateId,
CertificateData = certDataString
});
_certificateOptionController = new CertificateOptionController(Mock.Of <ILogger <CertificateController> >(),
_mockContextAccessor.Object,
_mockCertificateApiClient.Object,
_mockSessionService.Object);
}
public Certificate GetCertificateFromViewModel(Certificate certificate, CertificateData data)
{
data.CourseOption = HasAdditionalLearningOption ? Option : string.Empty;
certificate.CertificateData = JsonConvert.SerializeObject(data);
return(certificate);
}
private async Task <Certificate> CreateNewCertificate(StartCertificateRequest request, Organisation organisation)
{
_logger.LogDebug($"Creating new certificate for Uln:{request.Uln} StandardCode:{request.StandardCode} StandardUId{request.StandardUId}");
var certificate = new Certificate();
var certificateData = new CertificateData
{
EpaDetails = new EpaDetails {
Epas = new List <EpaRecord>()
}
};
certificate.Uln = request.Uln;
certificate.StandardCode = request.StandardCode;
certificate.Status = CertificateStatus.Draft;
certificate.CreatedBy = request.Username;
certificate.CertificateReference = string.Empty;
certificate.CreateDay = DateTime.UtcNow.Date;
certificate = await PopulateCertificateData(certificate, certificateData, request, organisation);
var newCertificate = await _certificateRepository.New(certificate);
_logger.LogDebug($"Created new certificate with Id:{newCertificate.Id} CertificateReference:{newCertificate.CertificateReference}");
return(newCertificate);
}
public Certificate GetCertificateFromViewModel(Certificate certificate, CertificateData data)
{
data.AchievementDate = new DateTime(int.Parse(Year), int.Parse(Month), int.Parse(Day));
certificate.CertificateData = JsonConvert.SerializeObject(data);
return(certificate);
}
public void Add(CertificateData Entity)
{
var parameters = new { Password = Entity.Password, Path = Entity.Path, BusinessName = Entity.Businessname };
_dbconnection.Execute($"INSERT INTO CertificateData (Password, Path, BusinessName) VALUES (@Password," +
$"@Path," +
$"@BusinessName)", parameters);
}
private void OnExportDetails(object sender, RoutedEventArgs e)
{
if (ExportCertificateDetails != null)
{
Button btn = (Button)sender;
CertificateData certificateData = (CertificateData)btn.DataContext;
ExportCertificateDetails(this, certificateData);
}
}
public void Update(CertificateData Entity)
{
var parameters = new { Password = Entity.Password, Path = Entity.Path, BusinessName = Entity.Businessname };
_dbconnection.Execute($"UPDATE CertificateData SET Password = @Password," +
$" Path = @Path," +
$" BusinessName = @BusinessName" +
$" WHERE Id = { Entity.Id }", parameters);
}
private CertificateData CombineCertificateData(CertificateData certData, CertificateData requestData, StandardOptions options)
{
var epaDetails = certData.EpaDetails ?? new EpaDetails();
if (epaDetails.Epas is null)
{
epaDetails.Epas = new List <EpaRecord>();
}
var epaOutcome = certData.OverallGrade == CertificateGrade.Fail ? EpaOutcome.Fail : EpaOutcome.Pass;
if (requestData.AchievementDate != null && !epaDetails.Epas.Any(rec => rec.EpaDate == requestData.AchievementDate.Value && rec.EpaOutcome == epaOutcome))
{
var record = new EpaRecord {
EpaDate = requestData.AchievementDate.Value, EpaOutcome = epaOutcome
};
epaDetails.Epas.Add(record);
// sort pass outcomes before fail outcomes as pass is the final state even if earlier than the fail
var latestRecord = epaDetails.Epas
.OrderByDescending(epa => epa.EpaOutcome != EpaOutcome.Fail ? 1 : 0)
.ThenByDescending(epa => epa.EpaDate)
.First();
epaDetails.LatestEpaDate = latestRecord.EpaDate;
epaDetails.LatestEpaOutcome = latestRecord.EpaOutcome;
}
return(new CertificateData()
{
LearnerGivenNames = certData.LearnerGivenNames,
LearnerFamilyName = certData.LearnerFamilyName,
LearningStartDate = certData.LearningStartDate,
StandardReference = certData.StandardReference,
StandardName = certData.StandardName,
StandardLevel = certData.StandardLevel,
StandardPublicationDate = certData.StandardPublicationDate,
FullName = certData.FullName,
ProviderName = certData.ProviderName,
ContactName = requestData.ContactName,
ContactOrganisation = requestData.ContactOrganisation,
Department = requestData.Department,
ContactAddLine1 = requestData.ContactAddLine1,
ContactAddLine2 = requestData.ContactAddLine2,
ContactAddLine3 = requestData.ContactAddLine3,
ContactAddLine4 = requestData.ContactAddLine4,
ContactPostCode = requestData.ContactPostCode,
Registration = requestData.Registration,
AchievementDate = requestData.AchievementDate,
CourseOption = CertificateHelpers.NormalizeCourseOption(options, requestData.CourseOption),
Version = requestData.Version,
OverallGrade = CertificateHelpers.NormalizeOverallGrade(requestData.OverallGrade),
EpaDetails = epaDetails
});
}
private string GetCertificateData()
{
var certData = new CertificateData
{
ContactName = "ContactName"
};
return(JsonConvert.SerializeObject(certData));
}
public Certificate GetCertificateFromViewModel(Certificate certificate, CertificateData data)
{
data.ContactName = Name;
data.Department = Dept;
certificate.CertificateData = JsonConvert.SerializeObject(data);
return(certificate);
}
private static string GetSubmittedOrPreviousGrade(Certificate certificate, CertificateData currentCertificateData, CertificateData submittedCertificateData)
{
if (certificate.Status == "Draft" && certificate.Status != "Deleted")
{
return(submittedCertificateData.OverallGrade);
}
return(currentCertificateData.OverallGrade);
}
public CertificateAmendQueryBase()
{
MockedLogger = new Mock <ILogger <CertificateAmendController> >();
var mockedApiClientLogger = new Mock <ILogger <ApiClient> >();
MockHttpContextAccessor = SetupMockedHttpContextAccessor();
ApiClient = SetupApiClient(mockedApiClientLogger);
CertificateData = JsonConvert.DeserializeObject <CertificateData>(Certificate.CertificateData);
}
public bool AddressHasChanged(CertificateData certData)
{
return
(certData.ContactOrganisation != Employer ||
certData.ContactAddLine1 != AddressLine1 ||
certData.ContactAddLine2 != AddressLine2 ||
certData.ContactAddLine3 != AddressLine3 ||
certData.ContactAddLine4 != City ||
certData.ContactPostCode != Postcode);
}
private CertificateData GetCertificateDataFromCertificate(Certificate certificate)
{
CertificateData certificateData = null;
if (certificate != null)
{
certificateData = JsonConvert.DeserializeObject <CertificateData>(certificate.CertificateData);
}
return(certificateData);
}
public static byte[] EncodeJwt(string username, CngKey newKey)
{
byte[] t = ImportECDsaCngKeyFromCngKey(newKey.Export(CngKeyBlobFormat.EccPrivateBlob));
CngKey tk = CngKey.Import(t, CngKeyBlobFormat.EccPrivateBlob);
ECDiffieHellmanCng ecKey = new ECDiffieHellmanCng(newKey);
ecKey.HashAlgorithm = CngAlgorithm.Sha256;
ecKey.KeyDerivationFunction = ECDiffieHellmanKeyDerivationFunction.Hash;
string b64Key = Convert.ToBase64String(ecKey.PublicKey.GetDerEncoded());
long exp = DateTimeOffset.UtcNow.AddDays(1).ToUnixTimeMilliseconds();
CertificateData certificateData = new CertificateData
{
Exp = exp,
Iat = exp,
ExtraData = new ExtraData
{
DisplayName = username,
//Identity = "af6f7c5e-fcea-3e43-bf3a-e005e400e579",
Identity = Guid.NewGuid().ToString(),
},
Iss = "self",
IdentityPublicKey = b64Key,
CertificateAuthority = true,
Nbf = exp,
RandomNonce = new Random().Next(),
};
// string txt = $@"{{
// ""exp"": 1467508449,
// ""extraData"": {{
// ""displayName"": ""gurunxx"",
// ""identity"": ""4e0199c6-7cfd-3550-b676-74398e0a5f1a""
// }},
// ""identityPublicKey"": ""{b64Key}"",
// ""nbf"": 1467508448
//}}";
string val = JWT.Encode(certificateData, tk, JwsAlgorithm.ES384, new Dictionary <string, object> {
{ "x5u", b64Key }
});
Log.Warn(JWT.Payload(val));
Log.Warn(string.Join(";", JWT.Headers(val)));
//val = "eyJhbGciOiJFUzM4NCIsIng1dSI6Ik1IWXdFQVlIS29aSXpqMENBUVlGSzRFRUFDSURZZ0FFREVLck5xdk93Y25iV3I5aUtVQ0MyeklFRmZ6Q0VnUEhQdG5Kd3VEdnZ3VjVtd1E3QzNkWmhqd0g0amxWc2RDVTlNdVl2QllQRktCTEJkWU52K09ZeW1MTFJGTU9odVFuSDhuZFRRQVV6VjJXRTF4dHdlVG1wSVFzdXdmVzRIdzAifQo.eyJleHAiOjE0Njc1MDg0NDksImV4dHJhRGF0YSI6eyJkaXNwbGF5TmFtZSI6Imd1cnVueHgiLCJpZGVudGl0eSI6IjRlMDE5OWM2LTdjZmQtMzU1MC1iNjc2LTc0Mzk4ZTBhNWYxYSJ9LCJpZGVudGl0eVB1YmxpY0tleSI6Ik1IWXdFQVlIS29aSXpqMENBUVlGSzRFRUFDSURZZ0FFREVLck5xdk93Y25iV3I5aUtVQ0MyeklFRmZ6Q0VnUEhQdG5Kd3VEdnZ3VjVtd1E3QzNkWmhqd0g0amxWc2RDVTlNdVl2QllQRktCTEJkWU52K09ZeW1MTFJGTU9odVFuSDhuZFRRQVV6VjJXRTF4dHdlVG1wSVFzdXdmVzRIdzAiLCJuYmYiOjE0Njc1MDg0NDh9Cg.jpCqzTo8nNVEW8ArK1NFBaqLx6kyJV6wPF8cAU6UGav6cfMc60o3m5DjwspN-JcyC14AlcNiPdWX8TEm1QFhtScb-bXo4WOJ0dNYXV8iI_eCTCcXMFjX4vgIHpb9xfjv";
val = $@"{{ ""chain"": [""{val}""] }}";
return(Encoding.UTF8.GetBytes(val));
}
public static byte[] EncodeJwt(string username, CngKey newKey)
{
byte[] t = ImportECDsaCngKeyFromCngKey(newKey.Export(CngKeyBlobFormat.EccPrivateBlob));
CngKey tk = CngKey.Import(t, CngKeyBlobFormat.EccPrivateBlob);
ECDiffieHellmanCng ecKey = new ECDiffieHellmanCng(newKey);
ecKey.HashAlgorithm = CngAlgorithm.Sha256;
ecKey.KeyDerivationFunction = ECDiffieHellmanKeyDerivationFunction.Hash;
string b64Key = Convert.ToBase64String(ecKey.PublicKey.GetDerEncoded());
long exp = DateTimeOffset.UtcNow.AddDays(1).ToUnixTimeMilliseconds();
CertificateData certificateData = new CertificateData
{
Exp = exp,
Iat = exp,
ExtraData = new ExtraData
{
DisplayName = username,
//Identity = "af6f7c5e-fcea-3e43-bf3a-e005e400e579",
Identity = Guid.NewGuid().ToString(),
},
Iss = "self",
IdentityPublicKey = b64Key,
CertificateAuthority = true,
Nbf = exp,
RandomNonce = new Random().Next(),
};
// string txt = $@"{{
// ""exp"": 1467508449,
// ""extraData"": {{
// ""displayName"": ""gurunxx"",
// ""identity"": ""4e0199c6-7cfd-3550-b676-74398e0a5f1a""
// }},
// ""identityPublicKey"": ""{b64Key}"",
// ""nbf"": 1467508448
//}}";
string val = JWT.Encode(certificateData, tk, JwsAlgorithm.ES384, new Dictionary<string, object> {{"x5u", b64Key}});
Log.Warn(JWT.Payload(val));
Log.Warn(string.Join(";", JWT.Headers(val)));
//val = "eyJhbGciOiJFUzM4NCIsIng1dSI6Ik1IWXdFQVlIS29aSXpqMENBUVlGSzRFRUFDSURZZ0FFREVLck5xdk93Y25iV3I5aUtVQ0MyeklFRmZ6Q0VnUEhQdG5Kd3VEdnZ3VjVtd1E3QzNkWmhqd0g0amxWc2RDVTlNdVl2QllQRktCTEJkWU52K09ZeW1MTFJGTU9odVFuSDhuZFRRQVV6VjJXRTF4dHdlVG1wSVFzdXdmVzRIdzAifQo.eyJleHAiOjE0Njc1MDg0NDksImV4dHJhRGF0YSI6eyJkaXNwbGF5TmFtZSI6Imd1cnVueHgiLCJpZGVudGl0eSI6IjRlMDE5OWM2LTdjZmQtMzU1MC1iNjc2LTc0Mzk4ZTBhNWYxYSJ9LCJpZGVudGl0eVB1YmxpY0tleSI6Ik1IWXdFQVlIS29aSXpqMENBUVlGSzRFRUFDSURZZ0FFREVLck5xdk93Y25iV3I5aUtVQ0MyeklFRmZ6Q0VnUEhQdG5Kd3VEdnZ3VjVtd1E3QzNkWmhqd0g0amxWc2RDVTlNdVl2QllQRktCTEJkWU52K09ZeW1MTFJGTU9odVFuSDhuZFRRQVV6VjJXRTF4dHdlVG1wSVFzdXdmVzRIdzAiLCJuYmYiOjE0Njc1MDg0NDh9Cg.jpCqzTo8nNVEW8ArK1NFBaqLx6kyJV6wPF8cAU6UGav6cfMc60o3m5DjwspN-JcyC14AlcNiPdWX8TEm1QFhtScb-bXo4WOJ0dNYXV8iI_eCTCcXMFjX4vgIHpb9xfjv";
val = $@"{{ ""chain"": [""{val}""] }}";
return Encoding.UTF8.GetBytes(val);
}
public void TestJWTHandling()
{
CngKey newKey = CngKey.Create(CngAlgorithm.ECDiffieHellmanP384, null, new CngKeyCreationParameters() {ExportPolicy = CngExportPolicies.AllowPlaintextExport, KeyUsage = CngKeyUsages.AllUsages});
byte[] t = CryptoUtils.ImportECDsaCngKeyFromCngKey(newKey.Export(CngKeyBlobFormat.EccPrivateBlob));
CngKey tk = CngKey.Import(t, CngKeyBlobFormat.EccPrivateBlob);
Assert.AreEqual(CngAlgorithmGroup.ECDsa, tk.AlgorithmGroup);
ECDiffieHellmanCng ecKey = new ECDiffieHellmanCng(newKey);
ecKey.HashAlgorithm = CngAlgorithm.Sha256;
ecKey.KeyDerivationFunction = ECDiffieHellmanKeyDerivationFunction.Hash;
var b64Key = Base64Url.Encode(ecKey.PublicKey.GetDerEncoded());
string test = $@"
{{
""exp"": 1464983845,
""extraData"": {{
""displayName"": ""gurunx"",
""identity"": ""af6f7c5e -fcea-3e43-bf3a-e005e400e578""
}},
""identityPublicKey"": ""{b64Key}"",
""nbf"": 1464983844
}}";
CertificateData certificateData = new CertificateData
{
Exp = 1464983845,
ExtraData = new ExtraData
{
DisplayName = "gurun",
Identity = "af6f7c5e -fcea-3e43-bf3a-e005e400e578",
},
IdentityPublicKey = b64Key,
Nbf = 1464983844,
};
JWT.JsonMapper = new NewtonsoftMapper();
string val = JWT.Encode(certificateData, tk, JwsAlgorithm.ES384, new Dictionary<string, object> {{"x5u", b64Key}});
Console.WriteLine(val);
Assert.AreEqual(b64Key, JWT.Headers(val)["x5u"]);
//Assert.AreEqual("", string.Join(";", JWT.Headers(val)));
//Assert.AreEqual(test, JWT.Payload(val));
Console.WriteLine(JWT.Payload(val));
IDictionary<string, dynamic> headers = JWT.Headers(val);
if (headers.ContainsKey("x5u"))
{
string certString = headers["x5u"];
// Validate
CngKey importKey = CryptoUtils.ImportECDsaCngKeyFromString(certString);
CertificateData data = JWT.Decode<CertificateData>(val, importKey);
Assert.NotNull(data);
Assert.AreEqual(certificateData.Exp, data.Exp);
Assert.AreEqual(certificateData.IdentityPublicKey, data.IdentityPublicKey);
Assert.AreEqual(certificateData.Nbf, data.Nbf);
Assert.NotNull(data.ExtraData);
Assert.AreEqual(certificateData.ExtraData.DisplayName, data.ExtraData.DisplayName);
Assert.AreEqual(certificateData.ExtraData.Identity, data.ExtraData.Identity);
}
}
