//---------------------------------------------------------------------
// Constructs request to MR.
//---------------------------------------------------------------------
public static BlobsRequest MRR(Workspace w, SerializationFormatKind format, RequestVerb verb, string payload, HttpStatusCode expectedStatusCode, params string[] URI)
{
string uri = URI.Length == 0 ? LastURI : URI[0];
BlobsRequest rq = new BlobsRequest(w, format, verb, uri, expectedStatusCode);
// Specific request properties.
rq.Format = SerializationFormatKind.PlainText;
rq.ContentType = "audio/mp3";
rq.Accept = (verb == RequestVerb.Get ? "*/*" : SerializationFormatKinds.ContentTypeFromKind(format));
rq.Payload = payload;
// Append $value, if needed.
if (uri.StartsWith("$") || uri.EndsWith(")"))
{
rq.URI += "/$value";
// Expect dummy ETags from stream provider.
byte[] hash = new System.Security.Cryptography.MD5CryptoServiceProvider().ComputeHash(System.Text.Encoding.ASCII.GetBytes(rq.URI));
if ((hash[0] & 3) > 1)
{
rq.ETagHeaderExpected = true;
}
}
return(rq);
}
public static void DefaultVerify(AstoriaResponse response)
{
// special case for ETags
if (response.ActualStatusCode == System.Net.HttpStatusCode.NotModified)
{
return;
}
AstoriaRequest request = response.Request;
RequestVerb verb = request.EffectiveVerb;
switch (verb)
{
case RequestVerb.Get:
VerifyGet(response);
break;
case RequestVerb.Post:
case RequestVerb.Patch:
case RequestVerb.Put:
case RequestVerb.Delete:
// other verbs now handled by default elsewhere
break;
default:
VerifyUnknownVerb(response);
break;
}
}
//---------------------------------------------------------------------
// Constructs AstoriaRequest and sets.
//---------------------------------------------------------------------
private BlobsRequest(Workspace w, SerializationFormatKind format, RequestVerb verb, string uri, HttpStatusCode expectedStatusCode) : base(w)
{
// Common settings for MLEs and MRs.
base.IsBlobRequest = true;
base.Verb = verb;
base.ExpectedStatusCode = expectedStatusCode;
// Construct request URI.
if (uri.Contains("(*)"))
{
// Replace (*) with random key.
string relativeURI = uri.Remove(0, w.ServiceUri.Length + 1);
ResourceContainer container = w.ServiceContainer.ResourceContainers[relativeURI.Substring(0, relativeURI.IndexOf("(*)"))];
KeyExpression key = null;
try { key = w.GetRandomExistingKey(container, container.BaseType); } catch(Exception e) { AstoriaTestLog.Skip("Unable to get random key"); }
base.Query = ContainmentUtil.BuildCanonicalQuery(key);
base.URI += relativeURI.Substring(relativeURI.IndexOf("(*)") + 3);
}
else
{
// Deterministic URI.
base.URI = uri;
}
LastURI = base.URI;
}
internal Uri CreateRequestUri(RequestVerb verb, string relativeUri, IKeyValueStore <object> queryParameters = null)
{
var uriString = new Uri(BaseUri, relativeUri ?? string.Empty).ToString();
if (uriString.Contains("?"))
{
throw new ArgumentException($"The relative URI can't contain a query string. Please use \"{nameof(queryParameters)}\" or escape any '?'-characters");
}
if (queryParameters != null)
{
var separatorChar = '?';
foreach (var key in queryParameters.Keys)
{
var escapedValue = queryParameters[key]?.ToString().NormalizeNull().TryTransform(Uri.EscapeUriString);
var tokenString = $"{separatorChar}{key}={escapedValue}";
uriString += tokenString;
separatorChar = '&';
}
}
return(new Uri(uriString));
}
//---------------------------------------------------------------------
// Constructs AstoriaRequest and sets.
//---------------------------------------------------------------------
private BlobsRequest(Workspace w, SerializationFormatKind format, RequestVerb verb, string uri, HttpStatusCode expectedStatusCode) : base(w)
{
// Common settings for MLEs and MRs.
base.IsBlobRequest = true;
base.Verb = verb;
base.ExpectedStatusCode = expectedStatusCode;
// Construct request URI.
if (uri.Contains("(*)"))
{
// Replace (*) with random key.
string relativeURI = uri.Remove(0, w.ServiceUri.Length + 1);
ResourceContainer container = w.ServiceContainer.ResourceContainers[relativeURI.Substring(0, relativeURI.IndexOf("(*)"))];
KeyExpression key = null;
try { key = w.GetRandomExistingKey(container, container.BaseType); } catch (Exception e) { AstoriaTestLog.Skip("Unable to get random key"); }
base.Query = ContainmentUtil.BuildCanonicalQuery(key);
base.URI += relativeURI.Substring(relativeURI.IndexOf("(*)") + 3);
}
else
{
// Deterministic URI.
base.URI = uri;
}
LastURI = base.URI;
}
protected void ForVerbAsync(RequestVerb verb, RouteSpecification route, IEnumerable <RouteHandlerAsync> handler)
{
if (verb == RequestVerb.Options || verb == RequestVerb.Head)
{
throw new ArgumentException(String.Format("Cannot register specific handlers for verb \"{0}\"", verb), "verb");
}
_routes.Add(CreateRouteEntry(new RouteMatcher(verb, route), handler));
}
public RequestBuilder Reset()
{
mCallbacks.Clear();
mParameters.Clear();
mAuthentications.Clear();
mHeaders.Clear();
mVerb = RequestVerb.Get;
mBody = null;
return(this);
}
public WebServiceClientRequest CreateRequest(RequestVerb verb, string relativeUri, IKeyValueStore <object> queryParameters = null)
{
var innerRequest = WebRequest.CreateHttp(CreateRequestUri(verb, relativeUri, queryParameters));
innerRequest.Method = verb.ToString().ToUpper();
innerRequest.Accept = CommunicationStrategy.ContentType;
innerRequest.ContentType = $"{CommunicationStrategy.ContentType}; charset={(mConfiguration.Encoding ?? Encoding.UTF8).WebName}";
var request = new WebServiceClientRequest(mConfiguration, CommunicationStrategy, innerRequest);
return(request);
}
//---------------------------------------------------------------------
// Constructs request to MLE.
//---------------------------------------------------------------------
public static BlobsRequest MLE(Workspace w, SerializationFormatKind format, RequestVerb verb, BlobsPayload payload, HttpStatusCode expectedStatusCode, params string[] URI)
{
string uri = URI.Length == 0 ? LastURI : URI[0];
BlobsRequest rq = new BlobsRequest(w, format, verb, uri, expectedStatusCode);
// Specific request properties.
rq.Format = format;
rq.ContentType = SerializationFormatKinds.ContentTypeFromKind(format);
rq.Accept = rq.ContentType;
rq.Payload = (payload != null ? payload.ToString() : null);
return rq;
}
//---------------------------------------------------------------------
// Constructs request to MLE.
//---------------------------------------------------------------------
public static BlobsRequest MLE(Workspace w, SerializationFormatKind format, RequestVerb verb, BlobsPayload payload, HttpStatusCode expectedStatusCode, params string[] URI)
{
string uri = URI.Length == 0 ? LastURI : URI[0];
BlobsRequest rq = new BlobsRequest(w, format, verb, uri, expectedStatusCode);
// Specific request properties.
rq.Format = format;
rq.ContentType = SerializationFormatKinds.ContentTypeFromKind(format);
rq.Accept = rq.ContentType;
rq.Payload = (payload != null ? payload.ToString() : null);
return(rq);
}
public static UpdatePayloadBuilder CreateUpdatePayloadBuilder(Workspace w, SerializationFormatKind format, RequestVerb requestVerb)
{
switch (format)
{
case SerializationFormatKind.Atom:
case SerializationFormatKind.Default:
case SerializationFormatKind.PlainXml:
return new AtomUpdatePayloadBuilder(w, requestVerb);
case SerializationFormatKind.JSON:
return new JsonUpdatePayloadBuilder(w, requestVerb);
default:
throw new ArgumentException("Could not create a payload builder for format: " + format.ToString());
}
}
public RouteMatcher(RequestVerb verb, RouteSpecification route)
{
if (route == null)
{
throw new ArgumentNullException("route");
}
this.Verb = verb;
_routeString = SanatizeRoute(route.ResourceRoute);
_resourceRegex = new Regex(BuildRouteRegex(_routeString), RegexOptions.Singleline | RegexOptions.IgnoreCase | RegexOptions.Compiled);
_paramMatches = route.UrlParameters;
_hasUrlParameters = _paramMatches != null && _paramMatches.Length > 0;
this.SortOrder = (_routeString.Split('/').Length + 1) + (_hasUrlParameters ? _paramMatches.Length * 3 : 0);
}
private string GetBookmarkName(NativeActivityContext context)
{
var name = RequestVerb.Get(context);
if (!String.IsNullOrEmpty(name))
{
return(name);
}
var attribute = (DefaultRequestVerbAttribute)GetType().GetCustomAttributes(typeof(DefaultRequestVerbAttribute), false).FirstOrDefault(); //GetAttribute<DefaultRequestVerbAttribute>();
if (attribute == null)
{
throw new InvalidOperationException("Request verb not specified in workflow and no DefaultRequestVerbAttribute provided for " + GetType().Name);
}
return(attribute.Verb);
}
public RequestOp(
long timeMs,
Type type,
RequestVerb verb,
object?id,
object?value = null,
int?freshnessSeconds = null,
object?criteria = null,
string?key = null
)
{
TimeMs = timeMs;
Type = type;
Verb = verb;
Id = id;
Value = value;
FreshnessSeconds = freshnessSeconds;
Criteria = criteria;
Key = key;
}
//---------------------------------------------------------------------
// Constructs request with $ref. Assumes parent(*)/child URI format.
//---------------------------------------------------------------------
public static BlobsRequest LNK(Workspace w, SerializationFormatKind format, RequestVerb verb, string payload, HttpStatusCode expectedStatusCode, params string[] URI)
{
string uri = (URI.Length == 0 ? LastURI : URI[0]);
BlobsRequest rq = new BlobsRequest(w, format, verb, uri, expectedStatusCode);
// Specific request properties.
rq.Format = format;
rq.ContentType = SerializationFormatKinds.ContentTypeFromKind(format == SerializationFormatKind.JSON ? SerializationFormatKind.JSON : SerializationFormatKind.PlainXml);
rq.Accept = rq.ContentType;
// Adjust link in payload, if needed.
if (!string.IsNullOrEmpty(payload))
{
rq.Payload = string.Format(format == SerializationFormatKind.JSON ?
@"{{""odata.id"": ""{0}"" }}" :
@"<ref xmlns='http://docs.oasis-open.org/odata/ns/metadata' id=""{0}"" />",
payload);
}
return(rq);
}
internal RequestBuilder([NotNull] WebServiceClient client, [NotNull] string requestPath)
{
if (client == null)
{
throw new ArgumentNullException(nameof(client));
}
if (requestPath.NormalizeNull() == null)
{
throw new ArgumentNullException(nameof(requestPath));
}
mHeaders = new MemoryKeyValueStore <string>();
mParameters = new MemoryKeyValueStore();
mAuthentications = new List <ServiceClientAuthentication>();
mCallbacks = new List <Tuple <Func <IWebResult, bool>, Action <WebServiceClientResponse> > >();
mInterceptors = new List <Func <RequestInterceptorContext, Task> >();
mClient = client;
mRequestPath = requestPath;
mVerb = RequestVerb.Get;
}
internal bool TryGetRouteMatch(RequestVerb verb, string uri, IValueBag parameters, out Route data)
{
data = null;
// Check the verb
if (verb != this.Verb)
{
return(false);
}
// Check the route
var match = _resourceRegex.Match(uri);
// Route didnt match, exit early
if (!match.Success)
{
return(false);
}
// Check any required parameters
if (_hasUrlParameters)
{
string value;
// Try each parameter match and if any fail, exit
foreach (var paramMatch in _paramMatches)
{
// Check if the key exists and the parameter value matches the specification
if (!parameters.TryGetValue(paramMatch.Key, out value) || !paramMatch.ValueMatches(value))
{
// Key does not exist
return(false);
}
}
}
// We made it, route matches all requirements
data = new Route(match);
return(true);
}
//---------------------------------------------------------------------
// Constructs request to MR.
//---------------------------------------------------------------------
public static BlobsRequest MRR(Workspace w, SerializationFormatKind format, RequestVerb verb, string payload, HttpStatusCode expectedStatusCode, params string[] URI)
{
string uri = URI.Length == 0 ? LastURI : URI[0];
BlobsRequest rq = new BlobsRequest(w, format, verb, uri, expectedStatusCode);
// Specific request properties.
rq.Format = SerializationFormatKind.PlainText;
rq.ContentType = "audio/mp3";
rq.Accept = (verb == RequestVerb.Get ? "*/*" : SerializationFormatKinds.ContentTypeFromKind(format));
rq.Payload = payload;
// Append $value, if needed.
if (uri.StartsWith("$") || uri.EndsWith(")"))
{
rq.URI += "/$value";
// Expect dummy ETags from stream provider.
byte[] hash = new System.Security.Cryptography.MD5CryptoServiceProvider().ComputeHash(System.Text.Encoding.ASCII.GetBytes(rq.URI));
if ((hash[0] & 3) > 1)
rq.ETagHeaderExpected = true;
}
return rq;
}
/// <summary>
/// Helper method for calling identity
/// </summary>
/// <param name="identityRestCall">The call you want to make</param>
/// <param name="postParams">The params to be sent with this request</param>
/// <param name="cookies">any cookies you want to add to the request</param>
/// <param name="verb">The type of request you want to make</param>
/// <returns>http response for the call</returns>
static public HttpWebResponse CallIdentityRestAPI(string identityRestCall, Dictionary<string, string> postParams, List<Cookie> cookies, RequestVerb verb)
{
// Setup the params
string urlParams = "";
if (postParams != null)
{
foreach (KeyValuePair<string, string> s in postParams)
{
if (urlParams.Length > 0)
{
urlParams += "&";
}
urlParams += s.Key + "=" + s.Value;
}
}
// Create the full URL
string fullURI = _IdentityServerBaseUri;
if (!identityRestCall.StartsWith("/"))
{
fullURI += "/" + identityRestCall;
}
else
{
fullURI += identityRestCall;
}
// Console out the params we're using
Console.WriteLine();
Console.WriteLine("Identity URL : " + fullURI);
Console.WriteLine("Params : " + urlParams);
// If we're not doing a post request, then add the params to the url
if (verb == RequestVerb.GET)
{
fullURI += "?" + urlParams;
}
Uri URL = new Uri(fullURI);
// Create the new request object
HttpWebRequest webRequest = (HttpWebRequest)HttpWebRequest.Create(URL);
switch (verb)
{
case RequestVerb.DELETE:
webRequest.Method = "DELETE";
break;
case RequestVerb.PUT:
webRequest.Method = "PUT";
break;
case RequestVerb.POST:
webRequest.Method = "POST";
break;
default:
webRequest.Method = "GET";
break;
}
Console.WriteLine("Method : " + webRequest.Method);
webRequest.Accept = "application/xml";
webRequest.Timeout = 1000 * 400;
webRequest.CookieContainer = new CookieContainer();
if (cookies != null)
{
Console.WriteLine("Cookies...");
foreach (Cookie c in cookies)
{
try
{
webRequest.CookieContainer.Add(c);
//webRequest.Headers.Add("Cookie",c.Name + "=" + c.Value);
Console.WriteLine(c.Name + " - " + c.Value);
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
}
}
}
// Add the cert for the request
X509Store store = new X509Store("My", StoreLocation.LocalMachine);
store.Open(OpenFlags.ReadOnly | OpenFlags.OpenExistingOnly);
X509Certificate _certificate = null;
bool gotDevCert = false;
for (int i = 0; i <= 1 && !gotDevCert; i++)
{
_certificate = store.Certificates.Find(X509FindType.FindBySubjectName, _webServiceCertificationName, false)[i];
gotDevCert = _certificate.Subject.ToLower().Contains("cn=" + _webServiceCertificationName.ToLower() + ",");
}
webRequest.ClientCertificates.Add(_certificate);
// Now setup the correct method depending on the post flag
if (verb != RequestVerb.GET)
{
webRequest.ContentType = "application/x-www-form-urlencoded;charset=UTF-8";
// Write the params to the body of the request
UTF8Encoding encoding = new UTF8Encoding();
byte[] bytes = encoding.GetBytes(urlParams);
webRequest.ContentLength = bytes.Length;
try
{
Stream requestBody = webRequest.GetRequestStream();
requestBody.Write(bytes, 0, bytes.Length);
requestBody.Close();
}
catch (Exception ex)
{
Console.WriteLine("Failed to get read stream - " + ex.Message);
throw (ex);
}
}
// Now do the request itself.
HttpWebResponse response = null;
try
{
response = (HttpWebResponse)webRequest.GetResponse();
if (response != null)
{
Console.WriteLine("Response code : " + response.StatusCode.ToString());
}
else
{
Console.WriteLine("No Response object");
}
}
catch (WebException ex)
{
_error = ex.Message + "\n";
if (ex.Response != null)
{
StreamReader reader = new StreamReader(ex.Response.GetResponseStream(), Encoding.UTF8);
_error += reader.ReadToEnd();
}
Console.WriteLine(_error);
Assert.Fail("Failed calling Identity Rest Interface with '" + identityRestCall + "' request. Error = " + _error);
}
Console.WriteLine("Response cookies...");
foreach (Cookie c in response.Cookies)
{
Console.WriteLine(c.Name + " - " + c.Value);
}
Console.WriteLine();
return response;
}
private static void UpdateErrorState(ContainmentQuery query, ContainmentQuerySuffix suffix, RequestVerb verb)
{
if (!MethodAllowed(query, suffix, verb))
{
// TODO: set error identifier?
query.ExpectedStatusCode = HttpStatusCode.MethodNotAllowed;
switch (verb)
{
case RequestVerb.Post:
query.ExpectedErrorIdentifier = SystemDataServicesResourceIdentifiers.BadRequest_InvalidUriForPostOperation;
UriQueryBuilder builder = new UriQueryBuilder(query.Workspace, query.Workspace.ServiceEndPoint);
query.ExpectedErrorArgs = new object[] { builder.Build(query.Query) };
break;
}
}
}
protected void ForVerb(RequestVerb verb, RouteSpecification route, IEnumerable <RouteHandler> handlers)
{
var asyncHandlers = handlers.Select(h => new RouteHandlerAsync((r, d) => Task.FromResult <TResponse>(h(r, d))));
_routes.Add(CreateRouteEntry(new RouteMatcher(verb, route), asyncHandlers));
}
public static bool IsSafeLinkOperation(RequestVerb verb, ResourceContainer container, ResourceProperty property)
{
if (!property.IsNavigation)
{
return(false);
}
if (property.Facets.UnsafeLinkOperations.Contains(verb))
{
return(false);
}
if (verb == RequestVerb.Get)
{
return(true);
}
// astoria-level check
switch (verb)
{
case RequestVerb.Patch:
case RequestVerb.Put:
if (property.OtherAssociationEnd.Multiplicity == Multiplicity.Many)
{
return(false);
}
break;
case RequestVerb.Post:
if (property.OtherAssociationEnd.Multiplicity != Multiplicity.Many)
{
return(false);
}
break;
case RequestVerb.Delete:
if (property.OtherAssociationEnd.Multiplicity == Multiplicity.One)
{
return(false);
}
break;
default:
return(false);
}
//// EF/DB level check
if (container.Workspace.Database != null)
{
// would changing this nav-prop affect any foreign keys
List <NodeProperty> affectedProperties = new List <NodeProperty>();
foreach (NodeProperty p in property.ResourceType.Properties)
{
if (!p.ForeignKeys.Any())
{
continue;
}
ResourceType relatedType = (p.ForeignKeys.First().PrimaryKey.Properties.First() as ResourceProperty).ResourceType;
if (relatedType == property.OtherAssociationEnd.ResourceType)
{
affectedProperties.Add(p);
}
}
foreach (NodeProperty p in property.OtherAssociationEnd.ResourceType.Properties)
{
if (!p.ForeignKeys.Any())
{
continue;
}
ResourceType relatedType = (p.ForeignKeys.First().PrimaryKey.Properties.First() as ResourceProperty).ResourceType;
if (relatedType == property.ResourceType)
{
affectedProperties.Add(p);
}
}
// can't change primary key by changing nav-prop
if (affectedProperties.Any(p => p.PrimaryKey != null))
{
return(false);
}
if (verb == RequestVerb.Delete && affectedProperties.Any(p => !p.Facets.Nullable))
{
return(false);
}
if (container.Workspace.DataLayerProviderKind == DataLayerProviderKind.Edm && (verb == RequestVerb.Put || verb == RequestVerb.Patch))
{
// EF: updating self-reference causes a null-reference in the mapping layer
if (property.Type is ResourceType && property.OtherAssociationEnd.ResourceType == property.ResourceType)
{
return(false);
}
}
}
return(true);
}
public static bool Valid(ContainmentQuerySuffix suffix, RequestVerb verb)
{
return map[suffix].Contains(verb);
}
private static bool MethodAllowed(ContainmentQuery query, ContainmentQuerySuffix suffix, RequestVerb verb)
{
if (query.SetExpected)
{
if (suffix != ContainmentQuerySuffix.None)
{
AstoriaTestLog.FailAndThrow("Only the NONE suffix can be used when a set is expected");
}
return verb == RequestVerb.Get || verb == RequestVerb.Post;
}
else
{
return VerbMap.Valid(suffix, verb);
}
}
public static bool IsSafeOperation(RequestVerb verb, ResourceContainer container)
{
if (container is ServiceOperation)
{
ServiceOperation op = container as ServiceOperation;
return(verb == op.Verb && verb == RequestVerb.Get); //for now POST always means insert
}
if (container.Name == "Invoices" && (container.Workspace.DataLayerProviderKind == DataLayerProviderKind.NonClr || container.Workspace.DataLayerProviderKind == DataLayerProviderKind.InMemoryLinq))
{
return(false);
}
switch (verb)
{
case RequestVerb.Delete:
if (container.Name.Equals("DataKey_Bit"))
{
return(false);
}
if (container.Name.Equals("ComputerDetails"))
{
return(false);
}
if (!container.ResourceTypes.All(type => IsSafeOperation(verb, container, type)))
{
return(false);
}
break;
case RequestVerb.Post:
if (container.Name.Equals("Shippers"))
{
return(false);
}
if (container.Name.Equals("Employees"))
{
return(false);
}
if (container.Name.Equals("Order_Details"))
{
return(false);
}
if (container.Name.Equals("ProjectSet"))
{
return(false);
}
if (container.Name.Equals("DataKey_Bit"))
{
return(false);
}
if (container.Name.Equals("Vehicles"))
{
return(false);
}
if (container.Name.Equals("People"))
{
return(false);
}
if (container.Name.Equals("Computers"))
{
return(false);
}
if (container.Name.Equals("Workers"))
{
return(false);
}
if (!container.ResourceTypes.All(type => IsSafeOperation(verb, container, type)))
{
return(false);
}
break;
}
return(true);
}
//---------------------------------------------------------------------
// Constructs request with $ref. Assumes parent(*)/child URI format.
//---------------------------------------------------------------------
public static BlobsRequest LNK(Workspace w, SerializationFormatKind format, RequestVerb verb, string payload, HttpStatusCode expectedStatusCode, params string[] URI)
{
string uri = (URI.Length == 0 ? LastURI : URI[0]);
BlobsRequest rq = new BlobsRequest(w, format, verb, uri, expectedStatusCode);
// Specific request properties.
rq.Format = format;
rq.ContentType = SerializationFormatKinds.ContentTypeFromKind(format == SerializationFormatKind.JSON ? SerializationFormatKind.JSON : SerializationFormatKind.PlainXml);
rq.Accept = rq.ContentType;
// Adjust link in payload, if needed.
if (!string.IsNullOrEmpty(payload))
{
rq.Payload = string.Format(format == SerializationFormatKind.JSON ?
@"{{""odata.id"": ""{0}"" }}" :
@"<ref xmlns='http://docs.oasis-open.org/odata/ns/metadata' id=""{0}"" />",
payload);
}
return rq;
}
private static void UpdateErrorState(ContainmentQuery query, ContainmentQuerySuffix suffix, RequestVerb verb)
{
if (!MethodAllowed(query, suffix, verb))
{
// TODO: set error identifier?
query.ExpectedStatusCode = HttpStatusCode.MethodNotAllowed;
switch (verb)
{
case RequestVerb.Post:
query.ExpectedErrorIdentifier = SystemDataServicesResourceIdentifiers.BadRequest_InvalidUriForPostOperation;
UriQueryBuilder builder = new UriQueryBuilder(query.Workspace, query.Workspace.ServiceEndPoint);
query.ExpectedErrorArgs = new object[] { builder.Build(query.Query) };
break;
}
}
}
public ModifiedVerbRequest(IRequest request, RequestVerb verb)
{
_request = request;
_verb = verb;
}
public static bool AppendSuffix(this ContainmentQuery query, ContainmentQuerySuffix suffix, RequestVerb verb)
{
UpdateErrorState(query, suffix, verb);
return UpdateQuery(query, suffix, verb);
}
static VerbMap()
{
map = new Dictionary <ContainmentQuerySuffix, RequestVerb[]>();
Array suffixes = Enum.GetValues(typeof(ContainmentQuerySuffix));
foreach (ContainmentQuerySuffix suffix in suffixes)
{
RequestVerb[] verbs;
#region fill the array
switch (suffix)
{
// entities
case ContainmentQuerySuffix.None:
case ContainmentQuerySuffix.SingleNavigation:
case ContainmentQuerySuffix.SingleNavigationTwice:
verbs = new RequestVerb[]
{
RequestVerb.Get,
RequestVerb.Delete,
RequestVerb.Patch,
RequestVerb.Put
};
break;
// sets
case ContainmentQuerySuffix.MultipleNavigation:
verbs = new RequestVerb[]
{
RequestVerb.Get,
RequestVerb.Post
};
break;
// values
case ContainmentQuerySuffix.SimpleType:
verbs = new RequestVerb[]
{
RequestVerb.Get,
RequestVerb.Patch,
RequestVerb.Put
};
break;
// $ref single - not sure about these
case ContainmentQuerySuffix.LinkedSingleNavigation:
verbs = new RequestVerb[]
{
RequestVerb.Get,
RequestVerb.Patch,
RequestVerb.Put
};
break;
// $ref multiple - not sure about these
case ContainmentQuerySuffix.LinkedMultipleNavigation:
verbs = new RequestVerb[]
{
RequestVerb.Get,
RequestVerb.Patch,
RequestVerb.Put
};
break;
default:
verbs = new RequestVerb[] { };
break;
}
#endregion
map[suffix] = verbs;
}
}
public RequestBuilder Verb(RequestVerb verb)
{
mVerb = verb;
return(this);
}
public static bool Valid(ContainmentQuerySuffix suffix, RequestVerb verb)
{
return(map[suffix].Contains(verb));
}
private static bool UpdateQuery(ContainmentQuery query, ContainmentQuerySuffix suffix, RequestVerb verb)
{
switch (suffix)
{
case ContainmentQuerySuffix.SingleNavigationTwice:
return(ApplyNavigationProperties(query, Multiplicity.One, Multiplicity.One));
case ContainmentQuerySuffix.SingleNavigation:
return(ApplyNavigationProperties(query, Multiplicity.One));
case ContainmentQuerySuffix.MultipleNavigation:
return(ApplyNavigationProperties(query, Multiplicity.Many));
case ContainmentQuerySuffix.LinkedSingleNavigation:
return(ApplyLink(query, Multiplicity.One));
case ContainmentQuerySuffix.LinkedMultipleNavigation:
return(ApplyLink(query, Multiplicity.Many));
case ContainmentQuerySuffix.SimpleType:
return(ApplySimpleType(query));
case ContainmentQuerySuffix.None:
return(true);
default:
return(false);
}
}
public static bool AppendSuffix(this ContainmentQuery query, ContainmentQuerySuffix suffix, RequestVerb verb)
{
UpdateErrorState(query, suffix, verb);
return(UpdateQuery(query, suffix, verb));
}
static VerbMap()
{
map = new Dictionary<ContainmentQuerySuffix, RequestVerb[]>();
Array suffixes = Enum.GetValues(typeof(ContainmentQuerySuffix));
foreach (ContainmentQuerySuffix suffix in suffixes)
{
RequestVerb[] verbs;
#region fill the array
switch (suffix)
{
// entities
case ContainmentQuerySuffix.None:
case ContainmentQuerySuffix.SingleNavigation:
case ContainmentQuerySuffix.SingleNavigationTwice:
verbs = new RequestVerb[]
{
RequestVerb.Get,
RequestVerb.Delete,
RequestVerb.Patch,
RequestVerb.Put
};
break;
// sets
case ContainmentQuerySuffix.MultipleNavigation:
verbs = new RequestVerb[]
{
RequestVerb.Get,
RequestVerb.Post
};
break;
// values
case ContainmentQuerySuffix.SimpleType:
verbs = new RequestVerb[]
{
RequestVerb.Get,
RequestVerb.Patch,
RequestVerb.Put
};
break;
// $ref single - not sure about these
case ContainmentQuerySuffix.LinkedSingleNavigation:
verbs = new RequestVerb[]
{
RequestVerb.Get,
RequestVerb.Patch,
RequestVerb.Put
};
break;
// $ref multiple - not sure about these
case ContainmentQuerySuffix.LinkedMultipleNavigation:
verbs = new RequestVerb[]
{
RequestVerb.Get,
RequestVerb.Patch,
RequestVerb.Put
};
break;
default:
verbs = new RequestVerb[] { };
break;
}
#endregion
map[suffix] = verbs;
}
}
public static bool IsSafeLinkOperation(RequestVerb verb, ResourceContainer container, ResourceProperty property)
{
if (!property.IsNavigation)
return false;
if (property.Facets.UnsafeLinkOperations.Contains(verb))
return false;
if (verb == RequestVerb.Get)
return true;
// astoria-level check
switch(verb)
{
case RequestVerb.Patch:
case RequestVerb.Put:
if (property.OtherAssociationEnd.Multiplicity == Multiplicity.Many)
return false;
break;
case RequestVerb.Post:
if (property.OtherAssociationEnd.Multiplicity != Multiplicity.Many)
return false;
break;
case RequestVerb.Delete:
if (property.OtherAssociationEnd.Multiplicity == Multiplicity.One)
return false;
break;
default:
return false;
}
//// EF/DB level check
if (container.Workspace.Database != null)
{
// would changing this nav-prop affect any foreign keys
List<NodeProperty> affectedProperties = new List<NodeProperty>();
foreach (NodeProperty p in property.ResourceType.Properties)
{
if (!p.ForeignKeys.Any())
continue;
ResourceType relatedType = (p.ForeignKeys.First().PrimaryKey.Properties.First() as ResourceProperty).ResourceType;
if (relatedType == property.OtherAssociationEnd.ResourceType)
affectedProperties.Add(p);
}
foreach (NodeProperty p in property.OtherAssociationEnd.ResourceType.Properties)
{
if (!p.ForeignKeys.Any())
continue;
ResourceType relatedType = (p.ForeignKeys.First().PrimaryKey.Properties.First() as ResourceProperty).ResourceType;
if (relatedType == property.ResourceType)
affectedProperties.Add(p);
}
// can't change primary key by changing nav-prop
if (affectedProperties.Any(p => p.PrimaryKey != null))
return false;
if (verb == RequestVerb.Delete && affectedProperties.Any(p => !p.Facets.Nullable))
return false;
if (container.Workspace.DataLayerProviderKind == DataLayerProviderKind.Edm && (verb == RequestVerb.Put || verb == RequestVerb.Patch))
{
// EF: updating self-reference causes a null-reference in the mapping layer
if (property.Type is ResourceType && property.OtherAssociationEnd.ResourceType == property.ResourceType)
return false;
}
}
return true;
}
private static bool UpdateQuery(ContainmentQuery query, ContainmentQuerySuffix suffix, RequestVerb verb)
{
switch (suffix)
{
case ContainmentQuerySuffix.SingleNavigationTwice:
return ApplyNavigationProperties(query, Multiplicity.One, Multiplicity.One);
case ContainmentQuerySuffix.SingleNavigation:
return ApplyNavigationProperties(query, Multiplicity.One);
case ContainmentQuerySuffix.MultipleNavigation:
return ApplyNavigationProperties(query, Multiplicity.Many);
case ContainmentQuerySuffix.LinkedSingleNavigation:
return ApplyLink(query, Multiplicity.One);
case ContainmentQuerySuffix.LinkedMultipleNavigation:
return ApplyLink(query, Multiplicity.Many);
case ContainmentQuerySuffix.SimpleType:
return ApplySimpleType(query);
case ContainmentQuerySuffix.None:
return true;
default:
return false;
}
}
public static AstoriaRequest BuildRandomRequest(Workspace workspace, RequestVerb verb, SerializationFormatKind format)
{
IEnumerable<ResourceContainer> safeContainers =
workspace.ServiceContainer.ResourceContainers
.Where(c => IsSafeOperation(verb, c));
if (verb != RequestVerb.Get)
safeContainers = safeContainers.Where(c => c.ResourceTypes.Any(t => IsSafeOperation(verb, c, t)));
fxList<ResourceContainer> containers = new fxList<ResourceContainer>(safeContainers);
if (!containers.Any())
return null;
AstoriaRequest request = null;
while (request == null && containers.Any())
{
ResourceContainer container = null;
ResourceType type = null;
KeyExpression key = null;
while (container == null && containers.Any())
{
container = containers.Choose();
if (verb == RequestVerb.Get)
{
key = workspace.GetRandomExistingKey(container);
if (key == null)
{
containers.Remove(container);
container = null;
}
}
else
{
fxList<ResourceType> types = new fxList<ResourceType>(container.ResourceTypes.Where(t => IsSafeOperation(verb, container, t)));
if (!types.Any())
{
containers.Remove(container);
container = null;
}
if (verb != RequestVerb.Delete)
type = types.Choose();
else
{
while (key == null && types.Any())
{
type = types.Choose();
key = workspace.GetRandomExistingKey(container, type);
if (key == null)
types.Remove(type);
}
if (key == null)
{
containers.Remove(container);
container = null;
}
}
}
}
// if we ran out of containers before finding one that would work
//
if (container == null)
return null;
// if the Build___ method returns null, we'll come back around with a different container/key
//
switch (verb)
{
case RequestVerb.Get:
request = BuildGet(workspace, key, HttpStatusCode.OK, format);
break;
case RequestVerb.Post:
request = BuildInsert(workspace, container, type, HttpStatusCode.Created, format);
break;
case RequestVerb.Put:
case RequestVerb.Patch:
request = BuildUpdate(workspace, container, type, (verb == RequestVerb.Put), HttpStatusCode.NoContent, format);
break;
case RequestVerb.Delete:
request = BuildDelete(workspace, key, HttpStatusCode.NoContent, format);
break;
default:
throw new ArgumentException("Unsupported verb: " + verb.ToString());
}
}
// might be null, but we did our best
//
return request;
}
public JsonUpdatePayloadBuilder(Workspace workspace, RequestVerb requestVerb)
: base(workspace, requestVerb)
{
_typeStack = new Stack <string>(8);
}
public AstoriaRequest CreateRequest(ExpNode query, ResourceBodyTree updateTree, RequestVerb operation)
{
AstoriaRequest request = new AstoriaRequest(this);
request.Verb = operation;
request.Query = query as QueryNode;
request.UpdateTree = updateTree;
PrepareRequest(request);
return request;
}
public UpdatePayloadBuilder(Workspace workspace, RequestVerb requestVerb)
{
_workspace = workspace;
_requestVerb = requestVerb;
}
public static string ToHttpMethod(this RequestVerb verb)
{
return(verb.ToString().ToUpperInvariant());
}
public static bool IsSafeOperation(RequestVerb verb, ResourceContainer container, ResourceType type)
{
switch (verb)
{
case RequestVerb.Delete:
if (!type.IsInsertable)
{
return(false);
}
if (type.Associations.Any())
{
return(false);
}
if (type.Properties.Any(p => p.Facets.ConcurrencyModeFixed && p.Facets.IsStoreBlob))
{
return(false);
}
return(true);
case RequestVerb.Patch:
if (type.Facets.AbstractType)
{
return(false);
}
if (!type.IsInsertable)
{
return(false);
}
if (type.IsAssociationEntity)
{
return(false);
}
if (type.Properties.Any(p => p.Facets.ConcurrencyModeFixed && p.Facets.IsStoreBlob))
{
return(false);
}
return(true);
case RequestVerb.Put:
if (type.Facets.AbstractType)
{
return(false);
}
if (!type.IsInsertable)
{
return(false);
}
if (type.IsAssociationEntity)
{
return(false);
}
if (type.Properties.Any(p => p.Facets.IsIdentity))
{
return(false);
}
if (type.Properties.Any(p => p.Facets.ConcurrencyModeFixed && p.Facets.IsStoreBlob))
{
return(false);
}
return(true);
case RequestVerb.Post:
if (type.Facets.AbstractType)
{
return(false);
}
if (!type.IsInsertable)
{
return(false);
}
if (type.IsAssociationEntity)
{
return(false);
}
if (type.IsChildRefEntity)
{
return(false);
}
if (type.Associations.Any(ra => ra.Ends.Any(end => end.ResourceType.IsAssociationEntity)))
{
return(false);
}
return(true);
}
return(true);
}
protected void ForVerb(RequestVerb requestVerb, string route, RouteHandler[] handler)
{
this.ForVerb(requestVerb, new RouteSpecification(route), handler);
}
public static AstoriaRequest BuildRandomRequest(Workspace workspace, RequestVerb verb, SerializationFormatKind format)
{
IEnumerable <ResourceContainer> safeContainers =
workspace.ServiceContainer.ResourceContainers
.Where(c => IsSafeOperation(verb, c));
if (verb != RequestVerb.Get)
{
safeContainers = safeContainers.Where(c => c.ResourceTypes.Any(t => IsSafeOperation(verb, c, t)));
}
fxList <ResourceContainer> containers = new fxList <ResourceContainer>(safeContainers);
if (!containers.Any())
{
return(null);
}
AstoriaRequest request = null;
while (request == null && containers.Any())
{
ResourceContainer container = null;
ResourceType type = null;
KeyExpression key = null;
while (container == null && containers.Any())
{
container = containers.Choose();
if (verb == RequestVerb.Get)
{
key = workspace.GetRandomExistingKey(container);
if (key == null)
{
containers.Remove(container);
container = null;
}
}
else
{
fxList <ResourceType> types = new fxList <ResourceType>(container.ResourceTypes.Where(t => IsSafeOperation(verb, container, t)));
if (!types.Any())
{
containers.Remove(container);
container = null;
}
if (verb != RequestVerb.Delete)
{
type = types.Choose();
}
else
{
while (key == null && types.Any())
{
type = types.Choose();
key = workspace.GetRandomExistingKey(container, type);
if (key == null)
{
types.Remove(type);
}
}
if (key == null)
{
containers.Remove(container);
container = null;
}
}
}
}
// if we ran out of containers before finding one that would work
//
if (container == null)
{
return(null);
}
// if the Build___ method returns null, we'll come back around with a different container/key
//
switch (verb)
{
case RequestVerb.Get:
request = BuildGet(workspace, key, HttpStatusCode.OK, format);
break;
case RequestVerb.Post:
request = BuildInsert(workspace, container, type, HttpStatusCode.Created, format);
break;
case RequestVerb.Put:
case RequestVerb.Patch:
request = BuildUpdate(workspace, container, type, (verb == RequestVerb.Put), HttpStatusCode.NoContent, format);
break;
case RequestVerb.Delete:
request = BuildDelete(workspace, key, HttpStatusCode.NoContent, format);
break;
default:
throw new ArgumentException("Unsupported verb: " + verb.ToString());
}
}
// might be null, but we did our best
//
return(request);
}
public AtomUpdatePayloadBuilder(Workspace workspace, RequestVerb requestVerb)
: base(workspace, requestVerb)
{
}
public static bool IsSafeOperation(RequestVerb verb, ResourceContainer container)
{
if (container is ServiceOperation)
{
ServiceOperation op = container as ServiceOperation;
return verb == op.Verb && verb == RequestVerb.Get; //for now POST always means insert
}
if(container.Name == "Invoices" && (container.Workspace.DataLayerProviderKind == DataLayerProviderKind.NonClr || container.Workspace.DataLayerProviderKind == DataLayerProviderKind.InMemoryLinq))
return false;
switch (verb)
{
case RequestVerb.Delete:
if (container.Name.Equals("DataKey_Bit"))
return false;
if (container.Name.Equals("ComputerDetails"))
return false;
if (!container.ResourceTypes.All(type => IsSafeOperation(verb, container, type)))
return false;
break;
case RequestVerb.Post:
if (container.Name.Equals("Shippers"))
return false;
if (container.Name.Equals("Employees"))
return false;
if (container.Name.Equals("Order_Details"))
return false;
if (container.Name.Equals("ProjectSet"))
return false;
if (container.Name.Equals("DataKey_Bit"))
return false;
if (container.Name.Equals("Vehicles"))
return false;
if (container.Name.Equals("People"))
return false;
if (container.Name.Equals("Computers"))
return false;
if (container.Name.Equals("Workers"))
return false;
if (!container.ResourceTypes.All(type => IsSafeOperation(verb, container, type)))
return false;
break;
}
return true;
}
private static bool MethodAllowed(ContainmentQuery query, ContainmentQuerySuffix suffix, RequestVerb verb)
{
if (query.SetExpected)
{
if (suffix != ContainmentQuerySuffix.None)
{
AstoriaTestLog.FailAndThrow("Only the NONE suffix can be used when a set is expected");
}
return(verb == RequestVerb.Get || verb == RequestVerb.Post);
}
else
{
return(VerbMap.Valid(suffix, verb));
}
}
public static bool IsSafeOperation(RequestVerb verb, ResourceContainer container, ResourceType type)
{
switch (verb)
{
case RequestVerb.Delete:
if (!type.IsInsertable)
return false;
if (type.Associations.Any())
return false;
if (type.Properties.Any(p => p.Facets.ConcurrencyModeFixed && p.Facets.IsStoreBlob))
return false;
return true;
case RequestVerb.Patch:
if (type.Facets.AbstractType)
return false;
if (!type.IsInsertable)
return false;
if (type.IsAssociationEntity)
return false;
if (type.Properties.Any(p => p.Facets.ConcurrencyModeFixed && p.Facets.IsStoreBlob))
return false;
return true;
case RequestVerb.Put:
if (type.Facets.AbstractType)
return false;
if (!type.IsInsertable)
return false;
if (type.IsAssociationEntity)
return false;
if (type.Properties.Any(p => p.Facets.IsIdentity))
return false;
if (type.Properties.Any(p => p.Facets.ConcurrencyModeFixed && p.Facets.IsStoreBlob))
return false;
return true;
case RequestVerb.Post:
if (type.Facets.AbstractType)
return false;
if (!type.IsInsertable)
return false;
if (type.IsAssociationEntity)
return false;
if (type.IsChildRefEntity)
return false;
if (type.Associations.Any(ra => ra.Ends.Any(end => end.ResourceType.IsAssociationEntity)))
return false;
return true;
}
return true;
}
public JsonUpdatePayloadBuilder(Workspace workspace, RequestVerb requestVerb)
: base(workspace, requestVerb)
{
_typeStack = new Stack<string>(8);
}
