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(); }