private void HandleGetRequest(HttpContext context, Func <IResult, IResult> resultWrapper)
{
var request = new HttpRequestWrapper(context.Request);
var response = new HttpResponseWrapper(context.Response);
var absolutePath = HttpUtility.UrlDecode(request.Url.AbsolutePath);
var originalFormat = FormatInfoProvider.ResolveFromExtension(Path.GetExtension(absolutePath));
if (originalFormat == null)
{
ServeIllegalExtensionResult(response);
return;
}
IMediaTransformer mediaTransformer;
var transformMedia = MediaTransformerFactory.TryCreateTransformer(request, originalFormat, FormatInfoProvider, out mediaTransformer);
var outputFormat = transformMedia ? mediaTransformer.OutputFormat : originalFormat;
IResult result;
if (TryGetResult(request, outputFormat, transformMedia, mediaTransformer, out result))
{
result = resultWrapper(result);
ResultHandler.HandleResult(result, outputFormat, request, response);
result.Dispose();
}
else
{
ServeNotFoundResult(response);
}
}
public static void MockContext(this ViewController controller, IRegisteredUser user)
{
var identity = new RegisteredUserIdentity(user.Id, user.UserType, user.IsActivated)
{
FullName = user.FullName, NeedsReset = false, User = user
};
var principal = new RegisteredUserPrincipal(identity);
var mockContext = new Mock <HttpContextBase>();
mockContext.SetupGet(c => c.User).Returns(principal);
var mockRequest = new Mock <HttpRequestBase>();
mockRequest.SetupGet(r => r.Headers).Returns(new NameValueCollection {
{ "X-Rewrite-URL", "/" }
});
mockContext.SetupGet(c => c.Request).Returns(mockRequest.Object);
var mockResponse = new HttpResponseWrapper(new HttpResponse(new StringWriter()));
mockContext.SetupGet(c => c.Response).Returns(mockResponse);
var mockControllerContext = new Mock <ControllerContext>();
mockControllerContext.SetupGet(c => c.HttpContext).Returns(mockContext.Object);
controller.ControllerContext = mockControllerContext.Object;
}
public override void ProcessRequest(HttpContext context)
{
var response = new HttpResponseWrapper(context.Response);
var operationName = context.Request.GetOperationName();
if (DefaultHandledRequest(context))
{
return;
}
try
{
if (string.IsNullOrEmpty(operationName))
{
return;
}
var request = CreateRequest(context.Request, operationName);
var endpointAttributes = EndpointAttributes.SyncReply | EndpointAttributes.Xml
| GetEndpointAttributes(context.Request);
var result = ExecuteService(request, endpointAttributes);
response.WriteToResponse(result, x => DataContractSerializer.Instance.Parse(x), ContentType.Xml);
}
catch (Exception ex)
{
var errorMessage = string.Format("Error occured while Processing Request: {0}", ex.Message);
Log.Error(errorMessage, ex);
response.WriteXmlErrorToResponse(operationName, errorMessage, ex);
}
}
private void Application_BeginRequest(Object source, EventArgs e)
{
if (HttpContext.Current == null)
{
return;
}
var request = new HttpRequestWrapper(HttpContext.Current.Request);
var response = new HttpResponseWrapper(HttpContext.Current.Response);
var cookieNames = new[] { CookieHelper.AssistedUserCookieName, CookieHelper.UserDataCookieName };
foreach (var cookieName in cookieNames)
{
var data = request.GetCookieData <CookieUserData>(cookieName);
if (data == null)
{
continue;
}
var ticksElapsed = DateTime.Now.Ticks - data.Issued.Ticks;
var halfTime = FormsAuthentication.Timeout.Ticks / 2;
if (ticksElapsed >= halfTime)
{
data.Issued = DateTime.Now;
response.SetCookieData(cookieName, data);
}
}
}
/// <summary>
/// Stream a file from a file resource.
/// </summary>
/// <param name="context"></param>
/// <param name="uri"></param>
/// <returns></returns>
private long StreamFromFileResource(HttpContextWrapper context, Uri uri)
{
long bytes = 0;
// Get the HttpResponse from this proxied request.
HttpResponseWrapper response = (HttpResponseWrapper)context.Response;
if (System.IO.File.Exists(uri.LocalPath))
{
response.ContentType = MimeType(uri.LocalPath);
// Transfer the stream to the response stream
using (FileStream stream = new FileStream(uri.LocalPath, FileMode.Open))
{
stream.CopyTo(response.OutputStream);
response.End();
}
}
else
{
//response.StatusCode = 404;
//response.End();
throw new DescriptiveHttpException(404, "Resource not found", "The requested file was not found or is no longer available.");
}
return(bytes);
}
public override void ProcessRequest(HttpContext context)
{
var response = new HttpResponseWrapper(context.Response);
var operationName = context.Request.GetOperationName();
if (string.IsNullOrEmpty(operationName)) return;
if (DefaultHandledRequest(context)) return;
try
{
var request = CreateRequest(context.Request, operationName);
var endpointAttributes = EndpointAttributes.SyncReply | EndpointAttributes.Jsv
| GetEndpointAttributes(context.Request);
var result = ExecuteService(request, endpointAttributes);
var isDebugRequest = context.Request.RawUrl.ToLower().Contains("debug");
var writeFn = isDebugRequest
? (Func<object, string>)JsvFormatter.SerializeAndFormat
: TypeSerializer.SerializeToString;
var contentType = isDebugRequest ? ContentType.PlainText : ContentType.JsvText;
response.WriteToResponse(result, writeFn, contentType);
}
catch (Exception ex)
{
var errorMessage = string.Format("Error occured while Processing Request: {0}", ex.Message);
Log.Error(errorMessage, ex);
response.WriteJsvErrorToResponse(operationName, errorMessage, ex);
}
}
public override void ProcessRequest(HttpContext context)
{
var response = new HttpResponseWrapper(context.Response);
var operationName = context.Request.GetOperationName();
if (DefaultHandledRequest(context)) return;
try
{
if (string.IsNullOrEmpty(operationName)) return;
var request = CreateRequest(context.Request, operationName);
var endpointAttributes = EndpointAttributes.SyncReply | EndpointAttributes.Xml
| GetEndpointAttributes(context.Request);
var result = ExecuteService(request, endpointAttributes);
response.WriteToResponse(result, x => DataContractSerializer.Instance.Parse(x), ContentType.Xml);
}
catch (Exception ex)
{
var errorMessage = string.Format("Error occured while Processing Request: {0}", ex.Message);
Log.Error(errorMessage, ex);
response.WriteXmlErrorToResponse(operationName, errorMessage, ex);
}
}
public void Init(HttpApplication context)
{
context.BeginRequest += (sender, e) =>
{
try
{
var application = sender as HttpApplication;
if (application != null)
{
var request = application.Request;
var response = application.Response;
if (request != null && response != null)
{
var wrappedRequest = new HttpRequestWrapper(request);
var wrappedResponse = new HttpResponseWrapper(response);
ResolveDuplicateCookies(wrappedRequest, wrappedResponse);
Restore(wrappedRequest, wrappedResponse);
}
}
}
catch
{
}
};
}
public override void Fetch(HttpRequestWrapper request, HttpResponseWrapper response)
{
if (request.getHeaders("If-Modified-Since") != null)
{
if (!request.isConcat)
{
response.setStatus((int)HttpStatusCode.NotModified);
}
return;
}
String host = request.getHeaders("Host");
if (!lockedDomainService.isSafeForOpenProxy(host))
{
// Force embedded images and the like to their own domain to avoid XSS
// in gadget domains.
return;
}
sRequest rcr = buildHttpRequest(request);
sResponse results = fetcher.fetch(rcr);
if (contentRewriterRegistry != null)
{
results = contentRewriterRegistry.rewriteHttpResponse(rcr, results);
}
if (!request.isConcat)
{
SetResponseHeaders(request, response.getResponse(), results);
for (int i = 0; i < results.getHeaders().Count; i++)
{
String name = results.getHeaders().GetKey(i);
if (!DISALLOWED_RESPONSE_HEADERS.Contains(name.ToLower()))
{
foreach (String value in results.getHeaders().GetValues(i))
{
response.AddHeader(name, value);
}
}
}
}
if (request.getParameter("rewriteMime") != null)
{
response.setContentType(request.getParameter("rewriteMime"));
}
if (results.getHttpStatusCode() != (int)HttpStatusCode.OK)
{
response.setStatus((int)results.getHttpStatusCode());
}
else
{
response.setStatus((int)HttpStatusCode.OK);
}
response.Write(results.responseBytes);
}
internal static Dictionary <string, string> FromHttpResponseWrapper(HttpResponseWrapper response)
{
GaxPreconditions.CheckNotNull(response, nameof(response));
return(new Dictionary <string, string>
{
{ LabelsCommon.HttpStatusCode, response.StatusCode.ToString() }
});
}
private void CheckForAuthFailure(object sender, EventArgs e)
{
var app = sender as HttpApplication;
var response = new HttpResponseWrapper(app.Response);
var request = new HttpRequestWrapper(app.Request);
var context = new HttpContextWrapper(app.Context);
CheckForAuthFailure(request, response, context);
}
public AccountController(
HttpContextWrapper httpContext,
HttpResponseWrapper httpResponse)
{
_context = httpContext;
_response = httpResponse;
_authenticationManager = _context.GetOwinContext().Authentication;
_userManager =
_context.GetOwinContext().GetUserManager <ApplicationUserManager>();
}
public override async Task ProcessRequestAsync(HttpContext context)
{
context.ThrowIfNull("context");
var request = new HttpRequestWrapper(context.Request);
var response = new HttpResponseWrapper(context.Response);
if (_antiCsrfCookieManager != null && _antiCsrfNonceValidator != null && _antiCsrfResponseGenerator != null)
{
if (!String.IsNullOrEmpty(context.Request.ContentType))
{
try
{
var contentType = new ContentType(context.Request.ContentType);
if (String.Equals(contentType.MediaType, "application/x-www-form-urlencoded", StringComparison.OrdinalIgnoreCase) || String.Equals(contentType.MediaType, "multipart/form-data", StringComparison.OrdinalIgnoreCase))
{
ValidationResult validationResult = await _antiCsrfNonceValidator.ValidateAsync(request);
ResponseResult responseResult = await _antiCsrfResponseGenerator.GetResponseAsync(validationResult);
if (responseResult.ResultType == ResponseResultType.ResponseGenerated)
{
await ProcessResponseAsync(context, responseResult.Response, null);
return;
}
}
}
catch (FormatException)
{
}
}
await _antiCsrfCookieManager.ConfigureCookieAsync(request, response);
}
{
IEnumerable <RouteMatchResult> routeMatchResults = await GetRouteMatchResultsAsync(request);
IEnumerable <Task <ResponseGenerators.ResponseResult> > responseResultTasks = _responseGenerators.Select(arg => arg.GetResponseAsync(new HttpContextWrapper(context), routeMatchResults));
foreach (Task <ResponseGenerators.ResponseResult> responseResultTask in responseResultTasks)
{
ResponseGenerators.ResponseResult responseResult = await responseResultTask;
if (responseResult.ResultType == ResponseGenerators.ResponseResultType.ResponseGenerated)
{
await ProcessResponseAsync(context, await responseResult.Response, responseResult.CacheKey);
return;
}
}
}
}
public void ApplyHeadersToResponse()
{
var headers = new WebHeaderCollection();
headers[HttpResponseHeader.ContentType] = "application/binary";
var response = new HttpResponseWrapper(new HttpResponse(new StringWriter()));
MessagingUtilities.ApplyHeadersToResponse(headers, response);
Assert.AreEqual(headers[HttpResponseHeader.ContentType], response.ContentType);
}
public async Task ListarPedidos()
{
responseHttp = await repositorio.Get <List <Pedido> >($"api/pedido?pagina={paginaActual}&cantidadDeRegistros={cantidadDeRegistrosAMostrar}&userName={userName}&vendedorId={vendedorIdFiltro}&provinciaId={provinciaIdFiltro}&estadoPedidoId={estadoPedidoIdFiltro}&tipoListaPrecioId={tipoListaPrecioIdFiltro}");
if (!responseHttp.Error)
{
pedidos = responseHttp.Response;
registrosTotales = int.Parse(responseHttp.HttpResponseMessage.Headers.GetValues("conteo").FirstOrDefault());
paginasTotales = int.Parse(responseHttp.HttpResponseMessage.Headers.GetValues("totalPaginas").FirstOrDefault());
}
}
public async Task ListarItemsApi(int pagina = 1)
{
responseHttp = await repositorio.Get <List <T> >($"{consultaApi.baseUrl}pagina={pagina}&cantidadDeRegistros={consultaApi.cantidadDeRegistrosAMostrar}");
if (!responseHttp.Error)
{
listado = responseHttp.Response;
var conteo = responseHttp.HttpResponseMessage.Headers.GetValues("conteo").FirstOrDefault();
paginasTotales = int.Parse(responseHttp.HttpResponseMessage.Headers.GetValues("totalPaginas").FirstOrDefault());
}
}
public async Task ListarInventarios(int pagina = 1)
{
responseHttp = await repositorio.Get <List <Inventario> >($"api/inventario/InventarioPorDeposito?depositoId={deposito.Id}&filtro={filtro}&pagina={pagina}&cantidadDeRegistros=50");
if (!responseHttp.Error)
{
inventarios = responseHttp.Response;
var conteo = responseHttp.HttpResponseMessage.Headers.GetValues("conteo").FirstOrDefault();
paginasTotales = int.Parse(responseHttp.HttpResponseMessage.Headers.GetValues("totalPaginas").FirstOrDefault());
}
}
public GlobalHttpContext()
{
useContext = Current;
response = new HttpResponseWrapper(useContext);
request = new HttpRequestWrapper(useContext);
try {
if (useContext.Session != null)
{
session = new HttpSessionState(useContext);
}
} catch { }
server = new HttpServerUtility();
}
public async Task ListarRecibos()
{
responseHttp = await repositorio.Get <List <ReciboCobranzas> >($"api/reciboCobranza?pagina={paginaActual}&cantidadDeRegistros={cantidadDeRegistrosAMostrar}");
if (!responseHttp.Error)
{
recibosCobranza = responseHttp.Response;
registrosTotales = int.Parse(responseHttp.HttpResponseMessage.Headers.GetValues("conteo").FirstOrDefault());
paginasTotales = int.Parse(responseHttp.HttpResponseMessage.Headers.GetValues("totalPaginas").FirstOrDefault());
}
}
public async Task ListarFacturas()
{
responseHttp = await repositorio.Get <List <FacturaCompras> >($"api/facturaCompra?pagina={paginaActual}&cantidadDeRegistros={cantidadDeRegistrosAMostrar}&estadoFacturaId={estadoFacturaIdFiltro}");
if (!responseHttp.Error)
{
facturas = responseHttp.Response;
registrosTotales = int.Parse(responseHttp.HttpResponseMessage.Headers.GetValues("conteo").FirstOrDefault());
paginasTotales = int.Parse(responseHttp.HttpResponseMessage.Headers.GetValues("totalPaginas").FirstOrDefault());
}
}
public async Task ListarMovimientosInventario(int pagina = 1)
{
responseHttp = await repositorio.Get <List <MovimientoInventario> >($"api/movimientoInventario?inventarioId={inventario.Id}&pagina={pagina}&cantidadDeRegistros=20");
if (!responseHttp.Error)
{
inventario.MovimientosInventario = responseHttp.Response;
var conteo = responseHttp.HttpResponseMessage.Headers.GetValues("conteo").FirstOrDefault();
paginasTotales = int.Parse(responseHttp.HttpResponseMessage.Headers.GetValues("totalPaginas").FirstOrDefault());
}
}
public async Task ListarClientes()
{
responseHttp = await repositorio.Get <List <OrdenProduccion> >($"api/ordenProduccion?pagina={paginaActual}&cantidadDeRegistros={cantidadDeRegistrosAMostrar}");
if (!responseHttp.Error)
{
ordenesProduccion = responseHttp.Response;
registrosTotales = int.Parse(responseHttp.HttpResponseMessage.Headers.GetValues("conteo").FirstOrDefault());
paginasTotales = int.Parse(responseHttp.HttpResponseMessage.Headers.GetValues("totalPaginas").FirstOrDefault());
}
}
public async Task ListarClientes()
{
responseHttp = await repositorio.Get <List <Cliente> >($"api/cliente?pagina={paginaActual}&cantidadDeRegistros={cantidadDeRegistrosAMostrar}&userName={userName}&provinciaId={provinciaIdFiltro}&departamentoId={departamentoIdFiltro}");
if (!responseHttp.Error)
{
clientes = responseHttp.Response;
registrosTotales = int.Parse(responseHttp.HttpResponseMessage.Headers.GetValues("conteo").FirstOrDefault());
paginasTotales = int.Parse(responseHttp.HttpResponseMessage.Headers.GetValues("totalPaginas").FirstOrDefault());
}
}
public static void Refresh(IServerResponse msg = null, HttpResponseBase response = null)
{
if (response == null)
{
response = new HttpResponseWrapper(HttpContext.Current.Response);
}
StringBuilder sb = new StringBuilder();
sb.Append("<script type='text/javascript'> ");
sb.Append("if(window.postMessage) { if(window.opener != null) { window.opener.postMessage('{\"event\":\"reload\"");
if (msg != null)
{
sb.AppendFormat(", \"msg\": {{ \"Status\": \"{0}\", \"Message\": \"{1}\" }}", (int)msg.Status, msg.Message);
}
sb.Append("}', '*'); }");
sb.Append("else if(window.parent != null) { window.parent.postMessage('{\"event\":\"reload\"");
if (msg != null)
{
sb.AppendFormat(", \"msg\": {{ \"Status\": \"{0}\", \"Message\": \"{1}\" }}", (int)msg.Status, msg.Message);
}
sb.Append("}', '*'); }");
sb.Append("else { window.top.postMessage('{\"event\":\"reload\"");
if (msg != null)
{
sb.AppendFormat(", \"msg\": {{ \"Status\": \"{0}\", \"Message\": \"{1}\" }}", (int)msg.Status, msg.Message);
}
sb.Append("}', '*'); }");
sb.Append("} else { if(window.opener != null) { ");
if (msg != null)
{
sb.AppendFormat("window.localStorage.setItem(\"alert\", '{{ \"Status\": \"{0}\", \"Message\": \"{1}\" }}');", (int)msg.Status, msg.Message);
}
sb.Append("window.opener.location.reload(); }");
sb.Append("else if(window.parent != null) { ");
if (msg != null)
{
sb.AppendFormat("window.localStorage.setItem(\"alert\", '{{ \"Status\": \"{0}\", \"Message\": \"{1}\" }}');", (int)msg.Status, msg.Message);
}
sb.Append("window.parent.location.reload(); }");
sb.Append("else { ");
if (msg != null)
{
sb.AppendFormat("window.localStorage.setItem(\"alert\", '{{ \"Status\": \"{0}\", \"Message\": \"{1}\" }}');", (int)msg.Status, msg.Message);
}
sb.Append("window.top.location.reload(); }");
sb.Append("} </script>");
response.Write(sb.ToString());
response.End();
}
public override void Execute(System.Web.HttpContext context)
{
IHttpRequest request = new HttpRequestWrapper(ServicePath, OperationName, context.Request);
IHttpResponse response = new HttpResponseWrapper(context.Response);
HostContext.InitRequest(request, response);
if (!EndpointHost.MetadataMap[request.ServicePath].MetadataFeatureEnabled)
{
new NotFoundHttpHandler(request.ServicePath).ProcessRequest(request, response, request.OperationName);
return;
}
ProcessRequest(request, response, OperationName);
}
private void CheckForAuthFailure(object sender, EventArgs e)
{
var app = sender as HttpApplication;
var response = new HttpResponseWrapper(app.Response);
var request = new HttpRequestWrapper(app.Request);
var context = new HttpContextWrapper(app.Context);
if (true.Equals(context.Items["RequestWasNotAuthorized"]) &&
request.IsAjaxRequest())
{
response.StatusCode = 401;
response.ClearContent();
}
}
private async Task <QuoteVM> CheckDeserialize(HttpResponseWrapper <QuoteVM> httpResponseWrapper)
{
QuoteVM quoteVM = new QuoteVM();
if (httpResponseWrapper.Success)
{
quoteVM = await Deserialize <QuoteVM>(httpResponseWrapper.HttpResponseMessage, defaultJsonSerializerOptions);
}
else
{
quoteVM.Exception = await httpResponseWrapper.GetBody();
}
return(quoteVM);
}
private async Task <IdiomVM> CheckDeserialize(HttpResponseWrapper <IdiomVM> httpResponseWrapper)
{
IdiomVM idiomVM = new IdiomVM();
if (httpResponseWrapper.Success)
{
idiomVM = await Deserialize <IdiomVM>(httpResponseWrapper.HttpResponseMessage, defaultJsonSerializerOptions);
}
else
{
idiomVM.Exception = await httpResponseWrapper.GetBody();
}
return(idiomVM);
}
private async Task <VocVM> CheckDeserialize(HttpResponseWrapper <VocVM> httpResponseWrapper)
{
VocVM vocVM = new VocVM();
if (httpResponseWrapper.Success)
{
vocVM = await Deserialize <VocVM>(httpResponseWrapper.HttpResponseMessage, defaultJsonSerializerOptions);
}
else
{
vocVM.Exception = await httpResponseWrapper.GetBody();
}
return(vocVM);
}
private async Task <BranchVM> CheckDeserialize(HttpResponseWrapper <BranchVM> httpResponseWrapper)
{
BranchVM branchVM = new BranchVM();
if (httpResponseWrapper.Success)
{
branchVM = await Deserialize <BranchVM>(httpResponseWrapper.HttpResponseMessage, defaultJsonSerializerOptions);
}
else
{
branchVM.Exception = await httpResponseWrapper.GetBody();
}
return(branchVM);
}
private async Task <FiscalYearVM> CheckDeserialize(HttpResponseWrapper <FiscalYearVM> httpResponseWrapper)
{
FiscalYearVM fiscalyearVM = new FiscalYearVM();
if (httpResponseWrapper.Success)
{
fiscalyearVM = await Deserialize <FiscalYearVM>(httpResponseWrapper.HttpResponseMessage, defaultJsonSerializerOptions);
}
else
{
fiscalyearVM.Exception = await httpResponseWrapper.GetBody();
}
return(fiscalyearVM);
}
public static HttpContextBase GetFakeHttpContext(bool isCustomErrorEnabed)
{
Thread.GetDomain().SetData(".appPath", string.Empty);
Thread.GetDomain().SetData(".appVPath", string.Empty);
using (var writerRequest = new StringWriter(CultureInfo.InvariantCulture))
using (var writerResponse = new StringWriter(CultureInfo.InvariantCulture))
{
var workerRequest = new SimpleWorkerRequest("page", "", writerRequest);
var response = new HttpResponseWrapper(new HttpResponse(writerResponse));
var mock = new Mock <HttpContextWrapper>(new HttpContext(workerRequest));
mock.SetupGet(ctx => ctx.IsCustomErrorEnabled).Returns(isCustomErrorEnabed);
mock.SetupGet(ctx => ctx.Response).Returns(response);
return(mock.Object);
}
}
public override void Execute(HttpContext context)
{
var httpReq = new HttpRequestWrapper(context.Request);
var httpRes = new HttpResponseWrapper(context.Response);
var operationName = httpReq.QueryString["op"];
if (!EndpointHost.Metadata.IsVisible(httpReq, Format, operationName))
{
EndpointHost.Config.HandleErrorResponse(httpReq, httpRes, HttpStatusCode.Forbidden, "Service Not Available");
return;
}
var writer = new HtmlTextWriter(context.Response.Output);
context.Response.ContentType = "text/html";
ProcessOperations(writer, new HttpRequestWrapper(GetType().Name, context.Request));
}
