public void PermanentRedirect()
{
var response = new RedirectResponse("/", RedirectResponse.RedirectType.Permanent);
response.Headers.Should().Contain("Location", "/");
response.Body.AsString().Should().BeEmpty();
response.StatusCode.Should().Be(HttpStatusCode.MovedPermanently);
}
public static async Task <IHttpResponse> PostAsync(
[Property(Name = id_token)] string idToken,
[Property(Name = state)] IRef <Authorization> authorization,
IAzureApplication application, IProvideUrl urlHelper,
IHttpRequest request, IInvokeApplication endpoints,
RedirectResponse onRedirectResponse,
ServiceUnavailableResponse onNoServiceResponse,
BadRequestResponse onBadCredentials,
GeneralConflictResponse onFailure)
{
var parameters = new Dictionary <string, string>
{
{ id_token, idToken },
{ state, authorization.id.ToString("N") },
};
var method = EastFive.Azure.Auth.Method.ByMethodName(
AzureADB2CProvider.IntegrationName, application);
return(await EastFive.Azure.Auth.Redirection.ProcessRequestAsync(method, parameters,
application, request, endpoints, urlHelper,
(redirect, accountIdMaybe) => onRedirectResponse(redirect),
(why) => onBadCredentials().AddReason($"Bad credentials:{why}"),
(why) => onNoServiceResponse().AddReason(why),
(why) => onFailure(why)));
}
public void TemporaryRedirect()
{
var response = new RedirectResponse("/", RedirectResponse.RedirectType.Temporary);
response.Headers.Should().Contain("Location", "/");
response.Body.AsString().Should().BeEmpty();
response.StatusCode.Should().Be(HttpStatusCode.TemporaryRedirect);
}
public override RedirectResponse Request(RedirectRequest redirectRequest)
{
try
{
this._action = "/createRequest";
string request = Serializer.JsonSerializer.SerializeObject(redirectRequest);
var node = JsonConvert.DeserializeXmlNode(request, "payload");
XElement createRequest = new XElement(p2p + "createRequest", XElement.Parse(node.OuterXml));
string response = this.CallWebService(createRequest);
JObject res = JObject.Parse(response);
var data = res["ns1:createRequestResponse"]["createRequestResult"];
return(JsonConvert.DeserializeObject <RedirectResponse>(data.ToString()));
}
catch (Exception ex)
{
Status status = new Status("ERROR", "WR", PlacetoPayException.ReadException(ex), (DateTime.Now).ToString("yyyy-MM-ddTHH\\:mm\\:sszzz"));
RedirectResponse redirectResponse = new RedirectResponse(null, null, status);
return(redirectResponse);
}
}
public static async Task <HttpResponseMessage> GetAsync(
[QueryParameter(Name = StatePropertyName)] string state,
[QueryParameter(Name = ClientPropertyName)] IRef <Client> clientRef,
[QueryParameter(Name = ValidationPropertyName)] string validation,
Api.Azure.AzureApplication application, UrlHelper urlHelper,
//ContentTypeResponse<Authentication> onFound,
RedirectResponse onFound,
ReferencedDocumentNotFoundResponse <Client> onInvalidClient)
{
return(await await clientRef.StorageGetAsync(
(client) =>
{
var authentication = new Authentication
{
authenticationRef = SecureGuid.Generate().AsRef <Authentication>(),
state = state,
};
return authentication.StorageCreateAsync(
(entity) =>
{
var location = urlHelper.GetLocation <Authentication>(
auth => auth.authenticationRef.AssignQueryValue(authentication.authenticationRef),
application);
return onFound(location);
},
() => throw new Exception("Secure guid not unique"));
},
() => onInvalidClient().AsTask()));
}
/**
* Creates a login failed response.
*
* @param string user
* @param string originalUser
* @param string redirect_url
* @param string loginMessage
*
* @return RedirectResponse
*/
private RedirectResponse createLoginFailedResponse(
string user, string originalUser, string redirect_url, string loginMessage)
{
// Read current user and append if possible we need to
// return the unmodified user otherwise we will leak the login name
var args = user != null
? new Dictionary <string, string>()
{
{ "user", originalUser }
}
: new Dictionary <string, string>();
if (redirect_url != null)
{
args["redirect_url"] = redirect_url;
}
var response = new RedirectResponse(
this.urlGenerator.linkToRoute("core.login.showLoginForm", args)
);
response.throttle(new Dictionary <string, string> {
{ "user", user.Substring(0, 64) }
});
this.session.set("loginMessages", new List <string>
{
"", loginMessage, ""
});
return(response);
}
public async Task <RedirectResponse> NavigatesAsync(RedirectRequest model)
{
var response = new RedirectResponse();
try
{
Item entity = await _itemQueryHandler.GetBySegmentAsync(model.Segment);
if (entity != null && !string.IsNullOrWhiteSpace(entity.OriginUrl))
{
// logging history to the DB
await _statisticCommandHandler.ExecuteAsync(new CreateStatisticCommand
{
IpAddress = model.IpAddress,
ItemId = entity.Id
});
response.IsSuccess = true;
response.OriginUrl = entity.OriginUrl;
}
}
catch (Exception exception)
{
response.IsSuccess = false;
response.Message = exception.Message;
}
return(response);
}
/// <summary>
/// Método CrearOrdenPedido.
/// </summary>
/// <returns>Task{Orders}</returns>
public async Task <Orders> CrearOrdenPedido(Orders ordenPedido, string direccionIP, string agenteUsuario)
{
System.Net.ServicePointManager.SecurityProtocol = System.Net.SecurityProtocolType.Tls12;
var gateWay = new P2P(ConfigurationManager.AppSettings["Login_Ws_PlaceToPay"],
ConfigurationManager.AppSettings["TranKey_Ws_PlaceToPay"],
new Uri(ConfigurationManager.AppSettings["Url_Ws_PlaceToPay"]), Gateway.TP_REST);
Amount montoPago = new Amount(TOTAL_PAGO);
Payment pagoPedido = new Payment(PRODUCTO, PRODUCTO, montoPago);
var tiempoExpiracionPago = DateTime.Now.AddMinutes(10);
ordenPedido.OrderStatus = await this.tiendaVirtualRepositorio.ProcesarEstadoOrden(ESTADOINICIALORDEN);
ordenPedido.Status_Id = ordenPedido.OrderStatus.Id;
ordenPedido.Created_At = DateTime.Now;
this.tiendaVirtualRepositorio.Insertar(ordenPedido);
var urlRedireccionamientoLocal = string.Format("{0}/{1}{2}", ordenPedido.UrlRaiz, "ordenes/visualizarestado/false/", ordenPedido.Id);
RedirectRequest solicitudRedireccionamiento = new RedirectRequest(pagoPedido, urlRedireccionamientoLocal, direccionIP,
agenteUsuario, tiempoExpiracionPago.ToString("s", CultureInfo.InvariantCulture));
solicitudRedireccionamiento.Buyer = new Person(string.Empty, string.Empty, ordenPedido.Customer_Name,
string.Empty, ordenPedido.Customer_Email, mobile: ordenPedido.Customer_Mobile);
solicitudRedireccionamiento.Locale = "es_CO";
solicitudRedireccionamiento.CancelUrl = urlRedireccionamientoLocal;
RedirectResponse response = gateWay.Request(solicitudRedireccionamiento);
if (response.Status.status != ESTADO_OK_CREACION_ORDENPEDIDO)
{
this.tiendaVirtualRepositorio.Eliminar(ordenPedido);
throw new Exception(response.Status.Message);
}
ordenPedido.Request_Id = response.RequestId;
ordenPedido.UrlProcesamiento = response.ProcessUrl;
this.tiendaVirtualRepositorio.Actualizar(ordenPedido);
return(await Task.FromResult(ordenPedido));
}
public async static Task <HttpResponseMessage> XlsPostAsync(EastFive.Security.SessionServer.Context context,
ContentBytes sheet, [QueryParameter] Guid integration, IDictionary <string, bool> resourceTypes,
HttpRequestMessage request, System.Web.Http.Routing.UrlHelper url,
RedirectResponse onSuccess,
NotFoundResponse onNotFound,
GeneralConflictResponse onError)
{
var sheetId = Guid.NewGuid();
return(await await context.Integrations.UpdateAsync(integration,
sheet.content.MD5HashGuid().ToString("N"),
new Dictionary <string, string>()
{
{ "resource_types", resourceTypes.SelectKeys().Join(",") },
{ "sheet_id", sheetId.ToString("N") },
},
(redirectUrl) =>
{
return EastFive.Api.Azure.Credentials.Sheets.SaveAsync(sheetId, sheet.contentType.MediaType, sheet.content, integration,
context.DataContext,
() => onSuccess(redirectUrl),
"Guid not unique".AsFunctionException <HttpResponseMessage>());
},
() => onNotFound().ToTask(),
() => onError("The provided integration ID has not been connected to an authorization.").ToTask()));
}
private static Func <NancyContext, Response> RequiresHttps(bool redirect, int?httpsPort)
{
return((ctx) =>
{
Response response = null;
var request = ctx.Request;
if (!request.Url.IsSecure)
{
if (redirect && request.Method.Equals("GET", StringComparison.OrdinalIgnoreCase))
{
var redirectUrl = request.Url.Clone();
redirectUrl.Port = httpsPort;
redirectUrl.Scheme = "https";
response = new RedirectResponse(redirectUrl.ToString());
}
else
{
response = new Response {
StatusCode = HttpStatusCode.Forbidden
};
}
}
return response;
});
}
public static async Task <HttpResponseMessage> CreateResponseAsync(
[QueryParameter(Name = "login_process_id")] Guid credentialProcessId,
[OptionalQueryParameter(Name = "ApiKeySecurity")] string apiSecurityKey,
ApiSecurity apiSecurity,
EastFive.Api.Azure.AzureApplication application, HttpRequestMessage request,
RedirectResponse redirectResponse,
ViewStringResponse viewResponse)
{
return(await await CredentialProcessDocument.FindByIdAsync(credentialProcessId,
async (document) =>
{
var providerKvp = await application.AuthorizationProviders
.Where(prov => prov.Value.GetType().FullName == document.Provider)
.FirstAsync(
value => value,
() => default(KeyValuePair <string, IProvideAuthorization>));
var provider = providerKvp.Value;
Enum.TryParse(document.Action, out AuthenticationActions action);
return await ResponseController.CreateResponse(application, provider, document.Method, action,
document.SessionId, document.AuthorizationId, document.Token, document.RefreshToken,
document.GetValuesCredential(), request.RequestUri,
document.RedirectUrl.IsNullOrWhiteSpace(
() => null,
redirUrlString => new Uri(redirUrlString)),
(redirectUri, message) => redirectResponse(redirectUri),
(code, message, reason) => viewResponse($"<html><head><title>{reason}</title></head><body>{message}</body></html>", null),
application.Telemetry);
},
() => viewResponse("", null).AsTask(),
BlackBarLabs.Persistence.Azure.StorageTables.AzureStorageRepository.CreateRepository(
EastFive.Azure.AppSettings.ASTConnectionStringKey)));
}
public IHttpResponse RegisterPost(IHttpRequest req)
{
var user = new User();
try
{
if (req.FormData["password"] != req.FormData["confirmPassword"])
{
throw new Exception("Passwords must match.");
}
user.Email = req.FormData["email"];
user.FullName = req.FormData["fullName"];
user.Password = req.FormData["password"];
user.IsAdmin = false;
}
catch
{
return(new ViewResponse(HttpStatusCode.NotAuthorized, new RegisterView(true)));
}
service.Add(user);
var response = new RedirectResponse("/");
req.Session.Add("UserId", service.LastUserId());
return(response);
}
private static Func<NancyContext, Response> RequiresHttpsOrXForwardedProto(bool redirect)
{
return ctx =>
{
Response response = null;
Request request = ctx.Request;
if (!IsSecure(request))
{
if (redirect && request.Method.Equals("GET", StringComparison.OrdinalIgnoreCase))
{
Url redirectUrl = request.Url.Clone();
redirectUrl.Scheme = "https";
redirectUrl.Port = 443;
response = new RedirectResponse(redirectUrl.ToString());
}
else
{
response = new Response {StatusCode = HttpStatusCode.Forbidden};
}
}
return response;
};
}
public async Task <IActionResult> Payment(int idOrden)
{
var order = await _ordersService.GetOrder(idOrden);
if (order == null)
{
return(NotFound());
}
Gateway gateway = _ordersService.GetGateway();
Person person = new Person(
document: order.CustomerDocument,
documentType: "CC",
name: order.CustomerName,
surname: order.CustomerName.Replace(" ", ""),
email: order.CustomerEmail,
mobile: order.CustomerMobile
);
Amount amount = new Amount(Convert.ToDouble(order.ValorOrder), currency);
PlacetoPay.Integrations.Library.CSharp.Entities.Payment payment = new PlacetoPay.Integrations.Library.CSharp.Entities.Payment($"TEST_{DateTime.Now:yyyyMMdd_hhmmss}_{order.Id}", $"Pago básico de prueba orden {order.Id} ", amount, false, person);
RedirectRequest request = new RedirectRequest(payment,
urlLocalhostDetails + order.Id.ToString(),
ipAddress,
"PlacetoPay Sandbox",
(order.CreatedAt.AddMinutes(60)).ToString(formatDate),
person,
person);
RedirectResponse response = gateway.Request(request);
if (response.IsSuccessful())
{
Models.Payment pago = new Models.Payment()
{
OrderId = order.Id,
Fecha = Convert.ToDateTime(response.Status.Date),
RequestId = Convert.ToInt32(response.RequestId),
UrlPago = response.ProcessUrl,
Status = response.Status.status,
Reason = response.Status.Reason,
Message = response.Status.Message
};
if (await _paymentsService.CreatePayment(pago) == 0)
{
// NotFound Response Status 404.
return(NotFound());
}
return(RedirectToAction("Payment", "Orders", new { idOrden = order.Id, urlPago = response.ProcessUrl }));
}
else
{
return(RedirectToAction("Details", "Orders", new { id = order.Id, message = response.Status.Message }));
}
}
public IHttpResponse Login(IHttpRequest request, LoginViewModel model)
{
if (string.IsNullOrWhiteSpace(model.Username) ||
string.IsNullOrWhiteSpace(model.Password))
{
this.AddError("You have empty fields");
return(this.FileViewResponse("/login"));
}
var success = this.users.FindUser(model.Username, model.Password);
if (success)
{
this.LoginUser(request, model.Username);
var response = new RedirectResponse("/");
return(response);
}
else
{
this.AddError("Invalid user details!");
this.ViewData["authDisplay"] = "none";
return(this.FileViewResponse("/login"));
}
}
public IPaymentResponse Charge(PaymentRequest request)
{
var dic = new Dictionary <string, object>();
dic.Add("amt_tran", request.TotalAmount.ToString());
var currency = GetCurrencyCode(request.Currency);
dic.Add("tran_currency", currency);
dic.Add("purchase_id", DataHelper.GeneratePurchaseId(request.Id));
var preferences = new Dictionary <string, string>
{
{ "success_url", PaymentHelper.GetCallbackUrl(this, nameof(CheckoutFinished), Context) },
{ "failure_url", Setting.FailureUrl }
};
dic.Add("preferences", preferences);
var result = QualpayAPI.CheckOutUrl(dic, Setting);
if (result == null)
{
return(null);
}
var redirectUrl = result["checkout_link"];
RedirectResponse res = new RedirectResponse(redirectUrl, request.Id);
return(res);
}
public void DefaultRedirect()
{
var response = new RedirectResponse("/");
response.Headers.Should().Contain("Location", "/");
response.Body.AsString().Should().BeEmpty();
response.StatusCode.Should().Be(HttpStatusCode.SeeOther);
}
public static async Task <IHttpResponse> Get(
[OptionalQueryParameter(Name = ProvideLoginMock.extraParamState)] IRefOptional <Authorization> authorizationRef,
[QueryParameter(Name = ProvideLoginMock.extraParamToken)] string token,
IAzureApplication application, IProvideUrl urlHelper,
IHttpRequest request,
RedirectResponse redirectResponse,
ServiceUnavailableResponse onNoServiceResponse,
BadRequestResponse onBadCredentials,
GeneralConflictResponse onFailure)
{
var authentication = EastFive.Azure.Auth.Method.ByMethodName(
ProvideLoginMock.IntegrationName, application);
var parameters = new Dictionary <string, string>()
{
{ ProvideLoginMock.extraParamToken, token },
};
if (authorizationRef.HasValue)
{
parameters.Add(ProvideLoginMock.extraParamState, authorizationRef.id.ToString());
}
return(await Redirection.ProcessRequestAsync(authentication,
parameters,
application,
request, urlHelper,
(redirect) =>
{
var response = redirectResponse(redirect);
return response;
},
(why) => onBadCredentials().AddReason($"Bad credentials:{why}"),
(why) => onNoServiceResponse().AddReason(why),
(why) => onFailure(why)));
}
public void Constructor_WithLocationUrl_ShouldReturnAResponseWithCorrectHeader()
{
var response = new RedirectResponse("http://google.com");
Assert.That(response.Headers.Keys, Contains.Item("Location"));
Assert.That(response.Headers["Location"], Is.EqualTo("http://google.com"));
}
public IntegratedAuthenticationModule(ILog log, IAuthCookieCreator tokenIssuer, IApiActionResponseCreator responseCreator, IWebPortalConfigurationStore webPortalConfigurationStore)
{
Get[DirectoryServicesConstants.ChallengePath] = c =>
{
if (Context.CurrentUser == null)
{
return(responseCreator.Unauthorized(Request));
}
var principal = (IOctopusPrincipal)Context.CurrentUser;
var authCookies = tokenIssuer.CreateAuthCookies(Context.Request, principal.IdentificationToken, SessionExpiry.TwentyMinutes);
var whitelist = webPortalConfigurationStore.GetTrustedRedirectUrls();
Response response;
if (Request.Query["redirectTo"].HasValue && Requests.IsLocalUrl(Request.Query["redirectTo"].Value, whitelist))
{
var redirectLocation = Request.Query["redirectTo"].Value;
response = new RedirectResponse(redirectLocation).WithCookies(authCookies);
}
else
{
if (Request.Query["redirectTo"].HasValue)
{
log.WarnFormat("Prevented potential Open Redirection attack on an NTLM challenge, to the non-local url {0}", Request.Query["redirectTo"].Value);
}
response = new RedirectResponse(Request.Url.BasePath ?? "/").WithCookies(authCookies);
}
return(response);
};
}
public static async Task <HttpResponseMessage> GetAllSecureAsync(
[QueryParameter(Name = "ApiKeySecurity")] string apiSecurityKey,
[QueryParameter(Name = "authorization")] IRef <Authorization> authorizationRef,
ApiSecurity apiSecurity,
AzureApplication application,
HttpRequestMessage request,
MultipartResponseAsync <Authorization> onContent,
RedirectResponse onSuccess,
NotFoundResponse onNotFound,
ForbiddenResponse onFailure)
{
return(await await authorizationRef.StorageGetAsync(
async authorization =>
{
return await await Method.ById(authorization.Method, application,
async method =>
{
return await await method.ParseTokenAsync(authorization.parameters, application,
(externalId, loginProvider) =>
{
return Auth.Redirection.ProcessAsync(authorization,
async updatedAuth =>
{
}, method, externalId, authorization.parameters,
Guid.NewGuid(), request.RequestUri, application, loginProvider,
(uri) => onSuccess(uri),
(why) => onFailure().AddReason(why),
application.Telemetry);
},
why => onFailure().AddReason(why).AsTask());
},
() => onFailure().AddReason("Method no longer supported").AsTask());
},
() => onNotFound().AsTask()));
}
public IntegratedAuthenticationModule(ILog log, IAuthCookieCreator tokenIssuer, IApiActionResponseCreator responseCreator, IWebPortalConfigurationStore webPortalConfigurationStore)
{
Get[DirectoryServicesConstants.ChallengePath] = c =>
{
if (Context.CurrentUser == null)
{
return(responseCreator.Unauthorized(Request));
}
var principal = (IOctopusPrincipal)Context.CurrentUser;
var tokenCookie = tokenIssuer.CreateAuthCookie(Context, principal.IdentificationToken, false);
var directoryPathResult = Request.AbsoluteVirtualDirectoryPath();
if (!directoryPathResult.IsValid)
{
return(responseCreator.BadRequest(directoryPathResult.InvalidReason));
}
var whitelist = webPortalConfigurationStore.GetTrustedRedirectUrls();
Response response;
if (Request.Query["redirectTo"].HasValue && Requests.IsLocalUrl(directoryPathResult.Path, Request.Query["redirectTo"].Value, whitelist))
{
var redirectLocation = Request.Query["redirectTo"].Value;
response = new RedirectResponse(redirectLocation).WithCookie(tokenCookie);
}
else
{
log.WarnFormat("Prevented potential Open Redirection attack on an NTLM challenge from the local instance {0} to the non-local url {1}", directoryPathResult.Path, Request.Query["redirectTo"].Value);
response = new RedirectResponse(directoryPathResult.Path ?? "/").WithCookie(tokenCookie);
}
return(response);
};
}
public void DefaultRedirect()
{
var response = new RedirectResponse("/");
response.Headers.Should().Contain("Location", "/");
response.Body.AsString().Should().BeEmpty();
response.StatusCode.Should().Be(HttpStatusCode.SeeOther);
}
public void TemporaryRedirect()
{
var response = new RedirectResponse("/", RedirectResponse.RedirectType.Temporary);
response.Headers.Should().Contain("Location", "/");
response.Body.AsString().Should().BeEmpty();
response.StatusCode.Should().Be(HttpStatusCode.TemporaryRedirect);
}
public void PermanentRedirect()
{
var response = new RedirectResponse("/", RedirectResponse.RedirectType.Permanent);
response.Headers.Should().Contain("Location", "/");
response.Body.AsString().Should().BeEmpty();
response.StatusCode.Should().Be(HttpStatusCode.MovedPermanently);
}
public void Should_add_location_header_to_the_message_when_response_contains_a_api_resource()
{
var uri = new Uri("http://example.com");
var response = new RedirectResponse(uri);
AssertExpectedStatus(response);
response.Headers.Location.ShouldEqual(uri);
}
public void Redirection_Response_Without_Status()
{
var carrierResponse = new RedirectResponse(new JObject {
{ "requestId", new Random().Next(0, 100000) },
{ "processUrl", "http://localhost/payment/process" },
});
Assert.False(carrierResponse.IsSuccessful());
}
/// <summary>
/// Logs the user out and redirects them to a URL
/// </summary>
/// <param name="context">Current context</param>
/// <param name="redirectUrl">URL to redirect to</param>
/// <returns>Nancy response</returns>
public static Response LogOutAndRedirectResponse(NancyContext context, string redirectUrl)
{
var response = new RedirectResponse(redirectUrl);
var authenticationCookie = BuildLogoutCookie(currentConfiguration);
response.AddCookie(authenticationCookie);
return(response);
}
public IHttpResponse Logout(IHttpRequest req)
{
var response = new RedirectResponse("/");
req.Cookies.ClearCookies();
req.Session.Clear();
response.CookieCollection.ClearCookies();
return(response);
}
/// <summary>
/// Redirect to provided URL.
/// </summary>
/// <param name="url">The URL to redirect.</param>
/// <param name="closeServerConnection">Close the server connection used by request if any?</param>
public void Redirect(string url, bool closeServerConnection = false)
{
var response = new RedirectResponse();
response.HttpVersion = WebSession.Request.HttpVersion;
response.Headers.AddHeader(KnownHeaders.Location, url);
response.Body = emptyData;
Respond(response, closeServerConnection);
}
/// <summary>
/// Redirect to URL.
/// </summary>
/// <param name="url"></param>
/// <returns></returns>
public async Task Redirect(string url)
{
var response = new RedirectResponse();
response.HttpVersion = WebSession.Request.HttpVersion;
response.Headers.AddHeader("Location", url);
response.Body = new byte[0];
await Respond(response);
}
public void CrearSubcribcion()
{
string email, nombre, apellido, espagador;
email = "*****@*****.**";
nombre = "Daniel";
apellido = "betancur";
espagador = "no";
try
{
Gateway gateway = CrearAutenticacion();
Amount amount = new Amount(20000.002);
string referencia = "pruebasd_" + db.Transaccions.ToList().Count();
Subscription subcripcion = new Subscription(referencia, "No hay descripcion");
Transaccion transaccion = new Transaccion();
transaccion.Id = db.Transaccions.ToList().Count() + 1;
if (nombre != null && email != null && apellido != null)
{
RedirectRequest request;
Person buyer = new Person("10000004", "CC", nombre, apellido, email);
if (espagador == "on")
{
Person payer = new Person("10000004", "CC", nombre, apellido, email);
request = new RedirectRequest(subcripcion,
"http://localhost:63562/Transacciones/returnURL" + "?" + "id=" + transaccion.Id,
"192.168.0.2",
"Mozilla/5.0 (Windows NT 6.1; Win64; x64; rv:47.0) Gecko/20100101 Firefox/47.0",
(DateTime.Now).AddMinutes(40).ToString("yyyy-MM-ddTHH\\:mm\\:sszzz"), payer, buyer);
}
else
{
request = new RedirectRequest(subcripcion,
"http://localhost:63562/Transacciones/returnURL" + "?" + "id=" + transaccion.Id,
"192.168.0.2",
"Mozilla/5.0 (Windows NT 6.1; Win64; x64; rv:47.0) Gecko/20100101 Firefox/47.0",
(DateTime.Now).AddMinutes(40).ToString("yyyy-MM-ddTHH\\:mm\\:sszzz"), null, buyer);
}
ServicePointManager.SecurityProtocol = SecurityProtocolType.Tls12;
RedirectResponse response = gateway.Request(request);
transaccion.requestId = response.RequestId;
transaccion.URL = response.ProcessUrl;
transaccion.referencia = referencia;
db.Transaccions.Add(transaccion);
db.SaveChanges();
Response.Redirect(response.ProcessUrl);
}
}
catch (Exception e)
{
Console.WriteLine("An error occurred: '{0}'", e);
}
}
public async Task Redirect(string url)
{
var response = new RedirectResponse();
response.HttpVersion = WebSession.Request.HttpVersion;
response.ResponseHeaders.Add("Location", new Models.HttpHeader("Location", url));
response.ResponseBody = Encoding.ASCII.GetBytes(string.Empty);
await Respond(response);
WebSession.Request.CancelRequest = true;
}
public void Redirection_Response_With_Status()
{
var carrierResponse = new RedirectResponse(new JObject {
{ "requestId", new Random().Next(0, 100000) },
{ "processUrl", "http://localhost/payment/process" },
{ "status", new JObject {
{ "status", "OK" }, { "reason", 2 }, { "message", "Aprobada" }, { "date", "2019-03-10T12:36:36-05:00" }
} }
});
Assert.True(carrierResponse.IsSuccessful());
}
public RedirectResponseTests()
{
Response = new RedirectResponse("https://github.com/bberak");
}
/// <summary>
/// Creates a response that sets the authentication cookie and redirects
/// the user back to where they came from.
/// </summary>
/// <param name="context">Current context</param>
/// <param name="userIdentifier">User identifier guid</param>
/// <param name="cookieExpiry">Optional expiry date for the cookie (for 'Remember me')</param>
/// <param name="fallbackRedirectUrl">Url to redirect to if none in the querystring</param>
/// <returns>Nancy response</returns>
public static Response UserLoggedInRedirectResponse(NancyContext context, Guid userIdentifier, DateTime? cookieExpiry = null, string fallbackRedirectUrl = "/")
{
var redirectUrl = fallbackRedirectUrl;
if (context.Request.Query[REDIRECT_QUERYSTRING_KEY].HasValue)
{
redirectUrl = context.Request.Query[REDIRECT_QUERYSTRING_KEY];
}
var response = new RedirectResponse(redirectUrl);
var authenticationCookie = BuildCookie(userIdentifier, cookieExpiry, currentConfiguration);
response.AddCookie(authenticationCookie);
return response;
}
/// <summary>
/// Logs the user out and redirects them to a URL
/// </summary>
/// <param name="context">Current context</param>
/// <param name="redirectUrl">URL to redirect to</param>
/// <returns>Nancy response</returns>
public static Response LogOutAndRedirectResponse(NancyContext context, string redirectUrl)
{
var response = new RedirectResponse(redirectUrl);
var authenticationCookie = BuildLogoutCookie(currentConfiguration);
response.AddCookie(authenticationCookie);
return response;
}
