public void Ctor_ShouldReturnInstanceOfClass_WhenDependenciesAreValid()
{
Mock <ISkillRequestValidator> mockSkillRequestValidator = new Mock <ISkillRequestValidator>();
Mock <ILogger <RequestMapper> > mockLogger = new Mock <ILogger <RequestMapper> >();
List <Mock <IRequestRouter> > mockRequestRouters = new List <Mock <IRequestRouter> >();
mockRequestRouters.Add(new Mock <IRequestRouter>());
RequestMapper sut = new RequestMapper(mockSkillRequestValidator.Object, mockLogger.Object, mockRequestRouters.Select(x => x.Object));
Assert.IsType <RequestMapper>(sut);
}
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 void GetRequestHandler_ShouldThrowArgumentNullException_WhenSkillRequestIsInvalid()
{
Mock <ISkillRequestValidator> mockSkillRequestValidator = new Mock <ISkillRequestValidator>();
mockSkillRequestValidator.Setup(x => x.IsValid(It.IsAny <SkillRequest>())).Returns(false);
Mock <ILogger <RequestMapper> > mockLogger = new Mock <ILogger <RequestMapper> >();
List <Mock <IRequestRouter> > mockRequestRouters = new List <Mock <IRequestRouter> >();
mockRequestRouters.Add(new Mock <IRequestRouter>());
RequestMapper sut = new RequestMapper(mockSkillRequestValidator.Object, mockLogger.Object, mockRequestRouters.Select(x => x.Object));
Assert.Throws <ArgumentNullException>(() => sut.GetRequestHandler(new SkillRequest()));
}
public void MappingDetails_WhenInputCorrect()
{
var merchantId = "merchantId";
var merchantRef = "merchantRef";
var timeStamp = DateTimeOffset.UtcNow;
clock.Setup(c => c.GetCurrentUtcTimestamp()).Returns(timeStamp);
var response = RequestMapper.MapDetailsRequest(merchantId, merchantRef, clock.Object);
Check.That(response).IsNotNull();
Check.That(response.MerchantId).Equals(merchantId);
Check.That(response.MerchantReferenceNumber).Equals(merchantRef);
Check.That(response.TimeStamp).Equals(timeStamp);
}
public async Task <ActionResult <Request> > GetOne(int id)
{
var result = await _requestRepository.GetRequestById(id);
if (result == null)
{
return(NotFound());
}
result.Customer = await _customerRepository.GetCustomerById(result.CustomerId);
var reqResource = RequestMapper.MapToRequestDTO(result);
return(Ok(reqResource));
}
public async Task <ActionResult <Request> > GetRequestSubscribers(int id)
{
var request = await _requestRepository.GetRequestById(id);
if (request == null)
{
return(NotFound());
}
var subs = _requestRepository.GetAllRequests().First(r => r.Id == id).Subscribers.ToList();
var subResource = RequestMapper.MapToSubscriberDTOList(subs);
return(Ok(subResource));
}
public async Task <Model.Request> GetRequestByID(long id)
{
var param = new DynamicParameters();
param.Add("@ID", id);
var mapper = new RequestMapper();
return((await SqlMapper.QueryAsync(_unitOfWork.Connection,
"GetRequestByID",
new[]
{
typeof(Model.Request),
typeof(Code),
typeof(Code),
typeof(HalalTeam),
typeof(Premise),
typeof(Characteristic),
typeof(RFA),
typeof(Log),
typeof(Attachment),
typeof(RequestLineItem),
typeof(Review),
typeof(ReviewLineItem),
typeof(Characteristic)
},
obj =>
{
return mapper.Map(obj[0] as Model.Request,
obj[1] as Code,
obj[2] as Code,
obj[3] as HalalTeam,
obj[4] as Premise,
obj[5] as Characteristic,
obj[6] as RFA,
obj[7] as Log,
obj[8] as Attachment,
obj[9] as RequestLineItem,
obj[10] as Review,
obj[11] as ReviewLineItem,
obj[12] as Characteristic);
},
param,
splitOn: "ID,CCID,GCID,HalalTeamID,PremiseID,CharID,RFAID,LogID,AttID,LineItemID,ReviewID," +
"ReviewLineItemID,LiCharID",
commandType: CommandType.StoredProcedure,
transaction: _unitOfWork.Transaction)).FirstOrDefault());
}
static void Execute(ISystem system, string path)
{
IEnumerable <IEnumerable <string> > allInputs = ReadInputs(path);
foreach (var inputs in allInputs)
{
foreach (string input in inputs)
{
system.Form.Insert(input);
}
var request = RequestMapper.Map(system.Form);
var result = ServeRequest(request);
system.Display.Print(result);
Console.WriteLine("==============================================================");
}
}
/// <summary>
/// Get all request records
/// </summary>
/// <returns></returns>
public IEnumerable <Request> GetAllRequests()
{
using (var command = new SqlCommand("sp_GetAllRequests", _connection))
{
command.CommandType = CommandType.StoredProcedure;
var requestList = new List <Request>();
using (var reader = command.ExecuteReader())
{
while (reader.Read())
{
var request = RequestMapper.Map(reader);
requestList.Add(request);
}
}
return(requestList);
}
}
public async Task <Model.Request> GetRequestByRefID(string refID)
{
var param = new DynamicParameters();
param.Add("@RefID", refID);
var mapper = new RequestMapper();
return((await SqlMapper.QueryAsync(_unitOfWork.Connection,
"GetRequestByRefID",
new[]
{
typeof(Model.Request),
typeof(HalalTeam),
typeof(Premise),
typeof(Characteristic),
typeof(RFA),
typeof(Log),
typeof(Attachment),
typeof(RequestLineItem),
typeof(Review),
typeof(ReviewLineItem),
typeof(Characteristic)
},
obj =>
{
Model.Request re = obj[0] as Model.Request;
HalalTeam ha = obj[1] as HalalTeam;
Premise pr = obj[2] as Premise;
Characteristic ch = obj[3] as Characteristic;
RFA r = obj[4] as RFA;
Log l = obj[5] as Log;
Attachment att = obj[6] as Attachment;
RequestLineItem rli = obj[7] as RequestLineItem;
Review rev = obj[8] as Review;
ReviewLineItem revli = obj[9] as ReviewLineItem;
Characteristic licha = obj[10] as Characteristic;
return mapper.Map(re, null, null, ha, pr, ch, r, l, att, rli, rev, revli, licha);
},
param,
splitOn: "ID,HalalTeamID,PremiseID,CharID,RFAID,LogID,AttID,LineItemID,ReviewID," +
"ReviewLineItemID,LiCharID",
commandType: CommandType.StoredProcedure,
transaction: _unitOfWork.Transaction)).FirstOrDefault());
}
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 Request GetRequestById(int id)
{
using (var command = new SqlCommand("sp_GetRequestById", _connection))
{
command.CommandType = CommandType.StoredProcedure;
command.Parameters.AddWithValue("@RequestId", id);
var request = new Request();
using (var reader = command.ExecuteReader())
{
while (reader.Read())
{
request = RequestMapper.Map(reader);
}
}
return(request);
}
}
public async Task <ActionResult> DeleteUserFromRequest(int id)
{
var request = await _requestRepository.GetRequestById(id);
if (request != null)
{
request.DesignatedUser = null;
await _requestRepository.UpdateRequest(request);
request.Customer = await _customerRepository.GetCustomerById(request.CustomerId);
var reqResource = RequestMapper.MapToRequestDTO(request);
return(Ok(reqResource));
}
return(BadRequest());
}
public IEnumerable <Request> GetAllRequestsByStatus(int status)
{
using (var command = new SqlCommand("sp_GetAllRequestsByState", _connection))
{
command.CommandType = CommandType.StoredProcedure;
command.Parameters.AddWithValue("@State", status);
var requestList = new List <Request>();
using (var reader = command.ExecuteReader())
{
while (reader.Read())
{
var request = RequestMapper.Map(reader);
requestList.Add(request);
}
}
return(requestList);
}
}
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 void GetRequestHandler_ShouldThrowNotSupportedException_WhenSkillRequestTypeIsUnknown()
{
Mock <ISkillRequestValidator> mockSkillRequestValidator = new Mock <ISkillRequestValidator>();
mockSkillRequestValidator.Setup(x => x.IsValid(It.IsAny <SkillRequest>())).Returns(true);
Mock <ILogger <RequestMapper> > mockLogger = new Mock <ILogger <RequestMapper> >();
Mock <IRequestRouter> mockRequestrouter = new Mock <IRequestRouter>();
mockRequestrouter.Setup(x => x.RequestType).Returns(RequestType.IntentRequest);
List <Mock <IRequestRouter> > mockRequestRouters = new List <Mock <IRequestRouter> >();
mockRequestRouters.Add(mockRequestrouter);
RequestMapper sut = new RequestMapper(mockSkillRequestValidator.Object, mockLogger.Object, mockRequestRouters.Select(x => x.Object));
Assert.Throws <Exception>(() => sut.GetRequestHandler(GenerateValidSkillRequest(new UnknownRequest())));
}
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 HttpResponseMessage GetRequest(DateTime date, string lastname, RequestState state)
{
var context = ApplicationEntityContextFactory.Current;
var map = new RequestMapper(context);
var Query = map.GetRequestPOCOQueryable();
Query = Query.Where(t =>
t.InsertDateTime == date &&
t.CurrentState == state
);
if (!string.IsNullOrEmpty(lastname))
{
Query = Query.Where(t => t.LastName.Contains(lastname));
}
var result = Query.ToList();
return(Request.CreateResponse(result));
}
public async Task <Model.Request> ValidateRequest
(Scheme?Scheme, SubScheme?SubScheme, Premise premise)
{
var dp = DataConverter.ToPremiseData(premise);
var param = new DynamicParameters();
param.Add("@Scheme", (int)Scheme);
if (SubScheme != null)
{
param.Add("@SubScheme", (int)SubScheme);
}
else
{
param.Add("@SubScheme", SubScheme);
}
param.Add("@Premise", dp.AsTableValuedParameter("dbo.PremiseType"));
var mapper = new RequestMapper();
return((await SqlMapper.QueryAsync <Model.Request>(_unitOfWork.Connection,
"ValidateRequest",
new[]
{
typeof(Model.Request),
typeof(Model.RequestLineItem),
typeof(Model.Premise)
},
obj =>
{
return mapper.Map(obj[0] as Model.Request,
obj[1] as RequestLineItem,
obj[2] as Premise);
},
param,
splitOn: "ID,LineItemID,PremiseID",
commandType: CommandType.StoredProcedure,
transaction: _unitOfWork.Transaction)).FirstOrDefault());
}
public AuthorizeResponse Authorize(AuthorizeRequest authorize)
{
// Validate request
RequestValidator.ValidateAuthorizeRequest(authorize);
// Map input request in the XML Request
var request = RequestMapper.MapAuthorizeRequest(authorize, _shopId);
// Calculate and set MAC
request.Request.MAC = _encoder.GetMac(RequestHandler.GetMacDictionary(request), _apiResultKey);
var xmlBody = XmlTool.Serialize(request);
// Do call to VPOS
var xmlResponse = _restClient.CallApi(_urlAPI, xmlBody);
// Map response
var objectResponse = XmlTool.Deserialize <BPWXmlResponse <DataAuthorize> >(xmlResponse);
// Verify Response MAC
VerifyMacResponse(objectResponse);
VerifyAuthorization(objectResponse.Data.Authorization);
VerifyPanAliasData(objectResponse.Data.PanAliasData);
//Response Mapping
return(ResponseMapper.MapAuthorize(objectResponse));;
}
private bool ParseBuildRequest()
{
if (_server.RequestCache.TryLookupParsedRequest(_requestContext))
{
return(true);
}
// Parse
var parseTree = ParseRequest();
if (_requestContext.Failed)
{
return(false);
}
// parse/build request
var reqBuilder = new RequestParser(_requestContext);
if (!reqBuilder.BuildRequest(parseTree))
{
return(false);
}
// Map and validate
var mapper = new RequestMapper(_requestContext);
mapper.MapAndValidateRequest();
if (_requestContext.Failed)
{
return(false);
}
var success = !_requestContext.Failed;
if (success && !_requestContext.Metrics.FromCache)
{
_server.RequestCache.AddParsedRequest(_requestContext);
}
return(success);
}
public void GetRequestHandler_ShouldThrowNotSupportedException_WhenSkillRequestTypeIsPlaybackControllerRequest()
{
Mock <ISkillRequestValidator> mockSkillRequestValidator = new Mock <ISkillRequestValidator>();
mockSkillRequestValidator.Setup(x => x.IsValid(It.IsAny <SkillRequest>())).Returns(true);
Mock <ILogger <RequestMapper> > mockLogger = new Mock <ILogger <RequestMapper> >();
Mock <IRequestRouter> mockRequestrouter = new Mock <IRequestRouter>();
mockRequestrouter.Setup(x => x.RequestType).Returns(RequestType.IntentRequest);
List <Mock <IRequestRouter> > mockRequestRouters = new List <Mock <IRequestRouter> >();
mockRequestRouters.Add(mockRequestrouter);
RequestMapper sut = new RequestMapper(mockSkillRequestValidator.Object, mockLogger.Object, mockRequestRouters.Select(x => x.Object));
Assert.Throws <NotSupportedException>(() => sut.GetRequestHandler(GenerateValidSkillRequest(new PlaybackControllerRequest()
{
RequestId = "TestRequestId", Type = "PlaybackControllerRequestType.Next", Locale = "en-US"
})));
}
public static Request ToEntity(this RequestMapper request)
{
return(new Request
{
RequestDate = request.RequestDate,
IsClosed = false,
Reciever = new Reciever
{
FirstName = request.Reciever.FirstName,
LastName = request.Reciever.LastName,
Age = request.Reciever.Age,
Address = request.Reciever.Address
},
RequestDetails = new RequestDetails
{
AnimalType = request.RequestDetails.AnimalType,
Gender = request.RequestDetails.Gender,
MinAge = request.RequestDetails.MinAge,
MaxAge = request.RequestDetails.MaxAge,
Color = request.RequestDetails.Color
}
});
}
public OrderStatusResponse GetOrderStatus(OrderStatusRequest orderStatusRequest)
{
// Validate Request
RequestValidator.ValidateOrderStatusRequest(orderStatusRequest);
// Build Request object
var request = RequestMapper.MapOrderStatusRequest(orderStatusRequest, _shopId);
request.Request.MAC = _encoder.GetMac(RequestHandler.GetMacDictionary(request), _apiResultKey);
var xmlBody = XmlTool.Serialize(request);
// Do call to VPOS
var xmlResponse = _restClient.CallApi(_urlAPI, xmlBody);
// Map response
var objectResponse = XmlTool.Deserialize <BPWXmlResponse <DataOrderStatus> >(xmlResponse);
// Verify Mac Response
VerifyMacResponse(objectResponse);
VerifyPanAliasData(objectResponse.Data.PanAliasData);
foreach (var authorization in objectResponse.Data.Authorizations)
{
VerifyAuthorization(authorization);
}
return(ResponseMapper.MapOrderStatusResponse(objectResponse));
}
public void GetRequestHandler_ShouldReturnConnectionResponseRequestHandler_WhenSkillRequestTypeIsConnectionResponseRequest()
{
Mock <ISkillRequestValidator> mockSkillRequestValidator = new Mock <ISkillRequestValidator>();
mockSkillRequestValidator.Setup(x => x.IsValid(It.IsAny <SkillRequest>())).Returns(true);
Mock <ILogger <RequestMapper> > mockLogger = new Mock <ILogger <RequestMapper> >();
Mock <IRequestRouter> mockRequestrouter = new Mock <IRequestRouter>();
mockRequestrouter.Setup(x => x.RequestType).Returns(RequestType.ConnectionResponseRequest);
List <Mock <IRequestRouter> > mockRequestRouters = new List <Mock <IRequestRouter> >();
mockRequestRouters.Add(mockRequestrouter);
RequestMapper sut = new RequestMapper(mockSkillRequestValidator.Object, mockLogger.Object, mockRequestRouters.Select(x => x.Object));
IRequestRouter requestHandler = sut.GetRequestHandler(GenerateValidSkillRequest(new ConnectionResponseRequest()
{
RequestId = "TestRequestId", Type = "Connections.Response", Locale = "en-US"
}));
Assert.True(requestHandler != null);
}
public async Task <Response <R> > ExecuteTaskAsync <T, R>(Request <T> request)
{
try
{
IRestResponse <R> restResponse = null;
//generating rest request
var restRequest =
RequestMapper.MapRequestToRestRequest(request, request.Data);
//execute request
restResponse = await ExecuteRequest <R>(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));
}
catch (System.Exception ex)
{
throw ex;
}
}
public void GetRequestHandler_ShouldReturnSessionEndedRequestHandler_WhenSkillRequestTypeIsSessionEndedRequest()
{
Mock <ISkillRequestValidator> mockSkillRequestValidator = new Mock <ISkillRequestValidator>();
mockSkillRequestValidator.Setup(x => x.IsValid(It.IsAny <SkillRequest>())).Returns(true);
Mock <ILogger <RequestMapper> > mockLogger = new Mock <ILogger <RequestMapper> >();
Mock <IRequestRouter> mockRequestrouter = new Mock <IRequestRouter>();
mockRequestrouter.Setup(x => x.RequestType).Returns(RequestType.SessionEndedRequest);
List <Mock <IRequestRouter> > mockRequestRouters = new List <Mock <IRequestRouter> >();
mockRequestRouters.Add(mockRequestrouter);
RequestMapper sut = new RequestMapper(mockSkillRequestValidator.Object, mockLogger.Object, mockRequestRouters.Select(x => x.Object));
IRequestRouter intentRequestHandler = sut.GetRequestHandler(GenerateValidSkillRequest(new SessionEndedRequest()
{
RequestId = "TestRequestId", Type = "SessionEndedRequest", Locale = "en-US"
}));
Assert.Equal(RequestType.SessionEndedRequest, intentRequestHandler.RequestType);
}
public async Task <Model.Request> GetParentRequest
(Scheme?Scheme, SubScheme?SubScheme, Premise premise,
RequestStatus[] statuses, RequestType[] requestTypes)
{
var statusTable = new DataTable();
statusTable.Columns.Add("Val", typeof(int));
if (statuses?.Any() ?? false)
{
foreach (var status in statuses)
{
statusTable.Rows.Add(status);
}
}
var typeTable = new DataTable();
typeTable.Columns.Add("Val", typeof(int));
if (requestTypes?.Any() ?? false)
{
foreach (var rtype in requestTypes)
{
typeTable.Rows.Add(rtype);
}
}
var param = new DynamicParameters();
param.Add("@Scheme", (int)Scheme);
if (SubScheme != null)
{
param.Add("@SubScheme", (int)SubScheme);
}
else
{
param.Add("@SubScheme", SubScheme);
}
param.Add("@BlockNo", premise.BlockNo);
param.Add("@UnitNo", premise.UnitNo);
param.Add("@FloorNo", premise.FloorNo);
param.Add("@BuildingName", premise.BuildingName);
param.Add("@Address1", premise.Address1);
param.Add("@Postal", premise.Postal);
param.Add("@Status", statusTable.AsTableValuedParameter("dbo.SmallIntType"));
param.Add("@ReqTypes", typeTable.AsTableValuedParameter("dbo.SmallIntType"));
var mapper = new RequestMapper();
return((await SqlMapper.QueryAsync <Model.Request>(_unitOfWork.Connection,
"GetParentRequest",
new[]
{
typeof(Model.Request),
typeof(Model.RequestLineItem),
typeof(Model.Premise)
},
obj =>
{
return mapper.Map(obj[0] as Model.Request,
obj[1] as RequestLineItem,
obj[2] as Premise);
},
param,
splitOn: "ID,LineItemID,PremiseID",
commandType: CommandType.StoredProcedure,
transaction: _unitOfWork.Transaction)).FirstOrDefault());
}
public RequestMapperTests()
{
_httpContext = new DefaultHttpContext();
_inputRequest = _httpContext.Request;
_requestMapper = new RequestMapper();
}
public RequestMapperTests()
{
_inputRequest = new DefaultHttpRequest(new DefaultHttpContext());
_requestMapper = new RequestMapper();
}
