public ThreeDSAuthorization0Response ThreeDSAuthorize0(ThreeDSAuthorization0Request request)
{
// Validate request
RequestValidator.ValidateThreeDSAuthorize0Request(request);
// Map input request in the XML Request
var requestXML = RequestMapper.MapThreeDSAuthorization0Request(request, _shopId, _apiResultKey);
// Calculate and set MAC
requestXML.Request.MAC = _encoder.GetMac(RequestHandler.GetMacDictionary(requestXML), _apiResultKey);
// Url Encode ThreeDSData to correctly send it
requestXML.Data.RequestTag.ThreeDSData = HttpUtility.UrlEncode(requestXML.Data.RequestTag.ThreeDSData);
var xmlBody = XmlTool.Serialize(requestXML);
// Do call
var xmlResponse = _restClient.CallApi(_urlAPI, xmlBody);
// Map response
var objectResponse = XmlTool.Deserialize <BPWXmlResponse <Data3DSResponse> >(xmlResponse);
// Verify Response MAC
VerifyMacResponse(objectResponse);
VerifyAuthorization(objectResponse.Data.Authorization);
VerifyPanAliasData(objectResponse.Data.PanAliasData);
VerifyThreeDSChallenge(objectResponse.Data.ThreeDSChallenge);
VerifyThreeDSMethod(objectResponse.Data.ThreeDSMethod);
return(ResponseMapper.MapThreeDSAuthorization0(objectResponse));
}
public AssetResponseModel Get(string id)
{
//FIXME
//TODO get logged in character ID from header
string mrCharFirstId = "6bcdb901-dab3-4091-a5c9-000000000030";
String loggedInCharacterIdFromHeader = mrCharFirstId;
if (String.IsNullOrEmpty(id.Trim()))
{
return(null);
}
var asset = _backingService.GetAssetById(loggedInCharacterIdFromHeader, id);
if (asset == null)
{
return(null);
}
// Get a resource
return(new AssetResponseModel()
{
Assets = new ResponseAsset[] { ResponseMapper.ToResponseAsset(asset) }
});
}
public async Task <PaymentResponse> PaymentRequest(string merchantId, [FromBody] PaymentRequest payload)
{
var request = RequestMapper.MapPaymentRequest(merchantId, payload, clock);
var result = await gateway.HandlePaymentRequest(request);
return(ResponseMapper.MapResponse(result));
}
public async Task <PaymentResponse> PaymentDetails(string merchantId, string merchantReferenceNumber)
{
var request = RequestMapper.MapDetailsRequest(merchantId, merchantReferenceNumber, clock);
var result = await gateway.HandleDetailsRequest(request);
return(ResponseMapper.MapResponse(result));
}
public void CanMapGatewayResponseToResponse()
{
var source = new GatewayResponse
{
MerchantId = "merchantId",
MerchantReferenceNumber = "refNumber",
IsSuccess = true,
FailureReason = "operation successfull",
GatewayId = "gatewayId",
PaymentAmount = 123.45d,
PaymentCurrency = "USD",
TruncatedCardNumber = "***0404",
TimeStamp = DateTimeOffset.UtcNow
};
var result = ResponseMapper.MapResponse(source);
Check.That(result.IsSuccess).Equals(source.IsSuccess);
Check.That(result.FailureReason).Equals(source.FailureReason);
Check.That(result.MerchantId).Equals(source.MerchantId);
Check.That(result.MerchantReferenceNumber).Equals(source.MerchantReferenceNumber);
Check.That(result.PaymentAmount).Equals(source.PaymentAmount);
Check.That(result.PaymentCurrency).Equals(source.PaymentCurrency);
Check.That(result.TimeStamp).Equals(source.TimeStamp);
Check.That(result.TruncatedCardNumber).Equals(source.TruncatedCardNumber);
}
public IResponse <GameInstance> Play(PlayGameInstanceDto dto)
{
var gameInstance = Get(dto.Id);
var gameStrategy = GameStrategyProvider.Provide(gameInstance.GameId);
var newGameStateAsJsonStringResponse = gameStrategy != null?gameStrategy.LoadAndPlayAndReturnGameStateAsString(gameInstance, RequestContext.UserId, dto.UserInput) : new Response <string>
{
Data = ""
};
var response = ResponseMapper.MapMetadata <GameInstance>(newGameStateAsJsonStringResponse);
if (!response.IsValid || response.Messages.Any(x => x.Contains("wins!")))
{
return(response);
}
var newGameState = CreateGameStateObject(newGameStateAsJsonStringResponse.Data);
response.Data = Save(gameInstance, newGameState);
if (gameStrategy != null)
{
SaveGameStateHistory(response.Data.Id, gameInstance.State, $"User Input: {dto.UserInput}");
}
return(response);
}
public async Task <IActionResult> CreateBet([FromBody] BetApiModel bet)
{
// var header = _context.HttpContext.Request?.Headers["id"];
var newbet = await _rouletteService.NewBet(bet);
return(Ok(ResponseMapper.MapBet(newbet)));
}
public CoverageProcessor(CoverageMiner coverageMiner, CoverageValidator coverageValidator, CoverageMapper coverageMapper, CoverageSender coverageSender, ResponseMapper responseMapper)
{
_coverageMiner = coverageMiner;
_coverageValidator = coverageValidator;
_coverageMapper = coverageMapper;
_coverageSender = coverageSender;
_responseMapper = responseMapper;
}
public PolicyProcessor(PolicyMiner policyMiner, PolicyValidator policyValidator, PolicyMapper policyMapper, ResponseMapper responseMapper, PolicySender policySender)
{
_policyMiner = policyMiner;
_policyMapper = policyMapper;
_policyValidator = policyValidator;
_policySender = policySender;
_responseMapper = responseMapper;
}
public void Setup()
{
_responseModel = new ResponseModel();
_response = new Response();
// Test object
_responseMapper = new ResponseMapper();
}
public OrdersResponseModel Get()
{
var orders = _backingService.GetLastOrders();
return(new OrdersResponseModel()
{
Orders = orders.Select(c => ResponseMapper.ToResponseOrder(c)).ToArray <OrderResponseModel>()
});
}
public DomainsResponseModel Get()
{
var domains = _backingService.AllDomains();
return(new DomainsResponseModel()
{
Domains = domains.Select(d => ResponseMapper.ToResponseDomain(d)).ToArray <ResponseDomain>()
});
}
public EndeavourDirectoryResponseModel Get()
{
var endeavours = _backingService.GetPublicEndeavours();
return(new EndeavourDirectoryResponseModel()
{
Directory = endeavours.Select(c => ResponseMapper.ToResponseEndeavourDirectoryEntry(c)).ToArray <ResponseEndeavourDirectoryEntry>()
});
}
public void Setup()
{
_responseModel = new ResponseModel
{
Message = "Successful",
Successful = true
};
_responseMapper = new ResponseMapper();
}
public ActorDirectoryResponseModel Get()
{
var actors = _backingService.AllPublicActors();
return(new ActorDirectoryResponseModel()
{
Directory = actors.Select(c => ResponseMapper.ToResponseActorDirectoryEntry(c))
.ToArray <ResponseActorDirectoryEntry>()
});
}
/// <summary>
/// Execute Result
/// </summary>
/// <typeparam name="T"></typeparam>
/// <returns></returns>
public IRestResponse <T> Execute <T>() where T : new()
{
IHttpResponse httpResponse = _httpFactory.Execute().Result;
IRestResponse <T> restResponse = ResponseMapper.ToAsyncResponse <T>(httpResponse);
if (!string.IsNullOrEmpty(httpResponse.Content))
{
restResponse.Data = Parser.Deserialize <T>(_restRequest.DataFormat, httpResponse.Content);
}
return(restResponse);
}
public void ParseXMLDataTest()
{
//Arrange
EPSConnector _connector = new EPSConnector();
ResponseMapper responseMapper = new ResponseMapper();
string xmlResponseString = "<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"yes\"?><CardServiceResponse xmlns=\"http://www.nrf-arts.org/IXRetail/namespace\" RequestType = \"CardPayment\" WorkstationID = \"Dave's Workstation\" RequestID = \"19\" OverallResult = \"Success\"><Terminal TerminalID = \"02052317\" TerminalBatch = \"006\"/><Tender><TotalAmount> 9.000000 </TotalAmount><Authorisation AcquirerID = \"000000\" StartDate = \"0401\" ExpiryDate = \"1412\" TimeStamp = \"2012-07-25T15:02:59.000+01:00\" ActionCode = \"000\" ApprovalCode = \"011860\" AcquirerBatch = \"006\" PANprint = \"541333******0036\" Merchant = \"2100112192\" AuthorisationType = \"Online\" CaptureReference = \"0092\"/></Tender></CardServiceResponse >";
//Act
var paymentInfo = responseMapper.MapPaymentResponse(xmlResponseString, "testconnector");
//Assert
Assert.IsNotNull(paymentInfo);
}
public AssetResponseModel Get()
{
//FIXME
//TODO get logged in character ID from header
string mrCharFirstId = "6bcdb901-dab3-4091-a5c9-000000000030";
String loggedInCharacterIdFromHeader = mrCharFirstId;
var assets = _backingService.MyAssets(loggedInCharacterIdFromHeader);
return(new AssetResponseModel()
{
Assets = assets.Select(a => ResponseMapper.ToResponseAsset(a)).ToArray <ResponseAsset>()
});
}
public void Initialize()
{
test01Data = File.ReadAllText(@"TestData/Test01.json", Encoding.UTF8);
test02Data = File.ReadAllText(@"TestData/Test02.json", Encoding.UTF8);
test03Data = File.ReadAllText(@"TestData/Test03.json", Encoding.UTF8);
test04Data = File.ReadAllText(@"TestData/Test04.json", Encoding.UTF8);
test05Data = File.ReadAllText(@"TestData/Test05.json", Encoding.UTF8);
categoryProvider = new CategoryProvider();
var requestMapper = new RequestMapper();
var responseMapper = new ResponseMapper(categoryProvider);
bMICalculator = new BMICalculator(categoryProvider, requestMapper, responseMapper);
}
public ActionResult <IResponse <object> > New(CreateGameInstanceDto dto)
{
var validationResponse = GameInstanceValidator.Validate(dto);
if (!validationResponse.IsValid)
{
return(BadRequest(validationResponse));
}
var gameInstanceResponse = GameInstanceLogic.New(dto);
var response = ResponseMapper.MapMetadata <GameInstanceDto>(gameInstanceResponse);
response.Data = GameInstanceMapper.Map(gameInstanceResponse.Data);
return(Ok(response));
}
public Response Process(SessionActivity sessionActivity)
{
var policyMiner = new PolicyMiner();
var policy = policyMiner.Mine(sessionActivity);
var policyMapper = new PolicyMapper();
var policyModel = policyMapper.Map(policy);
var policySender = new PolicySender();
var responseModel = policySender.Send(policyModel);
var responseMapper = new ResponseMapper();
var response = responseMapper.Map(responseModel);
return(response);
}
public void GetCompetingDrivers_ReturnAllDrivers_WhenRequestedFromRepository(string dir,
string path,
RequestFactory requestFactory,
ResponseMapper responseMapper)
{
var client = ErgastClientGenerator.ErgastClientWithResponseFromFile(dir, path);
var request = new DriverInfoRequest
{
Season = "2019",
Round = "5"
};
var driverRepository = new DriverRepository(new DriverClient(client, requestFactory, responseMapper));
var driverDtoCollection = Task.Run(async() => await driverRepository.GetCompetingDriversAsync(2019, 2)).Result;
Assert.NotNull(driverDtoCollection);
}
public async Task <Response <T> > ExecuteTaskAsync <T>(Request request)
{
IRestResponse <T> restResponse = null;
//generating rest request
var restRequest =
RequestMapper.MapRequestToRestRequest(request);
//execute request
restResponse = await ExecuteRequest <T>(restRequest, request.Method, request.BaseUrl);
//check for time out and log request/response/error
//_requestResponseLogger.Log(restRequest, restResponse);
//generate response from RestResponse
return(ResponseMapper.MapRestResponseToResponse(restResponse));
}
public void MapMetadata_WithNonNullData_ShouldMapErrorsAndMessages()
{
//arrange
Arrange();
//act
var result = ResponseMapper.MapMetadata <string>(_sourceResponse);
//assert
Assert.AreEqual(3, result.Errors.Count);
Assert.AreEqual("this is an error", result.Errors.ElementAt(0));
Assert.AreEqual("this is another error", result.Errors.ElementAt(1));
Assert.AreEqual("this is a third error", result.Errors.ElementAt(2));
Assert.AreEqual(2, result.Messages.Count);
Assert.AreEqual("this is a message", result.Messages.ElementAt(0));
Assert.AreEqual("this is another message", result.Messages.ElementAt(1));
}
public async Task <ResponseDto> GetByPhrase(string phrase, string type)
{
switch (type)
{
case "shodan":
var shodanResult = await _iResponseShodanRepository.GetByPhrase(phrase);
return(ResponseMapper.MapShodanResponseToDto(shodanResult, phrase));
case "censys":
var censysResult = await _iResponseCensysRepository.GetByPhrase(phrase);
return(ResponseMapper.MapCensysResponseToDto(censysResult));
default:
return(null);
}
}
public RefundResponse Refund(RefundRequest request)
{
// Validate Request
RequestValidator.ValidateRefundRequest(request);
// Map input request in the XML Request
var requestXML = RequestMapper.MapRefundRequest(request, _shopId);
//calculate MAC
requestXML.Request.MAC = _encoder.GetMac(RequestHandler.GetMacDictionary(requestXML), _apiResultKey);
// Do call to VPOS
var xmlBody = XmlTool.Serialize(requestXML);
var xmlResponse = _restClient.CallApi(_urlAPI, xmlBody);
var objectResponse = XmlTool.Deserialize <BPWXmlResponse <DataManageOperation> >(xmlResponse);
// Verify Mac Response
VerifyMacResponse(objectResponse);
VerifyOperation(objectResponse.Data.Operation);
return(ResponseMapper.MapRefundResponse(objectResponse));
}
public DomainResponseModel Get([Required] string id)
{
if (String.IsNullOrEmpty(id.Trim()))
{
return(null);
}
var domain = _backingService.GetDomainById(id);
if (domain == null)
{
return(null);
}
// Get a resource
return(new DomainResponseModel()
{
Domain = ResponseMapper.ToResponseDomain(domain)
});
}
public ThreeDSAuthorization2Response ThreeDSAuthorize2(ThreeDSAuthorization2Request request)
{
// Validate request
RequestValidator.ValidateThreeDSAuthorize2Request(request);
// Map input request in the XML Request
var requestXML = RequestMapper.MapThreeDSAuthorization2Request(request, _shopId);
// Calculate and set MAC
requestXML.Request.MAC = _encoder.GetMac(RequestHandler.GetMacDictionary(requestXML), _apiResultKey);
var xmlBody = XmlTool.Serialize(requestXML);
// Do call to VPOS
var xmlResponse = _restClient.CallApi(_urlAPI, xmlBody);
var objectResponse = XmlTool.Deserialize <BPWXmlResponse <Data3DSResponse> >(xmlResponse);
// Verify Mac Response
VerifyMacResponse(objectResponse);
VerifyAuthorization(objectResponse.Data.Authorization);
VerifyPanAliasData(objectResponse.Data.PanAliasData);
return(ResponseMapper.MapThreeDSAuthorization2(objectResponse));
}
public EndeavourDirectoryResponseModel Get([Required] string userId)
{
if (String.IsNullOrEmpty(userId.Trim()))
{
return(null);
}
var endeavours = _backingService.GetMyEndeavours(userId);
if (endeavours == null)
{
return(null);
}
// Get a resource
return(new EndeavourDirectoryResponseModel()
{
Directory = endeavours.Select(c => ResponseMapper.ToResponseEndeavourDirectoryEntry(c)).ToArray <ResponseEndeavourDirectoryEntry>()
});
}
public async Task <ActionResult <IResponse <object> > > PlayAsync(PlayGameInstanceDto dto)
{
var validationResponse = GameInstanceValidator.Validate(dto);
if (!validationResponse.IsValid)
{
return(BadRequest(validationResponse));
}
var gameInstanceResponse = GameInstanceLogic.Play(dto);
var response = ResponseMapper.MapMetadata <GameInstanceDto>(gameInstanceResponse);
response.Data = GameInstanceMapper.Map(GameInstanceLogic.Get(dto.Id));
if (response.IsValid)
{
await GameHubContext.Clients.Group(dto.Id.ToString()).SendAsync("Refresh");
}
return(Ok(response));
}
