public async Task ReturnAResponseFromAnyProxyRequest()
{
// Setup your mocked stuff
var mockedProxyRequest = ProxyRequestBuilder <string[]>
.CreateBuilder("https://www.this.is/fake", HttpRequestMethod.Get)
.AppendToRoute("api/example")
.Accept("application/json")
.Build();
var mockedProxyResponse = new ProxyResponse <string[]>
{
IsSuccessfulStatusCode = true,
StatusCode = HttpStatusCode.OK,
ResponseDto = new[] { "Mocked Value From Any Request 1", "Mocked Value From Any Request 2" }
};
// Create and configure TestProxy
var testProxy = new TestProxy();
testProxy.WhenIReceiveAnyRequest <Missing, string[]>().ThenIShouldReturnThisResponse(mockedProxyResponse);
// Use the TetProxy in the class that needs it
var classThatUsesProxy = new ClassThatUsesProxy(testProxy);
var methodThatUsesProxyResponse = await classThatUsesProxy.MethodThatUsesProxyAsync(mockedProxyRequest).ConfigureAwait(false);
Assert.Equal("Mocked Value From Any Request 1", methodThatUsesProxyResponse[0]);
Assert.Equal("Mocked Value From Any Request 2", methodThatUsesProxyResponse[1]);
}
public void TestResponse_Constructor_SetsFields()
{
var expectedFields = new TestResponseFields();
var response = new ProxyResponse <TestResponseFields>(expectedFields);
Assert.AreSame(expectedFields, response.Fields);
}
public static async Task <string> HandleUrls(string content)
{
MatchCollection matches = Url_Regex.Matches(content);
foreach (Match match in matches)
{
bool bypass = false;
foreach (string s in Media_Bypass)
{
if (match.Value.ToLower().Replace("www.", "").StartsWith(s))
{
bypass = true;
content = content.Replace(match.Value, $"");
break;
}
}
if (!bypass)
{
ProxyResponse proxied = await GetProxy(match.Value);
if (Media_Types.Contains(proxied.Item.Mime_Type))
{
content = content.Replace(match.Value, $"");
}
}
}
return(content);
}
public virtual ProxyResponse <R> GetResponse <T, R>(string requestUri, T postData)
where T : class
where R : class
{
HttpResponseMessage responseMsg;
if (OperationMethod != HttpMethod.Put && OperationMethod != HttpMethod.Post)
{
responseMsg = GetResponseMessage <object>(requestUri, null);
}
else
{
responseMsg = GetResponseMessage <T>(requestUri, postData);
}
if (responseMsg.IsSuccessStatusCode)
{
if (responseMsg.Content != null)
{
var textData = responseMsg.Content.ReadAsStringAsync().Result;
if (!string.IsNullOrWhiteSpace(textData))
{
var dto = Deserialise <R>(textData);
var proxResponse = new ProxyResponse <R>(textData, dto, true, responseMsg.StatusCode, responseMsg.ReasonPhrase);
return(proxResponse);
}
return(new ProxyResponse <R>(textData, default(R), true, responseMsg.StatusCode, responseMsg.ReasonPhrase));
}
}
return(new ProxyResponse <R>(responseMsg.Content.ReadAsStringAsync().Result, default(R), false, responseMsg.StatusCode, responseMsg.ReasonPhrase));
}
public async Task <IActionResult> Create([FromBody] CreateProxyRequest proxyRequest)
{
var proxy = new Proxy
{
Address = $"{proxyRequest.Host}:{proxyRequest.Port}",
Host = proxyRequest.Host,
Port = proxyRequest.Port,
Country = proxyRequest.Country,
User = proxyRequest.User,
Password = proxyRequest.Password,
Type = proxyRequest.Type,
Status = proxyRequest.Status ?? 0,
};
await _proxyService.CreateProxyAsync(proxy);
var baseUrl = $"{HttpContext.Request.Scheme}://{HttpContext.Request.Host.ToUriComponent()}";
var locationUrl = $"{baseUrl}/{ApiRoutes.Proxies.Get.Replace("{proxyAddress}", proxy.Address)}";
var response = new ProxyResponse {
Address = proxy.Address
};
return(Created(locationUrl, response));
}
public async Task <ProxyResponse <T, ServiceErrorResponse> > Refund <T>(JObject jsonData)
{
var httpOperationResponse = await CreateApiClient(async apiClient => await apiClient.Refund(jsonData));
var result = new ProxyResponse <T, ServiceErrorResponse /*Api Standard error format*/>(httpOperationResponse);
httpOperationResponse.Dispose();
return(result);
}
public async Task ExecuteTestMethod()
{
using (var unitOfWork = new UnitOfWork())
{
ExecuteTfs syncAll = new ExecuteTfs(unitOfWork);
ProxyResponse res = await syncAll.Execute(2, 275, null);
Assert.AreEqual(res.Result, "ok");
}
}
public static async Task <ProxyResponse> GetProxy(string url)
{
string encoded_url = HttpUtility.UrlEncode(url);
string encoded_key = HttpUtility.UrlEncode(MPSConfig.Current.Api_Key);
var response = await Http.PostAsync($"{MSP_PROXY}?auth={encoded_key}&url={encoded_url}", null);
ProxyResponse data = JsonSerializer.Deserialize <ProxyResponse>(await response.Content.ReadAsStringAsync());
return(data);
}
/// <summary>
/// Adds a proxy to the stub with predicate generators containing booleans
/// </summary>
/// <param name="to">endpoint address to proxy to</param>
/// <param name="proxyMode">proxyalways, proxyonce or proxytransparent</param>
/// <param name="predicateGenerators">list of predicates that a proxy repsonse will be recorded for</param>
/// <returns></returns>
public HttpStub ReturnsProxy(Uri to, ProxyMode proxyMode, IList <MatchesPredicate <HttpBooleanPredicateFields> > predicateGenerators)
{
var fields = new ProxyResponseFields <HttpBooleanPredicateFields>
{
To = to,
Mode = proxyMode,
PredicateGenerators = predicateGenerators
};
var response = new ProxyResponse <ProxyResponseFields <HttpBooleanPredicateFields> >(fields);
return(Returns(response));
}
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////
private void WwwProxy_PostResponse(ProxyRequest request, ProxyResponse response)
{
try
{
object responseFilter = scriptEngine_.Operations.GetMember <object>(wwwProxyFilterInstance_, "post_response_filter");
object[] parameters = { request, response };
scriptEngine_.Operations.Call(responseFilter, parameters);
}
catch (Exception e)
{
debugLog_.Write("WwwProxyScripting.WwwProxy_PostResponse()", e.ToString());
}
}
public override void Handle(ProxyRequest req)
{
using (var proxyStreamSsl = new SslStream(this.ProxyStream, true))
{
if (req.KeepAlive)
{
this.ProxyStream.Write(ConnectionEstablishedKA, 0, ConnectionEstablishedKA.Length);
}
else
{
this.ProxyStream.Write(ConnectionEstablished, 0, ConnectionEstablished.Length);
}
proxyStreamSsl.AuthenticateAsServer(this.m_certificate, false, this.m_sslProtocols, false);
req.Dispose();
while (ProxyRequest.TryParse(proxyStreamSsl, true, out req))
{
using (req)
using (var resp = new ProxyResponse(proxyStreamSsl))
{
try
{
this.m_handler(new ProxyContext(req, resp));
}
catch
{
if (!resp.HeaderSent)
{
resp.Headers.Clear();
resp.StatusCode = HttpStatusCode.InternalServerError;
}
throw;
}
}
if (!req.KeepAlive)
{
break;
}
}
}
}
/// <summary>
/// Parses the raw response into a proxy response object.
/// </summary>
/// <param name="response">Raw response returned by the destionation server.</param>
/// <param name="destinationUri">Destination URI object.</param>
/// <returns>Proxy Response</returns>
public static ProxyResponse BuildProxyResponse(string response, Uri destinationUri)
{
var splitResponse = response.Split(new[] { RequestConstants.CONTENT_SEPERATOR }, 2, StringSplitOptions.None);
if (splitResponse.Length == 1)
{
var status = ParseStatusCode(splitResponse[0]);
return(ProxyResponse.Create(status, Enumerable.Empty <ProxyHeader>(), Enumerable.Empty <Cookie>(), splitResponse[0]));
}
else
{
var responseHeadersHtml = splitResponse[0];
var statusWithHeaders = responseHeadersHtml.Split(new[] { Environment.NewLine }, StringSplitOptions.None);
var statusHtml = statusWithHeaders[0];
var status = ParseStatusCode(statusHtml);
var headerList = new List <ProxyHeader>();
var cookieContainer = new CookieContainer();
var headerArray = statusWithHeaders.Skip(1);
foreach (var header in headerArray)
{
var headerPair = header.Split(new[] { ": " }, 2, StringSplitOptions.None);
if (headerPair[0].ToLower().Contains(RequestConstants.SET_COOKIE_HEADER))
{
cookieContainer.SetCookies(destinationUri, headerPair[1]);
continue;
}
headerList.Add(ProxyHeader.Create(headerPair[0], headerPair[1]));
}
return(ProxyResponse.Create(status, headerList, cookieContainer.GetCookies(destinationUri), splitResponse[1]));
}
}
public override void Handle(ProxyRequest req)
{
do
{
using (req)
using (var resp = new ProxyResponse(this.ProxyStream))
{
if (req.KeepAlive)
{
resp.Headers.Set(HttpResponseHeader.Connection, "Keep-Alive");
resp.Headers.Set(HttpResponseHeader.KeepAlive, "timeout=30");
}
this.m_handler(new ProxyContext(req, resp));
if (!req.KeepAlive)
{
break;
}
}
} while (ProxyRequest.TryParse(this.ProxyStream, false, out req));
}
private static void AssertUpdatedContact(ContactAggregate contactAggregate, ProxyResponse <Contact> updatedContact)
{
Assert.AreEqual(contactAggregate.EmailAddress, updatedContact.DataObject.EmailAddress);
Assert.AreEqual(contactAggregate.ContactId, updatedContact.DataObject.ContactId);
Assert.AreEqual(contactAggregate.FamilyName, updatedContact.DataObject.FamilyName);
Assert.AreEqual(contactAggregate.Fax, updatedContact.DataObject.Fax);
Assert.AreEqual(contactAggregate.GivenName, updatedContact.DataObject.GivenName);
Assert.AreEqual(contactAggregate.IsPartner, updatedContact.DataObject.IsPartner);
Assert.AreEqual(contactAggregate.IsContractor, updatedContact.DataObject.IsContractor);
Assert.AreEqual(contactAggregate.IsCustomer, updatedContact.DataObject.IsCustomer);
Assert.AreEqual(contactAggregate.IsPartner, updatedContact.DataObject.IsPartner);
Assert.AreEqual(contactAggregate.IsSupplier, updatedContact.DataObject.IsSupplier);
Assert.AreEqual(contactAggregate.MiddleInitials, updatedContact.DataObject.MiddleInitials);
Assert.AreEqual(contactAggregate.MobilePhone, updatedContact.DataObject.MobilePhone);
Assert.AreEqual(contactAggregate.HomePhone, updatedContact.DataObject.HomePhone);
Assert.AreEqual(contactAggregate.PositionTitle, updatedContact.DataObject.PositionTitle);
Assert.AreEqual(contactAggregate.PostalAddress.City, updatedContact.DataObject.PostalAddress.City);
Assert.AreEqual(contactAggregate.PostalAddress.Country, updatedContact.DataObject.PostalAddress.Country);
Assert.AreEqual(contactAggregate.PostalAddress.Postcode, updatedContact.DataObject.PostalAddress.Postcode);
Assert.AreEqual(contactAggregate.PostalAddress.State, updatedContact.DataObject.PostalAddress.State);
Assert.AreEqual(contactAggregate.PostalAddress.Street, updatedContact.DataObject.PostalAddress.Street);
Assert.AreEqual(contactAggregate.PrimaryPhone, updatedContact.DataObject.PrimaryPhone);
Assert.AreEqual(contactAggregate.Salutation, updatedContact.DataObject.Salutation);
}
public ProxyContext(ProxyRequest req, ProxyResponse resp)
{
this.Request = req;
this.Response = resp;
}
public override void Handle(ProxyRequest req)
{
HttpWebRequest hreq = null;
this.CancelSource.Token.Register(() =>
{
try
{
hreq.Abort();
}
catch
{
}
});
do
{
using (req)
using (var resp = new ProxyResponse(this.ProxyStream))
{
hreq = req.CreateRequest(null, true) as HttpWebRequest;
if (req.RequestBodyReader != null)
{
var hreqStream = hreq.GetRequestStream();
req.RequestBodyReader.CopyTo(hreqStream);
}
HttpWebResponse hresp = null;
try
{
hresp = hreq.GetResponse() as HttpWebResponse;
}
catch (WebException ex)
{
hresp = ex.Response as HttpWebResponse;
}
catch
{
}
if (hresp == null)
{
resp.StatusCode = HttpStatusCode.InternalServerError;
req.RequestBodyReader?.CopyTo(Stream.Null);
}
else
{
using (hresp)
{
if (req.KeepAlive)
{
resp.Headers.Set(HttpResponseHeader.Connection, "Keep-Alive");
resp.Headers.Set(HttpResponseHeader.KeepAlive, "timeout=30");
}
using (var hrespBody = hresp.GetResponseStream())
resp.FromHttpWebResponse(hresp, hrespBody);
}
}
if (!req.KeepAlive)
{
break;
}
}
} while (ProxyRequest.TryParse(this.ProxyStream, false, out req));
}
private static async Task Create(HttpContext ctx, ValourDB db,
[FromHeader] string authorization, [Required] string name,
[Required] string image_url)
{
ServerAuthToken auth = await ServerAuthToken.TryAuthorize(authorization, db);
if (auth == null)
{
ctx.Response.StatusCode = 401;
await ctx.Response.WriteAsync($"Token is invalid [token: {authorization}]");
return;
}
TaskResult nameValid = ServerPlanet.ValidateName(name);
if (!nameValid.Success)
{
ctx.Response.StatusCode = 400;
await ctx.Response.WriteAsync(nameValid.Message);
return;
}
ServerUser user = await db.Users.FindAsync(auth.User_Id);
if (!user.Valour_Staff)
{
var owned_planets = await db.Planets.CountAsync(x => x.Owner_Id == user.Id);
if (owned_planets > MAX_OWNED_PLANETS)
{
ctx.Response.StatusCode = 400;
await ctx.Response.WriteAsync("Max owned planets reached");
return;
}
}
// Image handling via proxy
ProxyResponse proxyResponse = await MPSManager.GetProxy(image_url);
bool is_media = MPSManager.Media_Types.Contains(proxyResponse.Item.Mime_Type);
if (proxyResponse.Item == null || !is_media)
{
image_url = "https://valour.gg/image.png";
}
else
{
image_url = proxyResponse.Item.Url;
}
ulong planet_id = IdManager.Generate();
// Create general category
ServerPlanetCategory category = new ServerPlanetCategory()
{
Id = IdManager.Generate(),
Name = "General",
Parent_Id = null,
Planet_Id = planet_id,
Description = "General category",
Position = 0
};
// Create general channel
ServerPlanetChatChannel channel = new ServerPlanetChatChannel()
{
Id = IdManager.Generate(),
Planet_Id = planet_id,
Name = "General",
Message_Count = 0,
Description = "General chat channel",
Parent_Id = category.Id
};
// Create default role
ServerPlanetRole defaultRole = new ServerPlanetRole()
{
Id = IdManager.Generate(),
Planet_Id = planet_id,
Position = uint.MaxValue,
Color_Blue = 255,
Color_Green = 255,
Color_Red = 255,
Name = "@everyone"
};
ServerPlanet planet = new ServerPlanet()
{
Id = planet_id,
Name = name,
Member_Count = 1,
Description = "A Valour server.",
Image_Url = image_url,
Public = true,
Owner_Id = user.Id,
Default_Role_Id = defaultRole.Id,
Main_Channel_Id = channel.Id
};
// Add planet to database
await db.Planets.AddAsync(planet);
await db.SaveChangesAsync(); // We must do this first to prevent foreign key errors
// Add category to database
await db.PlanetCategories.AddAsync(category);
// Add channel to database
await db.PlanetChatChannels.AddAsync(channel);
// Add default role to database
await db.PlanetRoles.AddAsync(defaultRole);
// Save changes
await db.SaveChangesAsync();
// Add owner to planet
await planet.AddMemberAsync(user, db);
ctx.Response.StatusCode = 200;
await ctx.Response.WriteAsJsonAsync(planet.Id);
}
internal static ProxyResponse <ContactResponse> VerifyTestContactExistsOrCreate(ContactType contactType)
{
var proxy = new ContactsProxy();
ProxyResponse <ContactResponse> response = null;
switch (contactType)
{
case Ola.RestClient.ContactType.Customer:
{
response = SearchCarl(proxy);
if (response.DataObject.Contacts.Count == 0)
{
AddCarlCustomer(proxy.WsAccessKey, proxy.FileId);
response = SearchCarl(proxy);
}
break;
}
case Ola.RestClient.ContactType.Supplier:
{
response = SearchJenny(proxy);
if (response.DataObject.Contacts.Count == 0)
{
AddJennySupplier(proxy.WsAccessKey, proxy.FileId);
response = SearchJenny(proxy);
}
break;
}
case Ola.RestClient.ContactType.Partner:
{
response = SearchBrad(proxy);
if (response.DataObject.Contacts.Count == 0)
{
AddBradPartner(proxy.WsAccessKey, proxy.FileId);
response = SearchBrad(proxy);
}
break;
}
case Ola.RestClient.ContactType.Contractor:
{
response = SearchKathy(proxy);
if (response.DataObject.Contacts.Count == 0)
{
AddKathyContractor(proxy.WsAccessKey, proxy.FileId);
response = SearchKathy(proxy);
}
break;
}
}
if (response != null)
{
Assert.IsTrue(response.DataObject.Contacts.Count >= 1, "Incorrect number of contacts found.");
}
else
{
Assert.Fail("No contact type specified to be created.");
}
return(response);
}
