public RectokenResponse Post(RectokenRequest req)
{
RectokenResponse response;
req.merchant_id = FondyConfig.MerchantId;
req.version = FondyConfig.Protocol;
req.signature = Signature.GetRequestSignature(RequiredParams.GetHashProperties(req));
try
{
response = Client.Invoke <RectokenRequest, RectokenResponse>(req, req.ActionUrl);
}
catch (ClientException c)
{
response = new RectokenResponse {
Error = c
};
}
if (response.data != null && FondyConfig.Protocol == "2.0")
{
return(JsonFormatter.ConvertFromJson <RectokenResponse>(response.data, true, "order"));
}
return(response);
}
public SubscriptionResponse Post(SubscriptionRequest request)
{
SubscriptionResponse response;
string defaultProtocol = FondyConfig.Protocol;
string defaultContentType = FondyConfig.ContentType;
FondyConfig.ContentType = "json";
FondyConfig.Protocol = "2.0";
request.merchant_id = FondyConfig.MerchantId;
request.version = FondyConfig.Protocol;
request.subscription = "Y";
request.signature = Signature.GetRequestSignature(RequiredParams.GetHashProperties(request));
try
{
response = Client.Invoke <SubscriptionRequest, SubscriptionResponse>(request, request.ActionUrl);
}
catch (ClientException c)
{
response = new SubscriptionResponse {
Error = c
};
}
if (response.data != null && FondyConfig.Protocol == "2.0")
{
FondyConfig.Protocol = defaultProtocol;
FondyConfig.ContentType = defaultContentType;
return(JsonFormatter.ConvertFromJson <SubscriptionResponse>(response.data, true, "order"));
}
return(response);
}
/// <summary>
/// Parsing Response/Callback
/// </summary>
/// <param name="response"></param>
/// <param name="type"></param>
/// <param name="isCredit"></param>
/// <returns></returns>
public ResponseModel GetResponse(string response, string type = null, bool isCredit = false)
{
ResponseModel data = RequiredParams.ConvertResponseByContentType <ResponseModel>(response, false, type);
bool v2 = ISv2Resp(data);
try
{
if (v2)
{
IsSignatureValidV2(data, isCredit);
}
else
{
IsSignatureValid(data, response, type, isCredit);
}
}
catch (SignatureException e)
{
return(new ResponseModel {
SignatureError = e
});
}
if (v2)
{
ResponseModel dataV2 = JsonFormatter.ConvertFromJson <ResponseModel>(data.data, true, "order");
return(dataV2);
}
return(data);
}
/// <summary>
/// Submit if card 3ds
/// </summary>
/// <param name="req"></param>
/// <returns></returns>
public PcidssResponse StepTwo(StepTwoRequest req)
{
PcidssResponse response;
req.merchant_id = Config.MerchantId;
req.version = Config.Protocol;
req.signature = Signature.GetRequestSignature(RequiredParams.GetHashProperties(req));
try
{
response = Client.Invoke <StepTwoRequest, PcidssResponse>(req, req.ActionUrl);
}
catch (ClientException c)
{
response = new PcidssResponse {
Error = c
};
}
if (response.data != null && Config.Protocol == "2.0")
{
return(JsonFormatter.ConvertFromJson <PcidssResponse>(response.data, true, "order"));
}
return(response);
}
public VerificationResponse Post(VerificationRequest req)
{
VerificationResponse response;
req.merchant_id = Config.MerchantId;
req.verification = "Y";
req.version = Config.Protocol;
if (req.verification_type == null)
{
req.verification_type = "amount";
}
req.signature = Signature.GetRequestSignature(RequiredParams.GetHashProperties(req));
try
{
response = Client.Invoke <VerificationRequest, VerificationResponse>(req, req.ActionUrl);
}
catch (ClientException c)
{
response = new VerificationResponse {
Error = c
};
}
if (response.data != null && Config.Protocol == "2.0")
{
return(JsonFormatter.ConvertFromJson <VerificationResponse>(response.data, true, "order"));
}
return(response);
}
internal string Usage(string commandName, bool inCLI, bool onlyCommandline = false)
{
List <Parameter> RequiredParams;
List <Parameter> OptionalParams;
StringBuilder Expression = new StringBuilder(UsageExpression.Prefix);
if (!inCLI)
{
Expression.Append($"{Constants.AssemblyFile} ");
}
Expression.Append(commandName);
if (!IsDefault)
{
Expression.Append($" {Name}");
}
//Required Parameters
RequiredParams = Parameters.Where(p => p.DefinitionRequired).ToList();
if (RequiredParams.Count() > 0)
{
RequiredParams.ForEach(p => Expression.Append(p.CliSyntax()));
}
//Optional Parameters
OptionalParams = Parameters.Where(p => !p.DefinitionRequired).ToList();
if (OptionalParams.Count() > 0)
{
Expression.Append(" ");
StringBuilder tmp = new StringBuilder(string.Empty);
OptionalParams.ForEach(p => tmp.Append(p.CliSyntax()));
tmp.Append(" ");
Expression.Append(tmp.ToString().InBraces());
}
if (onlyCommandline)
{
return(Expression.ToString());
}
if (Parameters.Count > 0)
{
int padding = Parameters.Select(p => p.Name).GetPadding();
Expression.Append($"\r\n{UsageExpression.RequiredParameters}");
RequiredParams.ForEach(p => Expression.Append(p.DetailedUsage(padding)));
if (OptionalParams.Count > 0)
{
Expression.Append(UsageExpression.OptionalParameters);
OptionalParams.ForEach(p => Expression.Append(p.DetailedUsage(padding)));
}
}
return(Expression.ToString());
}
/// <summary>
/// Dynamically adds required parameters to the current <see cref="Command"/>.
/// </summary>
/// <param name="parametersName">The parameters</param>
public Command Require(params string[] parametersName)
{
if (parametersName == null)
{
throw new ArgumentNullException("parameterName");
}
RequiredParams.AddRange(parametersName);
return(this);
}
public AtolResponse Post(AtolRequest req)
{
AtolResponse response;
req.merchant_id = Config.MerchantId;
req.version = Config.Protocol;
req.signature = Signature.GetRequestSignature(RequiredParams.GetHashProperties(req));
try
{
response = Client.Invoke <AtolRequest, AtolResponse>(req, req.ActionUrl);
}
catch (ClientException c)
{
response = new AtolResponse {
Error = c
};
}
return(response);
}
public TransactionListResponse Post(TransactionListRequest req)
{
TransactionListResponse response;
req.merchant_id = FondyConfig.MerchantId;
req.signature = Signature.GetRequestSignature(RequiredParams.GetHashProperties(req));
// In this api only json allowed
FondyConfig.ContentType = "json";
try
{
response = Client.Invoke <TransactionListRequest, TransactionListResponse>(req, req.ActionUrl, false);
}
catch (ClientException c)
{
response = new TransactionListResponse {
Error = c
};
}
return(response);
}
/// <summary>
/// Basic Client
/// </summary>
/// <param name="req"></param>
/// <param name="actionUrl"></param>
/// <param name="isRoot"></param>
/// <param name="isCredit"></param>
/// <typeparam name="TCipspRequest"></typeparam>
/// <typeparam name="TCipspResponse"></typeparam>
/// <returns></returns>
/// <exception cref="ClientException"></exception>
public static TCipspResponse Invoke <TCipspRequest, TCipspResponse>(
TCipspRequest req,
string actionUrl,
bool isRoot = true,
bool isCredit = false
)
{
string data;
if (Config.Protocol == "2.0")
{
// In protocol v2 Only json allowed
if (Config.ContentType != "json")
{
throw new ClientException
{
ErrorMessage = "In protocol v2 only json content allowed",
ErrorCode = "0"
};
}
data = RequiredParams.GetParamsV2(req, isCredit);
}
else
{
data = RequiredParams.ConvertRequestByContentType(req);
}
string uriString = Config.Endpoint(null) + actionUrl;
HttpWebRequest conn = WebRequest.CreateHttp(new Uri(uriString)) as HttpWebRequest;
conn.ContentType = GetContentTypeHeader(Config.ContentType);
conn.UserAgent = _agent;
conn.Method = _method;
byte[] requestData = Encoding.UTF8.GetBytes(data);
var resultRequest = conn.BeginGetRequestStream(null, null);
using (Stream postStream = conn.EndGetRequestStream(resultRequest))
{
postStream.Write(requestData, 0, requestData.Length);
postStream.Dispose();
}
execute(conn);
if (_statusCode != 200)
{
throw new ClientException
{
ErrorCode = "500",
ErrorMessage = _response,
RequestId = "Server is gone",
};
}
ErrorResponseModel errorResponse =
RequiredParams.ConvertResponseByContentType <ErrorResponseModel>(_response, isRoot);
if (errorResponse.response_status == "failure" || errorResponse.error_message != null)
{
throw new ClientException
{
ErrorCode = errorResponse.error_code,
ErrorMessage = errorResponse.error_message,
RequestId = errorResponse.request_id,
};
}
TCipspResponse normalResponse =
RequiredParams.ConvertResponseByContentType <TCipspResponse>(_response, isRoot);
return(normalResponse);
}
