private void _resultExecutionButton_Click(object sender, EventArgs e)
{
var refresh = false;
foreach (var execution in SelectedExecutions)
{
try
{
var results = _client.Execute <string>(new SDataParameters
{
Path = "executions(" + SDataUri.FormatConstant(execution.Key) + ")/result"
});
using (var form = new ResultForm())
{
form.ShowDialog(results.Content, this);
}
}
catch (SDataException ex)
{
MessageBox.Show(string.Format("Error getting execution '{0}' result\r\n{1}", execution.Key, ex.Message));
if (ex.StatusCode == HttpStatusCode.Gone)
{
((ICollection <Execution>)_executionsGrid.DataSource).Remove(execution);
refresh = true;
}
}
}
if (refresh)
{
_executionsGrid.Refresh();
_executionsGrid.AutoResizeColumns();
}
}
protected override Stream LoadFile()
{
if (string.IsNullOrEmpty(_document.Key))
{
return(Stream.Null);
}
if (_formMode)
{
var results = _client.Execute <byte[]>(new SDataParameters
{
Path = "libraryDocuments(" + SDataUri.FormatConstant(_document.Key) + ")/file"
});
return(results.Content != null ? new MemoryStream(results.Content) : Stream.Null);
}
else
{
var results = _client.Execute(new SDataParameters
{
Path = "libraryDocuments(" + SDataUri.FormatConstant(_document.Key) + ")",
Precedence = 0,
ExtensionArgs = { { "includeFile", "true" } }
});
return(results.Files.Count == 1 ? results.Files[0].Stream : Stream.Null);
}
}
public override void Save(Stream stream)
{
if (stream == null)
{
_document = string.IsNullOrEmpty(_document.Key)
? _client.Post(_document)
: _client.Put(_document);
return;
}
var parms = new SDataParameters
{
Files = { new AttachedFile(null, _document.FileName, stream) }
};
if (string.IsNullOrEmpty(_document.Key))
{
parms.Method = HttpMethod.Post;
parms.Path = "libraryDocuments";
}
else
{
parms.Method = HttpMethod.Put;
parms.Path = "libraryDocuments(" + SDataUri.FormatConstant(_document.Key) + ")";
parms.ETag = _document.ETag;
}
if (_formMode)
{
foreach (var prop in typeof(LibraryDocument).GetProperties())
{
var name = _client.NamingScheme.GetName(prop);
if (!name.StartsWith("$", StringComparison.Ordinal) && !new[] { "createDate", "createUser", "modifyDate", "modifyUser" }.Contains(name, StringComparer.Ordinal))
{
var value = prop.GetValue(_document, null);
if (value != null)
{
parms.Form[name] = value.ToString();
}
}
}
parms.Path += "/file";
var results = _client.Execute(parms);
if (!string.IsNullOrEmpty(results.Location))
{
var selector = new SDataUri(results.Location).GetPathSegment(4).Selector;
_document.Key = selector.Substring(1, selector.Length - 2);
_document.ETag = results.ETag;
}
}
else
{
parms.Content = _document;
_document = _client.Execute <LibraryDocument>(parms).Content;
}
}
private static SDataParameters GetDeleteParameters <T>(ISDataClient client, T content, string path)
{
Guard.ArgumentNotNull(client, "client");
Guard.ArgumentNotNull(content, "content");
Guard.ArgumentNotNullOrEmptyString(path, "path");
return(new SDataParameters
{
Method = HttpMethod.Delete,
Path = string.Format("{0}({1})", path, SDataUri.FormatConstant(GetKey(content))),
ETag = GetETag(content)
});
}
protected override Expression VisitConstantExpression(ConstantExpression expression)
{
var value = expression.Value;
if (ContentHelper.IsObject(value) && !ContentHelper.IsCollection(value))
{
value = ContentHelper.GetProtocolValue <string>(value, SDataProtocolProperty.Key);
}
Append(SDataUri.FormatConstant(value));
return(expression);
}
private void btnPropertiesRead_Click(object sender, EventArgs e)
{
if (cbIsFeed.Checked)
{
var parts = new List <string>();
if (!string.IsNullOrEmpty(tbRPResourceKind.Text))
{
var selector = tbRPResourceSelector.Text;
if (!string.IsNullOrEmpty(selector))
{
selector = SDataUri.FormatConstant(selector);
}
parts.Add(new UriPathSegment(tbRPResourceKind.Text, selector).Segment);
}
if (lbProperties.Items.Count > 0)
{
parts.AddRange(lbProperties.Items.Cast <string>());
}
var collection = Client.Execute <SDataCollection <SDataResource> >(
new SDataParameters
{
Path = string.Join("/", parts)
}).Content;
gridRPPayloads.SelectedObject = null;
rpGridEntries.Rows.Clear();
rpGridEntries.Columns.Clear();
if (collection.Count > 0)
{
foreach (var key in collection[0].Keys)
{
rpGridEntries.Columns.Add(key, key);
}
foreach (var item in collection)
{
rpGridEntries.Rows.Add(item.Values.ToArray());
}
}
rpGridEntries.Refresh();
rpGridEntries.AutoResizeColumns();
}
else
{
var resource = Client.Get(tbRPResourceSelector.Text, tbRPResourceKind.Text);
rpGridEntries.Rows.Clear();
rpGridEntries.Columns.Clear();
gridRPPayloads.SelectedObject = resource;
}
}
private static SDataParameters GetGetParameters(ISDataClient client, string key, string etag, string path, SDataPayloadOptions options)
{
Guard.ArgumentNotNull(client, "client");
Guard.ArgumentNotNullOrEmptyString(key, "key");
Guard.ArgumentNotNullOrEmptyString(path, "path");
if (options == null)
{
options = new SDataPayloadOptions();
}
return(new SDataParameters
{
Path = string.Format("{0}({1})", path, SDataUri.FormatConstant(key)),
ETag = etag,
Include = options.Include,
Select = options.Select,
Precedence = options.Precedence
});
}
private static IEnumerable RenderContainsOperator(MethodCallExpression expression)
{
var argExpr = expression.Arguments[0] as ConstantExpression;
if (argExpr == null)
{
throw new NotSupportedException("Contains must be passed a literal string");
}
return(new object[]
{
"(",
expression.Object,
" like ",
SDataUri.FormatConstant("%" + argExpr.Value + "%"),
")"
});
}
private void UpdateUrl()
{
var uri = new SDataUri(Client.Uri);
if (!string.IsNullOrEmpty(tbSingleResourceKind.Text))
{
var selector = tbSingleResourceSelector.Text;
if (!string.IsNullOrEmpty(selector))
{
selector = SDataUri.FormatConstant(selector);
}
uri.AppendPath(new UriPathSegment(tbSingleResourceKind.Text, selector));
}
if (!string.IsNullOrEmpty(tbSingleResourceInclude.Text))
{
uri.Include = tbSingleResourceInclude.Text;
}
tbSingleURL.Text = uri.ToString();
}
private void UpdateUrl()
{
var uri = new SDataUri(Client.Uri);
if (!string.IsNullOrEmpty(tbRPResourceKind.Text))
{
var selector = tbRPResourceSelector.Text;
if (!string.IsNullOrEmpty(selector))
{
selector = SDataUri.FormatConstant(selector);
}
uri.AppendPath(new UriPathSegment(tbRPResourceKind.Text, selector));
}
if (lbProperties.Items.Count > 0)
{
uri.AppendPath(lbProperties.Items.Cast <string>().ToArray());
}
tbResourcePropertiesURL.Text = uri.ToString();
}
private static SDataParameters GetPutParameters <T>(ISDataClient client, T content, string path, SDataPayloadOptions options)
{
Guard.ArgumentNotNull(client, "client");
Guard.ArgumentNotNull(content, "content");
Guard.ArgumentNotNullOrEmptyString(path, "path");
if (options == null)
{
options = new SDataPayloadOptions();
}
return(new SDataParameters
{
Method = HttpMethod.Put,
Path = string.Format("{0}({1})", path, SDataUri.FormatConstant(GetKey(content))),
Content = content,
ETag = GetETag(content),
Include = options.Include,
Select = options.Select,
Precedence = options.Precedence
});
}
private SDataRequest CreateBatchRequest(ICollection <SDataParameters> items)
{
Guard.ArgumentNotNull(items, "items");
var resources = new SDataCollection <SDataResource>(items.Count);
string path = null;
MediaType?contentType = null;
var include = new List <string>();
var select = new List <string>();
int? precedence = null;
MediaType?format = null;
string language = null;
string version = null;
var accept = new List <MediaType>();
var form = new Dictionary <string, string>();
var files = new List <AttachedFile>();
var extensionArgs = new Dictionary <string, string>();
foreach (var parms in items)
{
if (parms.StartIndex != null)
{
throw new NotSupportedException("StartIndex not supported in batch requests");
}
if (parms.Count != null)
{
throw new NotSupportedException("Count not supported in batch requests");
}
if (parms.Where != null)
{
throw new NotSupportedException("Where not supported in batch requests");
}
if (parms.OrderBy != null)
{
throw new NotSupportedException("OrderBy not supported in batch requests");
}
if (parms.Search != null)
{
throw new NotSupportedException("Search not supported in batch requests");
}
if (parms.TrackingId != null)
{
throw new NotSupportedException("TrackingId not supported in batch requests");
}
if (parms.IncludeSchema != null)
{
throw new NotSupportedException("IncludeSchema not supported in batch requests");
}
if (parms.ReturnDelta != null)
{
throw new NotSupportedException("ReturnDelta not supported in batch requests");
}
if (parms.Path != path)
{
if (path != null)
{
throw new SDataClientException("All non-null path values must be the same");
}
path = parms.Path;
}
if (parms.ContentType != contentType)
{
if (contentType != null)
{
throw new SDataClientException("All non-null content type values must be the same");
}
contentType = parms.ContentType;
}
if (parms.Include != null)
{
include.AddRange(parms.Include.Split(','));
}
if (parms.Select != null)
{
select.AddRange(parms.Select.Split(','));
}
if (parms.Precedence != null && parms.Precedence != precedence)
{
precedence = Math.Max(precedence ?? 0, parms.Precedence.Value);
}
if (parms.Format != format)
{
if (format != null)
{
throw new SDataClientException("All non-null format values must be the same");
}
format = parms.Format;
}
if (parms.Language != language)
{
if (language != null)
{
throw new SDataClientException("All non-null language values must be the same");
}
language = parms.Language;
}
if (parms.Version != version)
{
if (version != null)
{
throw new SDataClientException("All non-null version values must be the same");
}
version = parms.Version;
}
if (parms.Accept != null)
{
accept.AddRange(parms.Accept);
}
foreach (var data in parms.Form)
{
form.Add(data.Key, data.Value);
}
files.AddRange(parms.Files);
foreach (var arg in parms.ExtensionArgs)
{
extensionArgs[arg.Key] = arg.Value;
}
SDataResource resource;
if (parms.Content == null)
{
resource = new SDataResource();
}
else
{
var content = parms.Content;
if (parms.Method == HttpMethod.Put && DifferentialUpdate)
{
var tracking = content as IChangeTracking;
if (tracking != null)
{
content = tracking.GetChanges();
if (content == null)
{
throw new SDataClientException("Content doesn't have any changes");
}
}
}
resource = ContentHelper.Serialize(content, NamingScheme) as SDataResource;
if (resource == null)
{
throw new SDataClientException("Only resources can be submitted in batch requests");
}
}
resource.HttpMethod = parms.Method;
if (parms.Method != HttpMethod.Post)
{
if (resource.Key == null)
{
throw new SDataClientException("A selector must be specified for GET, PUT and DELETE batch requests");
}
var itemUri = new SDataUri(Uri)
{
Include = parms.Include,
Select = parms.Select,
Precedence = parms.Precedence
};
if (path != null)
{
itemUri.AppendPath(path);
}
itemUri.LastPathSegment.Selector = SDataUri.FormatConstant(resource.Key);
resource.Id = itemUri.AbsoluteUri;
resource.Url = itemUri.Uri;
}
if (parms.ETag != null)
{
resource.IfMatch = parms.ETag;
}
resources.Add(resource);
}
var uri = new SDataUri(Uri)
{
Precedence = precedence,
Format = format ?? Format,
Language = language ?? Language,
Version = version ?? Version
};
if (path != null)
{
uri.AppendPath(path);
}
uri.AppendPath("$batch");
if (include.Count > 0)
{
uri.Include = string.Join(",", include.Distinct().ToArray());
}
if (select.Count > 0)
{
uri.Select = string.Join(",", select.Distinct().ToArray());
}
foreach (var arg in extensionArgs)
{
uri["_" + arg.Key] = arg.Value;
}
var request = CreateRequest(uri, HttpMethod.Post, resources);
request.ContentType = contentType ?? Format;
if (accept.Count > 0)
{
request.Accept = accept.Distinct().ToArray();
}
foreach (var data in form)
{
request.Form.Add(data.Key, data.Value);
}
foreach (var file in files)
{
request.Files.Add(file);
}
if (language != null)
{
request.AcceptLanguage = language ?? Language;
}
TraceRequest(request);
return(request);
}
private static SDataParameters GetServiceParameters(ISDataClient client, Expression bodyExpr, string path)
{
Guard.ArgumentNotNull(client, "client");
var callExpr = bodyExpr as MethodCallExpression;
if (callExpr == null)
{
throw new SDataClientException("Expression must be a method call");
}
var attr = callExpr.Method.GetCustomAttribute <SDataServiceOperationAttribute>();
var namingScheme = client.NamingScheme ?? NamingScheme.Default;
var request = new SDataResource();
var instance = callExpr.Object != null?Expression.Lambda(callExpr.Object).Compile().DynamicInvoke() : null;
if (path == null)
{
path = SDataPathAttribute.GetPath(instance != null ? instance.GetType() : callExpr.Method.DeclaringType);
}
if (instance != null)
{
if (attr == null || attr.PassInstanceBy == InstancePassingConvention.Selector ||
(attr.PassInstanceBy == InstancePassingConvention.Default && string.IsNullOrEmpty(attr.InstancePropertyName)))
{
if (path == null)
{
throw new SDataClientException("Path must be specified when passing instance context by selector");
}
var key = ContentHelper.GetProtocolValue <string>(instance, SDataProtocolProperty.Key);
if (string.IsNullOrEmpty(key))
{
throw new SDataClientException("Unable to extract resource key from instance");
}
path += string.Format("({0})", SDataUri.FormatConstant(key));
}
else if (attr.PassInstanceBy == InstancePassingConvention.Default)
{
var key = ContentHelper.GetProtocolValue <string>(instance, SDataProtocolProperty.Key);
request[attr.InstancePropertyName] = !string.IsNullOrEmpty(key) ? key : instance;
}
else
{
if (string.IsNullOrEmpty(attr.InstancePropertyName))
{
throw new SDataClientException("Instance property name must be specified when passing instance context by key property or object property");
}
if (attr.PassInstanceBy == InstancePassingConvention.KeyProperty)
{
var key = ContentHelper.GetProtocolValue <string>(instance, SDataProtocolProperty.Key);
if (string.IsNullOrEmpty(key))
{
throw new SDataClientException("Unable to extract resource key from instance");
}
request[attr.InstancePropertyName] = key;
}
else if (attr.PassInstanceBy == InstancePassingConvention.ObjectProperty)
{
request[attr.InstancePropertyName] = instance;
}
}
}
if (path != null)
{
path += "/";
}
path += "$service/" + namingScheme.GetName(callExpr.Method);
foreach (var pair in callExpr.Method.GetParameters().Zip(callExpr.Arguments, (param, arg) => new { param, arg }))
{
request[namingScheme.GetName(pair.param)] = Expression.Lambda(pair.arg).Compile().DynamicInvoke();
}
var xmlLocalName = attr != null ? attr.XmlLocalName : null;
var xmlNamespace = attr != null ? attr.XmlNamespace : null;
var content = new SDataResource(xmlLocalName, xmlNamespace)
{
{ "request", request }
};
return(new SDataParameters
{
Method = HttpMethod.Post,
Path = path,
Content = content
});
}