public void GenerateHeaderStrategyThirdParty()
{
signCredential = new SignatureCredential("testusername", "testpassword", "testsignature");
signSOAPHeaderAuthStrategy = new SignatureSOAPHeaderAuthStrategy();
subAuthorization = new SubjectAuthorization("testsubject");
signSOAPHeaderAuthStrategy.ThirdPartyAuthorization = subAuthorization;
signCredential.ThirdPartyAuthorization = subAuthorization;
string payload = signSOAPHeaderAuthStrategy.GenerateHeaderStrategy(signCredential);
XmlDocument xmlDoc = GetXmlDocument(payload);
XmlNodeList NodeListUsername = xmlDoc.GetElementsByTagName("Username");
Assert.IsTrue(NodeListUsername.Count > 0);
Assert.AreEqual("testusername", NodeListUsername[0].InnerXml);
XmlNodeList xmlNodeListPassword = xmlDoc.GetElementsByTagName("Password");
Assert.IsTrue(xmlNodeListPassword.Count > 0);
Assert.AreEqual("testpassword", xmlNodeListPassword[0].InnerXml);
XmlNodeList xmlNodeListSignature = xmlDoc.GetElementsByTagName("Signature");
Assert.IsTrue(xmlNodeListSignature.Count > 0);
Assert.AreEqual("testsignature", xmlNodeListSignature[0].InnerXml);
XmlNodeList xmlNodeListSubject = xmlDoc.GetElementsByTagName("Subject");
Assert.IsTrue(xmlNodeListSubject.Count > 0);
Assert.AreEqual("testsubject", xmlNodeListSubject[0].InnerXml);
}
/// <summary>
/// Processing TokenAuthorization} using SignatureCredential
/// </summary>
/// <param name="signCredential"></param>
/// <param name="tokenAuthorize"></param>
/// <returns></returns>
protected internal override Dictionary <string, string> ProcessTokenAuthorization(
SignatureCredential signCredential, TokenAuthorization tokenAuthorize)
{
Dictionary <string, string> headers = new Dictionary <string, string>();
try
{
OAuthGenerator generatorOAuth = new OAuthGenerator(signCredential.UserName, signCredential.Password);
//generatorOAuth.SetHttpPMethod(HttpMethod.POST);
generatorOAuth.SetToken(tokenAuthorize.AccessToken);
generatorOAuth.SetTokenSecret(tokenAuthorize.AccessTokenSecret);
string tokenTimeStamp = Timestamp;
generatorOAuth.SetTokenTimestamp(tokenTimeStamp);
logger.DebugFormat("token = " + tokenAuthorize.AccessToken + " tokenSecret=" + tokenAuthorize.AccessTokenSecret + " uri=" + endpointUrl);
generatorOAuth.SetRequestUri(endpointUrl);
//Compute Signature
string sign = generatorOAuth.ComputeSignature();
logger.DebugFormat("Permissions signature: " + sign);
string authorization = "token=" + tokenAuthorize.AccessToken + ",signature=" + sign + ",timestamp=" + tokenTimeStamp;
logger.DebugFormat("Authorization string: " + authorization);
headers.Add(BaseConstants.PayPalAuthorizationPlatformHeader, authorization);
}
catch (OAuthException oex)
{
throw oex;
}
return(headers);
}
/// <summary>
/// Processing TokenAuthorization} using SignatureCredential
/// </summary>
/// <param name="signCredential"></param>
/// <param name="toknAuthorization"></param>
/// <returns></returns>
protected internal override Dictionary <string, string> ProcessTokenAuthorization(
SignatureCredential signCredential, TokenAuthorization toknAuthorization)
{
Dictionary <string, string> headers = new Dictionary <string, string>();
try
{
OAuthGenerator sigGenerator = new OAuthGenerator(signCredential.UserName, signCredential.Password);
sigGenerator.setHTTPMethod(OAuthGenerator.HTTPMethod.POST);
sigGenerator.setToken(toknAuthorization.AccessToken);
sigGenerator.setTokenSecret(toknAuthorization.TokenSecret);
string tokenTimeStamp = Timestamp;
sigGenerator.setTokenTimestamp(tokenTimeStamp);
logger.Debug("token = " + toknAuthorization.AccessToken + " tokenSecret=" + toknAuthorization.TokenSecret + " uri=" + endpointURL);
sigGenerator.setRequestURI(endpointURL);
//Compute Signature
string sign = sigGenerator.ComputeSignature();
logger.Debug("Permissions signature: " + sign);
string authorization = "token=" + toknAuthorization.AccessToken + ",signature=" + sign + ",timestamp=" + tokenTimeStamp;
logger.Debug("Authorization string: " + authorization);
headers.Add(BaseConstants.PAYPAL_AUTHORIZATION_PLATFORM_HEADER, authorization);
}
catch (OAuthException ae)
{
throw ae;
}
return(headers);
}
/// <summary>
/// Returns the credentials
/// </summary>
/// <returns></returns>
private ICredential GetCredentials()
{
ICredential returnCredential = null;
try
{
CredentialManager credentialMngr = CredentialManager.Instance;
returnCredential = credentialMngr.GetCredentials(this.config, apiUsername);
if (!string.IsNullOrEmpty(accessToken))
{
IThirdPartyAuthorization toknAuthuthorization = new TokenAuthorization(accessToken, tokenSecret);
if (returnCredential is SignatureCredential)
{
SignatureCredential sigCred = (SignatureCredential)returnCredential;
sigCred.ThirdPartyAuthorization = toknAuthuthorization;
}
else if (returnCredential is CertificateCredential)
{
CertificateCredential certCred = (CertificateCredential)returnCredential;
certCred.ThirdPartyAuthorization = toknAuthuthorization;
}
}
}
catch (System.Exception ex)
{
throw ex;
}
return(returnCredential);
}
/// <summary>
/// Returns the API Credentials
/// </summary>
/// <param name="apiUserName"></param>
/// <returns></returns>
public ICredential GetCredentials(Dictionary <string, string> config, string apiUserName)
{
ICredential credential = null;
Account accnt = GetAccount(config, apiUserName);
if (accnt == null)
{
throw new MissingCredentialException("Missing credentials for " + apiUserName);
}
if (!string.IsNullOrEmpty(accnt.APICertificate))
{
CertificateCredential certCredential = new CertificateCredential(accnt.APIUsername, accnt.APIPassword, accnt.APICertificate, accnt.PrivateKeyPassword);
certCredential.ApplicationID = accnt.ApplicationId;
if (!string.IsNullOrEmpty(accnt.CertificateSubject))
{
SubjectAuthorization subAuthorization = new SubjectAuthorization(accnt.CertificateSubject);
certCredential.ThirdPartyAuthorization = subAuthorization;
}
credential = certCredential;
}
else
{
SignatureCredential signCredential = new SignatureCredential(accnt.APIUsername, accnt.APIPassword, accnt.APISignature);
signCredential.ApplicationID = accnt.ApplicationId;
if (!string.IsNullOrEmpty(accnt.SignatureSubject))
{
SubjectAuthorization subjectAuthorization = new SubjectAuthorization(accnt.SignatureSubject);
signCredential.ThirdPartyAuthorization = subjectAuthorization;
}
credential = signCredential;
}
ValidateCredentials(credential);
return(credential);
}
public void GetPayloadEndpointWithoutTokenTest()
{
platformAPIHandler = new PlatformAPICallPreHandler(ConfigManager.Instance.GetProperties(), "payload", "servicename", "method", Constants.APIUserName, "accessToken", "tokenSecret");
Assert.AreEqual("https://svcs.sandbox.paypal.com/servicename/method", platformAPIHandler.GetEndpoint());
Assert.AreEqual("payload", platformAPIHandler.GetPayload());
SignatureCredential signatureCredential = (SignatureCredential)platformAPIHandler.GetCredential();
TokenAuthorization thirdAuth = (TokenAuthorization)signatureCredential.ThirdPartyAuthorization;
Assert.AreEqual("accessToken", thirdAuth.AccessToken);
Assert.AreEqual("tokenSecret", thirdAuth.AccessTokenSecret);
}
public void GenerateHeaderStrategyWithoutToken()
{
SignatureHttpHeaderAuthStrategy signatureHttpHeaderAuthStrategy = new SignatureHttpHeaderAuthStrategy(Constants.APIEndpointNVP);
signCredential = new SignatureCredential("testusername", "testpassword", "testsignature");
Dictionary<string, string> header = signatureHttpHeaderAuthStrategy.GenerateHeaderStrategy(signCredential);
string username = header[BaseConstants.PayPalSecurityUserIdHeader];
string password = header[BaseConstants.PayPalSecurityPasswordHeader];
string sign = header[BaseConstants.PayPalSecuritySignatureHeader];
Assert.AreEqual("testusername", username);
Assert.AreEqual("testpassword", password);
Assert.AreEqual("testsignature", sign);
}
public void GenerateHeaderStrategyWithToken()
{
signHttpHeaderAuthStrategy = new SignatureHttpHeaderAuthStrategy(UnitTestConstants.APIEndpointSOAP);
TokenAuthorization toknAuthorization = new TokenAuthorization(UnitTestConstants.AccessToken, UnitTestConstants.TokenSecret);
signCredential = new SignatureCredential("testusername", "testpassword", "testsignature", toknAuthorization);
Dictionary <string, string> header = signHttpHeaderAuthStrategy.GenerateHeaderStrategy(signCredential);
string authHeader = header[BaseConstants.PAYPAL_AUTHORIZATION_MERCHANT_HEADER];
string[] headers = authHeader.Split(',');
Assert.AreEqual("token=" + UnitTestConstants.AccessToken, headers[0]);
}
public void GenerateHeaderStrategyToken()
{
signCredential = new SignatureCredential("testusername", "testpassword", "testsignature");
signSOAPHeaderAuthStrategy = new SignatureSOAPHeaderAuthStrategy();
TokenAuthorization toknAuthorization = new TokenAuthorization("accessToken", "tokenSecret");
signSOAPHeaderAuthStrategy.ThirdPartyAuthorization = toknAuthorization;
signCredential.ThirdPartyAuthorization = toknAuthorization;
string payload = signSOAPHeaderAuthStrategy.GenerateHeaderStrategy(signCredential);
Assert.AreEqual("<ns:RequesterCredentials/>", payload);
}
public void GenerateHeaderStrategyWithToken()
{
signHttpHeaderAuthStrategy = new SignatureHttpHeaderAuthStrategy(Constants.APIEndpointSOAP);
TokenAuthorization toknAuthorization = new TokenAuthorization(Constants.AccessToken, Constants.TokenSecret);
signCredential = new SignatureCredential("testusername", "testpassword", "testsignature", toknAuthorization);
Dictionary <string, string> header = signHttpHeaderAuthStrategy.GenerateHeaderStrategy(signCredential);
string authHeader = header[BaseConstants.PayPalAuthorizationMerchantHeader];
string[] headers = authHeader.Split(',');
Assert.AreEqual("token=" + Constants.AccessToken, headers[0]);
}
/// <summary>
/// Validates the API Credentials
/// </summary>
/// <param name="apiCredentials"></param>
private void ValidateCredentials(ICredential apiCredentials)
{
if (apiCredentials is SignatureCredential)
{
SignatureCredential credential = (SignatureCredential)apiCredentials;
Validate(credential);
}
else if (apiCredentials is CertificateCredential)
{
CertificateCredential credential = (CertificateCredential)apiCredentials;
Validate(credential);
}
}
public void GenerateHeaderStrategyWithoutToken()
{
signHttpHeaderAuthStrategy = new SignatureHttpHeaderAuthStrategy(UnitTestConstants.APIEndpointSOAP);
signCredential = new SignatureCredential("testusername", "testpassword", "testsignature");
Dictionary <string, string> header = signHttpHeaderAuthStrategy.GenerateHeaderStrategy(signCredential);
string username = header[BaseConstants.PAYPAL_SECURITY_USERID_HEADER];
string password = header[BaseConstants.PAYPAL_SECURITY_PASSWORD_HEADER];
string sign = header[BaseConstants.PAYPAL_SECURITY_SIGNATURE_HEADER];
Assert.AreEqual("testusername", username);
Assert.AreEqual("testpassword", password);
Assert.AreEqual("testsignature", sign);
}
public void GenerateHeaderStrategyWithoutToken()
{
signHttpHeaderAuthStrategy = new SignatureHttpHeaderAuthStrategy(Constants.APIEndpointSOAP);
signCredential = new SignatureCredential("testusername", "testpassword", "testsignature");
Dictionary <string, string> header = signHttpHeaderAuthStrategy.GenerateHeaderStrategy(signCredential);
string username = header[BaseConstants.PayPalSecurityUserIdHeader];
string password = header[BaseConstants.PayPalSecurityPasswordHeader];
string sign = header[BaseConstants.PayPalSecuritySignatureHeader];
Assert.AreEqual("testusername", username);
Assert.AreEqual("testpassword", password);
Assert.AreEqual("testsignature", sign);
}
public ICredential GetCredentials(string apiUserName)
{
if (apiUserName == null)
{
apiUserName = GetDefaultAccountName();
}
if (this.cachedCredentials.ContainsKey(apiUserName))
{
log.Debug("Returning cached credentials for " + apiUserName);
return(this.cachedCredentials[apiUserName]);
}
else
{
ICredential pro = null;
ConfigManager configMgr = ConfigManager.Instance;
Account acc = configMgr.GetAccount(apiUserName);
if (acc == null)
{
throw new MissingCredentialException("Missing credentials for " + apiUserName);
}
if (!string.IsNullOrEmpty(acc.APICertificate))
{
CertificateCredential cred = new CertificateCredential();
cred.APIUsername = acc.APIUsername;
cred.APIPassword = acc.APIPassword;
cred.CertificateFile = acc.APICertificate;
cred.PrivateKeyPassword = acc.PrivateKeyPassword;
cred.ApplicationID = acc.ApplicationId;
cred.CertificateSubject = acc.CertificateSubject;
pro = cred;
}
else
{
SignatureCredential cred = new SignatureCredential();
cred.APIUsername = acc.APIUsername;
cred.APIPassword = acc.APIPassword;
cred.APISignature = acc.APISignature;
cred.ApplicationID = acc.ApplicationId;
cred.SignatureSubject = acc.SignatureSubject;
pro = cred;
}
this.cachedCredentials.Add(apiUserName, pro);
return(pro);
}
}
public void ObjectCreation()
{
SignatureCredential cred = new SignatureCredential();
cred.APIUsername = "******";
cred.APIPassword = "******";
cred.ApplicationID = "APP-1234ASDFG";
cred.APISignature = "Adsjsalkdsadsad.sdsadipoewirpoewr";
Assert.AreEqual("username_api1.paypal.com", cred.APIUsername);
Assert.AreEqual("QWERRTYUIOP", cred.APIPassword);
Assert.AreEqual("Adsjsalkdsadsad.sdsadipoewirpoewr", cred.APISignature);
Assert.AreEqual("APP-1234ASDFG", cred.ApplicationID);
}
public void LoadSignatureCredential()
{
string apiUsername = Constants.APIUserName;
credentialMngr = CredentialManager.Instance;
credential = credentialMngr.GetCredentials(ConfigManager.Instance.GetProperties(), apiUsername);
Assert.IsNotNull(credential);
Assert.IsInstanceOfType(credential, typeof(SignatureCredential));
SignatureCredential signCredential = (SignatureCredential)credential;
Assert.AreEqual(apiUsername, signCredential.UserName);
Assert.AreEqual(Constants.APIPassword, signCredential.Password);
Assert.AreEqual(Constants.APISignature, signCredential.Signature);
Assert.AreEqual(Constants.ApplicationId, signCredential.ApplicationId);
}
/// <summary>
/// Validates the Signature Credentials
/// </summary>
/// <param name="apiCredentials"></param>
private void Validate(SignatureCredential apiCredentials)
{
if (string.IsNullOrEmpty(apiCredentials.UserName))
{
throw new InvalidCredentialException(BaseConstants.ErrorMessages.ErrorUserName);
}
if (string.IsNullOrEmpty(apiCredentials.Password))
{
throw new InvalidCredentialException(BaseConstants.ErrorMessages.ErrorPassword);
}
if (string.IsNullOrEmpty(((SignatureCredential)apiCredentials).Signature))
{
throw new InvalidCredentialException(BaseConstants.ErrorMessages.ErrorSignature);
}
}
public void loadSignatureCredential()
{
string apiUsername = "******";
CredentialManager mgr = CredentialManager.Instance;
ICredential cred = mgr.GetCredentials(apiUsername);
Assert.NotNull(cred);
Assert.IsInstanceOf(typeof(SignatureCredential), cred);
SignatureCredential sig = (SignatureCredential)cred;
Assert.AreEqual(apiUsername, sig.APIUsername);
Assert.AreEqual("WX4WTU3S8MY44S7F", sig.APIPassword);
Assert.AreEqual("AFcWxV21C7fd0v3bYYYRCpSSRl31A7yDhhsPUU2XhtMoZXsWHFxu-RWy", sig.APISignature);
Assert.AreEqual("APP-80W284485P519543T", sig.ApplicationID);
}
/// <summary>
/// Returns CertificateCredential as HTTP headers
/// </summary>
/// <param name="credential"></param>
/// <returns></returns>
public Dictionary <string, string> GenerateHeaderStrategy(SignatureCredential signCredential)
{
Dictionary <string, string> headers = null;
try
{
if (signCredential.ThirdPartyAuthorization is TokenAuthorization)
{
headers = ProcessTokenAuthorization(signCredential, (TokenAuthorization)signCredential.ThirdPartyAuthorization);
}
else
{
headers = new Dictionary <string, string>();
headers.Add(BaseConstants.PAYPAL_SECURITY_USERID_HEADER, signCredential.UserName);
headers.Add(BaseConstants.PAYPAL_SECURITY_PASSWORD_HEADER, signCredential.Password);
headers.Add(BaseConstants.PAYPAL_SECURITY_SIGNATURE_HEADER, signCredential.Signature);
}
}
catch (OAuthException ae)
{
throw ae;
}
return(headers);
}
/// <summary>
/// Appends SOAP Headers to payload
/// if the credentials mandate soap headers
/// </summary>
/// <returns></returns>
public string GetPayload()
{
if (payload == null)
{
payload = apiCallHandler.GetPayload();
string header = null;
if (credential is SignatureCredential)
{
SignatureCredential signCredential = (SignatureCredential)credential;
SignatureSOAPHeaderAuthStrategy signSoapHeaderAuthStrategy = new SignatureSOAPHeaderAuthStrategy();
signSoapHeaderAuthStrategy.ThirdPartyAuthorization = signCredential.ThirdPartyAuthorization;
header = signSoapHeaderAuthStrategy.GenerateHeaderStrategy(signCredential);
}
else if (credential is CertificateCredential)
{
CertificateCredential certCredential = (CertificateCredential)credential;
CertificateSOAPHeaderAuthStrategy certSoapHeaderAuthStrategy = new CertificateSOAPHeaderAuthStrategy();
certSoapHeaderAuthStrategy.ThirdPartyAuthorization = certCredential.ThirdPartyAuthorization;
header = certSoapHeaderAuthStrategy.GenerateHeaderStrategy(certCredential);
}
payload = GetPayloadUsingSOAPHeader(payload, GetAttributeNamespace(), header);
}
return(payload);
}
/// <summary>
/// Returns CertificateCredential as HTTP headers
/// </summary>
/// <param name="credential"></param>
/// <returns></returns>
public Dictionary <string, string> GenerateHeaderStrategy(SignatureCredential signCredential)
{
Dictionary <string, string> headers = null;
try
{
if (signCredential.ThirdPartyAuthorization is TokenAuthorization)
{
headers = ProcessTokenAuthorization(signCredential, (TokenAuthorization)signCredential.ThirdPartyAuthorization);
}
else
{
headers = new Dictionary <string, string>();
headers.Add(BaseConstants.PayPalSecurityUserIdHeader, signCredential.UserName);
headers.Add(BaseConstants.PayPalSecurityPasswordHeader, signCredential.Password);
headers.Add(BaseConstants.PayPalSecuritySignatureHeader, signCredential.Signature);
}
}
catch (OAuthException oex)
{
throw oex;
}
return(headers);
}
public SignatureCredentialTest()
{
signCredential = new SignatureCredential("platfo_1255077030_biz_api1.gmail.com", "1255077037", "Abg0gYcQyxQvnf2HDJkKtA-p6pqhA1k-KTYE0Gcy1diujFio4io5Vqjf");
}
public void GenerateHeaderStrategyThirdParty()
{
signCredential = new SignatureCredential("testusername", "testpassword", "testsignature");
signSOAPHeaderAuthStrategy = new SignatureSOAPHeaderAuthStrategy();
subAuthorization = new SubjectAuthorization("testsubject");
signSOAPHeaderAuthStrategy.ThirdPartyAuthorization = subAuthorization;
signCredential.ThirdPartyAuthorization = subAuthorization;
string payload = signSOAPHeaderAuthStrategy.GenerateHeaderStrategy(signCredential);
XmlDocument xmlDoc = GetXmlDocument(payload);
XmlNodeList NodeListUsername = xmlDoc.GetElementsByTagName("Username");
Assert.IsTrue(NodeListUsername.Count > 0);
Assert.AreEqual("testusername", NodeListUsername[0].InnerXml);
XmlNodeList xmlNodeListPassword = xmlDoc.GetElementsByTagName("Password");
Assert.IsTrue(xmlNodeListPassword.Count > 0);
Assert.AreEqual("testpassword", xmlNodeListPassword[0].InnerXml);
XmlNodeList xmlNodeListSignature = xmlDoc.GetElementsByTagName("Signature");
Assert.IsTrue(xmlNodeListSignature.Count > 0);
Assert.AreEqual("testsignature", xmlNodeListSignature[0].InnerXml);
XmlNodeList xmlNodeListSubject = xmlDoc.GetElementsByTagName("Subject");
Assert.IsTrue(xmlNodeListSubject.Count > 0);
Assert.AreEqual("testsubject", xmlNodeListSubject[0].InnerXml);
}
public void GenerateHeaderStrategyToken()
{
signCredential = new SignatureCredential("testusername", "testpassword", "testsignature");
signSOAPHeaderAuthStrategy = new SignatureSOAPHeaderAuthStrategy();
TokenAuthorization toknAuthorization = new TokenAuthorization("accessToken", "tokenSecret");
signSOAPHeaderAuthStrategy.ThirdPartyAuthorization = toknAuthorization;
signCredential.ThirdPartyAuthorization = toknAuthorization;
string payload = signSOAPHeaderAuthStrategy.GenerateHeaderStrategy(signCredential);
Assert.AreEqual("<ns:RequesterCredentials/>", payload);
}
public void SignatureCredentialArgumentException()
{
signCredential = new SignatureCredential(null, null, null);
}
public SignatureCredentialTest()
{
signCredential = new SignatureCredential("platfo_1255077030_biz_api1.gmail.com", "1255077037", "Abg0gYcQyxQvnf2HDJkKtA-p6pqhA1k-KTYE0Gcy1diujFio4io5Vqjf");
}
public void GenerateHeaderStrategyWithToken()
{
signHttpHeaderAuthStrategy = new SignatureHttpHeaderAuthStrategy(Constants.APIEndpointNVP);
TokenAuthorization toknAuthorization = new TokenAuthorization(Constants.AccessToken, Constants.TokenSecret);
signCredential = new SignatureCredential("testusername", "testpassword", "testsignature", toknAuthorization);
Dictionary<string, string> header = signHttpHeaderAuthStrategy.GenerateHeaderStrategy(signCredential);
string authHeader = header[BaseConstants.PayPalAuthorizationPlatformHeader];
string[] headers = authHeader.Split(',');
Assert.AreEqual("token=" + Constants.AccessToken, headers[0]);
}
/// <summary> /// Process Token Authorization based on API format /// </summary> /// <param name="signCredential"></param> /// <param name="tokenAuthorize"></param> /// <returns></returns> protected internal abstract Dictionary <string, string> ProcessTokenAuthorization(SignatureCredential signCredential, TokenAuthorization tokenAuthorize);
public void SignatureCredentialArgumentException()
{
signCredential = new SignatureCredential(null, null, null);
}
