public override CAConnectorCertificate GetSingleRecord(string caRequestID)
{
Logger.MethodEntry(ILogExtensions.MethodLogLevel.Debug);
CertificateStatusEnum certStatus = CertificateStatusEnum.PENDING_ISSUANCE;
GETCertificateDetailsResponse certResponse = JsonConvert.DeserializeObject <GETCertificateDetailsResponse>(_api.GetCertificate(caRequestID));
Enum.TryParse(certResponse.status, out certStatus);
string issuedCert = string.Empty;
if (certStatus == CertificateStatusEnum.ISSUED || certStatus == CertificateStatusEnum.REVOKED || certStatus == CertificateStatusEnum.EXPIRED)
{
issuedCert = RemovePEMHeader(JsonConvert.DeserializeObject <GETCertificateResponse>(_api.DownloadCertificate(caRequestID)).pems.certificate);
}
Logger.MethodExit(ILogExtensions.MethodLogLevel.Debug);
return(new CAConnectorCertificate()
{
CARequestID = caRequestID,
Certificate = issuedCert,
CSR = certResponse.csr,
ResolutionDate = certResponse.createdAt,
RevocationDate = certResponse.revokedAt,
RevocationReason = null,
Status = APIProcessor.MapReturnStatus(certStatus),
SubmissionDate = certResponse.createdAt
});
}
public override void Synchronize(ICertificateDataReader certificateDataReader, BlockingCollection <CAConnectorCertificate> blockingBuffer, CertificateAuthoritySyncInfo certificateAuthoritySyncInfo, CancellationToken cancelToken)
{
Logger.MethodEntry(ILogExtensions.MethodLogLevel.Debug);
string customerId = JsonConvert.DeserializeObject <GETShopperResponse>(_api.GetCustomerId()).customerId;
int pageNumber = 1;
bool wasLastPage = false;
do
{
GETCertificatesDetailsResponse certificates = JsonConvert.DeserializeObject <GETCertificatesDetailsResponse>(_api.GetCertificates(customerId, pageNumber, _syncPageSize));
foreach (CertificateDetails certificate in certificates.certificates)
{
Thread.Sleep(1000);
try
{
string issuedCert = RemovePEMHeader(JsonConvert.DeserializeObject <GETCertificateResponse>(_api.DownloadCertificate(certificate.certificateId)).pems.certificate);
CertificateStatusEnum certStatus = CertificateStatusEnum.ISSUED;
if (!Enum.TryParse(certificate.status, out certStatus))
{
certStatus = CertificateStatusEnum.CANCELED;
}
blockingBuffer.Add(new CAConnectorCertificate
{
CARequestID = certificate.certificateId,
Certificate = issuedCert,
CSR = string.Empty,
ResolutionDate = certificate.completedAt,
RevocationDate = certificate.revokedAt,
RevocationReason = null,
Status = APIProcessor.MapReturnStatus(certStatus),
SubmissionDate = certificate.createdAt,
ProductID = certificate.type
});
}
catch (GoDaddyException) { }
}
wasLastPage = certificates.pagination.previous == certificates.pagination.last;
pageNumber++;
} while (!wasLastPage);
blockingBuffer.CompleteAdding();
Logger.MethodExit(ILogExtensions.MethodLogLevel.Debug);
}
private async Task LoadImage(int ImageNum = 0)
{
var comic = await APIProcessor.LoadData(ImageNum);
if (ImageNum == 0)
{
MaxNum = comic.Num;
}
CurrentNum = comic.Num;
var urisource = new Uri(comic.Img, UriKind.Absolute);
pictureBox1.LoadAsync(urisource.ToString());
}
public override int Revoke(string caRequestID, string hexSerialNumber, uint revocationReason)
{
Logger.MethodEntry(ILogExtensions.MethodLogLevel.Debug);
try
{
_api.RevokeCertificate(caRequestID, APIProcessor.MapRevokeReason(revocationReason));
}
catch (Exception ex)
{
return(Convert.ToInt32(PKIConstants.Microsoft.RequestDisposition.FAILED));
}
Logger.MethodExit(ILogExtensions.MethodLogLevel.Debug);
return(Convert.ToInt32(PKIConstants.Microsoft.RequestDisposition.REVOKED));
}
private async Task <WeatherModel> LoadWeather()
{
string url = GetURL();
WeatherModel response = new WeatherModel();
try
{
response = await APIProcessor <WeatherModel> .APICall(GetURL());
}
catch (Exception e)
{
response = await APIProcessor <WeatherModel> .APICall(GetDefaultURL());
MessageBox.Show("Error while loading weather data. Server response: " + e.Message, "Error", MessageBoxButton.OK, MessageBoxImage.Error);
}
return(response);
}
public async Task APIProcessor_Scenario_APICall_ReturnsWeatherModel()
{
//Arrange
APIHelper.InitializeClient();
//Act
string url = "https://samples.openweathermap.org/data/2.5/weather?id=2172797&appid=b6907d289e10d714a6e88b30761fae22";
WeatherModel actualResult = await APIProcessor <WeatherModel> .APICall(url);
HttpResponseMessage response = await APIHelper.APIClient.GetAsync(url);
WeatherModel expectedResult = await response.Content.ReadAsAsync <WeatherModel>();
Task.WaitAll();
//Assert
Assert.IsTrue(actualResult == expectedResult);
}
public override void Initialize(ICAConnectorConfigProvider configProvider)
{
Logger.MethodEntry(ILogExtensions.MethodLogLevel.Debug);
foreach (KeyValuePair <string, object> configEntry in configProvider.CAConnectionData)
{
Logger.Trace($"{configEntry.Key}: {configEntry.Value}");
}
ValidateParameters <object>(configProvider.CAConnectionData, _connectionKeys);
string apiUrl = configProvider.CAConnectionData["ApiUrl"].ToString();
string apiKey = configProvider.CAConnectionData["ApiKey"].ToString();
string shopperId = configProvider.CAConnectionData["ShopperId"].ToString();
_rootType = configProvider.CAConnectionData["RootType"].ToString();
_syncPageSize = Convert.ToInt32(configProvider.CAConnectionData["SyncPageSize"]);
_enrollmentRetries = Convert.ToInt32(configProvider.CAConnectionData["EnrollmentRetries"]);
_secondsBetweenEnrollmentRetries = Convert.ToInt32(configProvider.CAConnectionData["SecondsBetweenEnrollmentRetries"]);
_api = new APIProcessor(apiUrl, apiKey, shopperId);
Logger.MethodExit(ILogExtensions.MethodLogLevel.Debug);
}
private async Task LoadEvents()
{
try
{
Console.WriteLine("Try block");
MenuItems = new ObservableCollection <EventModel>();
List <EventAPIModel> eventListItem = await APIProcessor.LoadEventsFromDB();
Console.WriteLine("event: " + eventListItem[0].Name);
foreach (var attraction in eventListItem)
{
if (attraction.isAccepted == "true")
{
PlaceModel placeResults = await APIProcessor.LoadPlace(attraction.Placeid);
MenuItems.Add(new EventModel
{
Place = placeResults.Place,
Description = attraction.Description,
Enddatetime = attraction.Enddatetime,
Entrancefee = attraction.Entrancefee.ToString(),
EventImage = attraction.EventImage,
Name = attraction.Name,
Startdatetime = attraction.Startdatetime.ToString()
});
Console.WriteLine("event added: " + eventListItem[0].Name);
}
}
Console.Write("events list after foreach: " + MenuItems.Count);
}
catch (Exception ex)
{
Console.WriteLine("Catch block in the MainPageDetailView : " + ex);
}
}
public override EnrollmentResult Enroll(ICertificateDataReader certificateDataReader, string csr, string subject, Dictionary <string, string[]> san, EnrollmentProductInfo productInfo, CSS.PKI.PKIConstants.X509.RequestFormat requestFormat, RequestUtilities.EnrollmentType enrollmentType)
{
Logger.MethodEntry(ILogExtensions.MethodLogLevel.Debug);
foreach (KeyValuePair <string, string> configEntry in productInfo.ProductParameters)
{
Logger.Trace($"{configEntry.Key}: {configEntry.Value}");
}
string[][] parameterKeys = new string[][] { };
if (enrollmentType == RequestUtilities.EnrollmentType.New)
{
parameterKeys = new string[][] { new string[] { "Email", "string" },
new string[] { "FirstName", "string" },
new string[] { "LastName", "string" },
new string[] { "Phone", "string" },
new string[] { "CertificatePeriodInYears", "int" } }
}
;
else
{
parameterKeys = new string[][] { new string[] { "PriorCertSN", "string" } }
};
ValidateParameters <string>(productInfo.ProductParameters, parameterKeys);
POSTCertificateEnrollmentResponse enrollmentResponse = new POSTCertificateEnrollmentResponse();
try
{
switch (enrollmentType)
{
case RequestUtilities.EnrollmentType.New:
switch (productInfo.ProductID)
{
case "DV_SSL":
case "DV_WILDCARD_SSL":
case "UCC_DV_SSL":
enrollmentResponse = EnrollDV(productInfo, csr, san);
break;
case "OV_SSL":
case "OV_CS":
case "OV_DS":
case "OV_WILDCARD_SSL":
case "UCC_OV_SSL":
enrollmentResponse = EnrollOV(productInfo, csr, san);
break;
case "EV_SSL":
case "UCC_EV_SSL":
enrollmentResponse = EnrollEV(productInfo, csr, san);
break;
default:
return(new EnrollmentResult {
Status = 30, StatusMessage = $"Error attempting to enroll certificate {subject}: Invalid Product ID - {productInfo.ProductID}."
});
}
break;
case RequestUtilities.EnrollmentType.Renew:
case RequestUtilities.EnrollmentType.Reissue:
CAConnectorCertificate certificate = certificateDataReader.GetCertificateRecord(DataConversion.HexToBytes(productInfo.ProductParameters["PriorCertSN"]));
enrollmentResponse = RenewReissue(certificate.CARequestID, productInfo, csr, san, enrollmentType == RequestUtilities.EnrollmentType.Renew);
break;
default:
return(new EnrollmentResult {
Status = 30, StatusMessage = $"Unsupported EnrollmentType: {enrollmentType}"
});
}
}
catch (Exception ex)
{
return(new EnrollmentResult {
Status = 30, StatusMessage = $"Error attempting to enroll certificate {subject}: {ex.Message}."
});
}
EnrollmentResult result = new EnrollmentResult();
CertificateStatusEnum certStatus = CertificateStatusEnum.PENDING_ISSUANCE;
for (int i = 0; i < _enrollmentRetries; i++)
{
try
{
GETCertificateDetailsResponse certResponse = JsonConvert.DeserializeObject <GETCertificateDetailsResponse>(_api.GetCertificate(enrollmentResponse.certificateId));
Enum.TryParse(certResponse.status, out certStatus);
if (certStatus == CertificateStatusEnum.ISSUED)
{
break;
}
}
catch (Exception) { }
Thread.Sleep(_secondsBetweenEnrollmentRetries * 1000);
}
string pemCertificate = certStatus == CertificateStatusEnum.ISSUED ? RemovePEMHeader(JsonConvert.DeserializeObject <GETCertificateResponse>(_api.DownloadCertificate(enrollmentResponse.certificateId)).pems.certificate) : string.Empty;
Logger.MethodExit(ILogExtensions.MethodLogLevel.Debug);
return(new EnrollmentResult {
CARequestID = enrollmentResponse.certificateId,
Certificate = pemCertificate,
Status = APIProcessor.MapReturnStatus(certStatus),
StatusMessage = $"GoDaddy Status = {certStatus.ToString()}"
});
}
