private static ObjectFieldDefinition CreateDefinition(
IDescriptorContext context)
{
var descriptor = ObjectFieldDescriptor
.New(context, "node");
descriptor
.Argument("id", a => a.Type <NonNullType <IdType> >())
.Type <NonNullType <NodeType> >()
.Resolver(async ctx =>
{
string id = ctx.Argument <string>("id");
IdValue deserializedId = _idSerializer.Deserialize(id);
if (ctx.Schema.TryGetType(deserializedId.TypeName,
out ObjectType type) &&
type.ContextData.TryGetValue(
RelayConstants.NodeResolverFactory,
out object o) &&
o is Func <IServiceProvider, INodeResolver> factory)
{
INodeResolver resolver =
factory.Invoke(ctx.Service <IServiceProvider>());
return(await resolver.ResolveAsync(
ctx, deserializedId.Value)
.ConfigureAwait(false));
}
return(null);
});
return(descriptor.CreateDefinition());
}
public override INode Find(INodeResolver resolver, string uri, NodeType nodeType, FileSystemOptions options)
{
var address = LayeredNodeAddress.Parse(uri);
if (address.Port >= 0 || address.UserName != "" || address.Password != "" || address.ServerName != "")
{
throw new MalformedUriException(uri, "Network & Authentication information not permitted");
}
if (nodeType.Is(typeof(IFile)))
{
var uri2 = address.InnerUri;
if (StringUriUtils.ContainsQuery(uri2))
{
uri2 += "&shadow=true";
}
else
{
uri2 += "?shadow=true";
}
return(resolver.Resolve(uri2, nodeType));
}
return(resolver.Resolve(address.InnerUri));
}
public override INode Find(INodeResolver resolver, string uri, NodeType nodeType, FileSystemOptions options)
{
var address = LayeredNodeAddress.Parse(uri);
if (address.Port >= 0 || address.UserName != "" || address.Password != "" || address.ServerName != "")
{
throw new MalformedUriException(uri, "Network & Authentication information not permitted");
}
if (nodeType.Is(typeof(IFile)))
{
var uri2 = address.InnerUri;
if (StringUriUtils.ContainsQuery(uri2))
{
uri2 += "&shadow=true";
}
else
{
uri2 += "?shadow=true";
}
return resolver.Resolve(uri2, nodeType);
}
return resolver.Resolve(address.InnerUri);
}
public INode Filter(ref INodeResolver resolver, ref INodeAddress address, ref NodeType nodeType, out bool canCache)
{
if (nodeType.GetType().IsGenericType && nodeType.GetType().GetGenericTypeDefinition() == typeof(DataFileNodeType<>))
{
var innerNodeType = nodeType.InnerType ?? NodeType.File;
var file = (IFile)resolver.Resolve(address.PathAndQuery, innerNodeType);
var dataFileType = typeof(DataFile<>);
dataFileType = dataFileType.MakeGenericType(nodeType.GetType().GetGenericArguments());
var dataFile = (INode)Activator.CreateInstance(dataFileType, file, nodeType);
canCache = true;
return dataFile;
}
else
{
canCache = false;
return null;
}
}
/// <summary>
/// Load design from input stream
/// </summary>
/// <param name="design"></param>
/// <param name="assigner"></param>
/// <param name="resolver"></param>
/// <returns></returns>
public static IModelDesign Load(Stream design, INodeIdAssigner assigner = null,
INodeResolver resolver = null)
{
try {
var model = design.DeserializeFromXml <ModelDesign>();
return(new ModelDesignFile(model, assigner, resolver ?? new CompositeModelResolver()));
}
catch (Exception ex) {
// Try to load as type dictionary
if (!design.CanSeek)
{
// Stream is already partitially read - need to reset - if we cannot throw
throw;
}
try {
design.Seek(0, SeekOrigin.Begin);
return(LoadTypeDictionary(design, assigner, resolver));
}
catch {
#pragma warning disable CA2200 // Rethrow to preserve stack details
throw ex;
#pragma warning restore CA2200 // Rethrow to preserve stack details
}
}
}
public INode Filter(ref INodeResolver resolver, ref INodeAddress address, ref NodeType nodeType, out bool canCache)
{
if (nodeType.GetType().IsGenericType&& nodeType.GetType().GetGenericTypeDefinition() == typeof(DataFileNodeType <>))
{
var innerNodeType = nodeType.InnerType ?? NodeType.File;
var file = (IFile)resolver.Resolve(address.PathAndQuery, innerNodeType);
var dataFileType = typeof(DataFile <>);
dataFileType = dataFileType.MakeGenericType(nodeType.GetType().GetGenericArguments());
var dataFile = (INode)Activator.CreateInstance(dataFileType, file, nodeType);
canCache = true;
return(dataFile);
}
else
{
canCache = false;
return(null);
}
}
public override INode Find(INodeResolver resolver, string uri, NodeType nodeType, FileSystemOptions options)
{
var result = uri.SplitOnFirst("://");
if (result.Left != this.viewFileSystem.RootDirectory.Address.Scheme)
{
throw new NotSupportedException(result.Left);
}
return(this.viewFileSystem.Resolve(TextConversion.FromEscapedHexString(result.Right), nodeType));
}
private static IDirectory ResolveRootDirectory(INodeResolver resolver, string uri, bool create)
{
try
{
return create ? resolver.ResolveDirectory(uri).Create(true) : resolver.ResolveDirectory(uri);
}
catch (Exception e)
{
Console.Error.WriteLine(e);
throw;
}
}
public override INode Find(INodeResolver resolver, string uri, NodeType nodeType, FileSystemOptions options)
{
Pair<string, string> result;
result = uri.SplitOnFirst("://");
if (result.Left != this.imaginaryFileSystem.RootDirectory.Address.Scheme)
{
throw new NotSupportedException(result.Left);
}
return this.imaginaryFileSystem.Resolve(TextConversion.FromEscapedHexString(result.Right), nodeType);
}
private static IDirectory ResolveRootDirectory(INodeResolver resolver, string uri, bool create)
{
try
{
return(create ? resolver.ResolveDirectory(uri).Create(true) : resolver.ResolveDirectory(uri));
}
catch (Exception e)
{
Console.Error.WriteLine(e);
throw;
}
}
public virtual INode Filter(ref INodeResolver resolver, ref INodeAddress address, ref NodeType nodeType, out bool canCache)
{
string value;
canCache = false;
if (this.QueryKey == null)
{
value = "true";
}
else
{
try
{
if (address.QueryValues[QueryKey] == null)
{
return null;
}
value = (string)address.QueryValues[this.QueryKey];
}
catch (KeyNotFoundException)
{
value = null;
}
}
if (nodeType.Equals(NodeType.File) && value != null && value.ToLower() == "true")
{
canCache = true;
var innerNodeType = nodeType.InnerType;
if (innerNodeType == null)
{
innerNodeType = NodeType.File;
}
var query = StringUriUtils.BuildQuery
(
address.QueryValues,
QueryFilter
);
var uri = address.AbsolutePath + "?" + query;
return new ShadowFile((IFile)resolver.Resolve(uri, innerNodeType), address);
}
return null;
}
public virtual INode Filter(ref INodeResolver resolver, ref INodeAddress address, ref NodeType nodeType, out bool canCache)
{
string value;
canCache = false;
if (this.QueryKey == null)
{
value = "true";
}
else
{
try
{
if (address.QueryValues[QueryKey] == null)
{
return(null);
}
value = (string)address.QueryValues[this.QueryKey];
}
catch (KeyNotFoundException)
{
value = null;
}
}
if (nodeType.Equals(NodeType.File) && value != null && value.ToLower() == "true")
{
canCache = true;
var innerNodeType = nodeType.InnerType;
if (innerNodeType == null)
{
innerNodeType = NodeType.File;
}
var query = StringUriUtils.BuildQuery
(
address.QueryValues,
QueryFilter
);
var uri = address.AbsolutePath + "?" + query;
return(new ShadowFile((IFile)resolver.Resolve(uri, innerNodeType), address));
}
return(null);
}
public override void OnBeforeCompleteType(
ITypeCompletionContext completionContext,
DefinitionBase definition,
IDictionary <string, object> contextData)
{
if ((completionContext.IsQueryType ?? false) &&
definition is ObjectTypeDefinition objectTypeDefinition)
{
ObjectFieldDefinition typeNameField = objectTypeDefinition.Fields.First(
t => t.Name.Equals(IntrospectionFields.TypeName) && t.IsIntrospectionField);
var index = objectTypeDefinition.Fields.IndexOf(typeNameField) + 1;
var descriptor = ObjectFieldDescriptor.New(
completionContext.DescriptorContext,
_node);
IIdSerializer serializer =
completionContext.Services.GetService <IIdSerializer>() ??
new IdSerializer();
descriptor
.Argument(_id, a => a.Type <NonNullType <IdType> >())
.Type <NodeType>()
.Resolve(async ctx =>
{
var id = ctx.ArgumentValue <string>(_id);
IdValue deserializedId = serializer.Deserialize(id);
ctx.LocalContextData = ctx.LocalContextData
.SetItem(WellKnownContextData.Id, deserializedId.Value)
.SetItem(WellKnownContextData.Type, deserializedId.TypeName);
if (ctx.Schema.TryGetType(deserializedId.TypeName,
out ObjectType type) &&
type.ContextData.TryGetValue(
RelayConstants.NodeResolverFactory,
out object?o) &&
o is Func <IServiceProvider, INodeResolver> factory)
{
INodeResolver resolver = factory.Invoke(ctx.Services);
return(await resolver.ResolveAsync(ctx, deserializedId.Value)
.ConfigureAwait(false));
}
return(null);
});
objectTypeDefinition.Fields.Insert(index, descriptor.CreateDefinition());
}
}
public override INode Filter(ref INodeResolver resolver, ref INodeAddress address, ref NodeType nodeType, out bool canCache)
{
string value;
canCache = false;
if (this.QueryKey == null)
{
return(null);
}
else
{
try
{
if (address.QueryValues[this.QueryKey] == null)
{
return(null);
}
value = (string)address.QueryValues[this.QueryKey];
}
catch (KeyNotFoundException)
{
return(null);
}
}
if (nodeType.Equals(NodeType.File))
{
canCache = true;
var query = StringUriUtils.BuildQuery
(
address.QueryValues,
pair => pair.Key.Equals(this.QueryKey, StringComparison.CurrentCultureIgnoreCase)
);
var uri = address.AbsolutePath + "?" + query;
var file = resolver.ResolveFile(uri);
var service = (ITempIdentityFileService)file.GetService(new TempIdentityFileServiceType(value));
canCache = true;
return(service.GetTempFile());
}
return(null);
}
public override INode Filter(ref INodeResolver resolver, ref INodeAddress address, ref NodeType nodeType, out bool canCache)
{
string value;
canCache = false;
if (this.QueryKey == null)
{
return null;
}
else
{
try
{
if (address.QueryValues[this.QueryKey] == null)
{
return null;
}
value = (string)address.QueryValues[this.QueryKey];
}
catch (KeyNotFoundException)
{
return null;
}
}
if (nodeType.Equals(NodeType.File))
{
canCache = true;
var query = StringUriUtils.BuildQuery
(
address.QueryValues,
pair => pair.Key.Equals(this.QueryKey, StringComparison.CurrentCultureIgnoreCase)
);
var uri = address.AbsolutePath + "?" + query;
var file = resolver.ResolveFile(uri);
var service = (ITempIdentityFileService)file.GetService(new TempIdentityFileServiceType(value));
canCache = true;
return service.GetTempFile();
}
return null;
}
/// <summary>
/// Load design from file and optional identifier file
/// </summary>
/// <param name="designFile"></param>
/// <param name="resolver"></param>
/// <returns></returns>
public static IModelDesign Load(string designFile, INodeResolver resolver = null)
{
using (var stream = File.OpenRead(designFile)) {
var model = stream.DeserializeFromXml <ModelDesign>();
var identifierFile = Path.ChangeExtension(designFile, "csv");
INodeIdAssigner assigner = null;
if (File.Exists(identifierFile))
{
using (var stream2 = File.OpenRead(identifierFile)) {
assigner = new IdentifierFile(stream2, model.TargetNamespace, model.TargetVersion);
}
}
return(new ModelDesignFile(model, assigner, resolver ?? new CompositeModelResolver()));
}
}
public static IObjectTypeDescriptor AsNode(
this IObjectTypeDescriptor descriptor,
INodeResolver nodeResolver)
{
if (descriptor == null)
{
throw new ArgumentNullException(nameof(descriptor));
}
if (nodeResolver == null)
{
throw new ArgumentNullException(nameof(nodeResolver));
}
return(AsNode(descriptor, sp => nodeResolver));
}
private static ObjectFieldDefinition CreateDefinition(
IDescriptorContext context)
{
var descriptor = ObjectFieldDescriptor
.New(context, _node);
IIdSerializer _serializer = null;
descriptor
.Argument(_id, a => a.Type <NonNullType <IdType> >())
.Type <NonNullType <NodeType> >()
.Resolver(async ctx =>
{
IServiceProvider services = ctx.Service <IServiceProvider>();
if (_serializer is null)
{
_serializer =
services.GetService(typeof(IIdSerializer)) is IIdSerializer s
? s
: new IdSerializer();
}
var id = ctx.Argument <string>(_id);
IdValue deserializedId = _serializer.Deserialize(id);
ctx.LocalContextData = ctx.LocalContextData
.SetItem(WellKnownContextData.Id, deserializedId.Value)
.SetItem(WellKnownContextData.Type, deserializedId.TypeName);
if (ctx.Schema.TryGetType(deserializedId.TypeName,
out ObjectType type) &&
type.ContextData.TryGetValue(
RelayConstants.NodeResolverFactory,
out var o) &&
o is Func <IServiceProvider, INodeResolver> factory)
{
INodeResolver resolver = factory.Invoke(services);
return(await resolver.ResolveAsync(ctx, deserializedId.Value)
.ConfigureAwait(false));
}
return(null);
});
return(descriptor.CreateDefinition());
}
public override INode Find(INodeResolver resolver, string uri, NodeType nodeType, FileSystemOptions options)
{
var node = base.Find(resolver, uri, nodeType, options);
if (node.Equals(this.ImaginaryFileSystem.RootDirectory))
{
var dir = (ImaginaryDirectory)node;
dir.Refreshed += delegate
{
PopulateRoot(dir);
};
PopulateRoot(dir);
}
return node;
}
public override INode Find(INodeResolver resolver, string uri, NodeType nodeType, FileSystemOptions options)
{
var node = base.Find(resolver, uri, nodeType, options);
if (node.Equals(this.ImaginaryFileSystem.RootDirectory))
{
var dir = (ImaginaryDirectory)node;
dir.Refreshed += delegate
{
PopulateRoot(dir);
};
PopulateRoot(dir);
}
return(node);
}
/// <summary>
/// Construct a new <see cref="NodeDelegationWrapper"/>.
/// </summary>
/// <param name="innerNode">
/// The <see cref="INode"/> to delegate to.
/// </param>
/// <param name="resolver">
/// The resolver used to delegate <c>Resolve</c> calls.
/// </param>
/// <param name="nodeAdapter">
/// The adapter that will adapt adapter candidate nodes returned be the
/// <c>Resolve</c> and <c>ParentDirectory</c> methods.
/// </param>
protected NodeDelegationWrapper(INode innerNode, INodeResolver resolver, Converter <INode, INode> nodeAdapter)
: base(innerNode)
{
if (resolver == null)
{
if (this.NodeType == NodeType.Directory)
{
resolver = new DefaultResolver(this);
}
else
{
resolver = new DefaultResolver(this);
}
}
this.NodeResolver = resolver;
this.NodeAdapter = nodeAdapter;
}
public override INode Filter(ref INodeResolver resolver, ref INodeAddress address, ref NodeType nodeType, out bool canCache)
{
MediaFileNodeType mediaFileNodeType;
if ((mediaFileNodeType = (nodeType as MediaFileNodeType)) != null)
{
var file = resolver.ResolveFile(address.PathAndQuery);
var mediaFile = MediaFileFactory.Default.NewMediaFile(file, mediaFileNodeType);
canCache = !mediaFileNodeType.UniqueInstance;
return mediaFile;
}
else
{
canCache = false;
return null;
}
}
public override INode Filter(ref INodeResolver resolver, ref INodeAddress address, ref NodeType nodeType, out bool canCache)
{
MediaFileNodeType mediaFileNodeType;
if ((mediaFileNodeType = (nodeType as MediaFileNodeType)) != null)
{
var file = resolver.ResolveFile(address.PathAndQuery);
var mediaFile = MediaFileFactory.Default.NewMediaFile(file, mediaFileNodeType);
canCache = !mediaFileNodeType.UniqueInstance;
return(mediaFile);
}
else
{
canCache = false;
return(null);
}
}
/// <summary>
/// Initializes a new instance of the QueryResult with a prepared hit collection.
/// Use this constructor if the hit collection contains all items in the memory.
/// </summary>
/// <param name="nodes">The <see cref="IEnumerable<Node>"/> that contains hits.</param>
public QueryResult(IEnumerable <Node> nodes)
{
switch (nodes)
{
case NodeList <Node> nodeList:
_result = nodeList;
Count = nodeList.Count;
break;
case List <Node> listOfNodes:
_result = new NodeResolver(listOfNodes);
Count = listOfNodes.Count;
break;
default:
var nodeArray = nodes as Node[] ?? nodes.ToArray();
_result = new NodeResolver(nodeArray);
Count = nodeArray.Length;
break;
}
}
/// <summary>
/// Initializes a new instance of the QueryResult with a prepared hit collection and it's count.
/// Use this constructor if the hit collection does contain all items in the memory and uses a block-read algorithm.
/// </summary>
/// <param name="nodes">The <see cref="IEnumerable<Node>"/> that contains hits.</param>
/// <param name="totalCount">Count of items.</param>
public QueryResult(IEnumerable <Node> nodes, int totalCount)
{
_result = new NodeResolver(nodes);
Count = totalCount;
}
public void Accept(INodeResolver resolver)
{
resolver.Resolve(this);
}
/// <summary>
/// Construct a new <see cref="NodeDelegationWrapper"/>.
/// </summary>
/// <param name="innerNode">
/// The <see cref="INode"/> to delegate to.
/// </param>
/// <param name="resolver">
/// The resolver used to delegate <c>Resolve</c> calls.
/// </param>
/// <param name="nodeAdapter">
/// The adapter that will adapt adapter candidate nodes returned be the
/// <c>Resolve</c> and <c>ParentDirectory</c> methods.
/// </param>
protected NodeDelegationWrapper(INode innerNode, INodeResolver resolver, Converter<INode, INode> nodeAdapter)
: base(innerNode)
{
if (resolver == null)
{
if (this.NodeType == NodeType.Directory)
{
resolver = new DefaultResolver(this);
}
else
{
resolver = new DefaultResolver(this);
}
}
this.NodeResolver = resolver;
this.NodeAdapter = nodeAdapter;
}
public DelegatingResolver(INodeResolver resolver)
{
this.resolver = resolver;
}
protected DirectoryDelegationWrapper(IDirectory innerDirectory, INodeResolver resolver, Converter<INode, INode> nodeAdapter)
: base(innerDirectory, resolver, nodeAdapter)
{
}
/// <summary>
/// Load design from file
/// </summary>
/// <param name="designFile"></param>
/// <param name="assigner"></param>
/// <param name="resolver"></param>
/// <returns></returns>
public static IModelDesign LoadTypeDictionary(string designFile,
INodeIdAssigner assigner = null, INodeResolver resolver = null)
{
using (var stream = File.OpenRead(designFile)) {
return(LoadTypeDictionary(stream, assigner, resolver));
}
}
public JumpPointResolver(INodeResolver resolver)
{
this.resolver = resolver;
}
public JumpPointResolver(INodeResolver resolver)
{
this.resolver = resolver;
}
public abstract INode Filter(ref INodeResolver resolver, ref INodeAddress address, ref NodeType nodeType, out bool canCache);
public abstract INode Find(INodeResolver resolver, string uri, NodeType nodeType, FileSystemOptions options);
public abstract INode Find(INodeResolver resolver, string uri, NodeType nodeType, FileSystemOptions options);
/* =========================================== */
/// <summary>
/// Initializes a new instance of the QueryResult with identifiers as hit collection.
/// </summary>
/// <param name="result">The IEnumerable<int> that contains ids of hits.</param>
public QueryResult(IEnumerable <int> result)
{
_result = new NodeList <Node>(result);
Count = _result.IdCount;
}
/// <summary>
/// Initializes a new instance of the QueryResult with
/// identifiers as hit collection and it's count.
/// </summary>
/// <param name="result">The IEnumerable<int> that contains ids of hits.</param>
/// <param name="totalCount">Count of items.</param>
public QueryResult(IEnumerable <int> result, int totalCount)
{
_result = new NodeList <Node>(result);
Count = totalCount;
}
public override INode Find(INodeResolver resolver, string uri, NodeType nodeType, FileSystemOptions options)
{
var nodeAddress = ParseUri(uri);
return(Find(nodeAddress, nodeType, options));
}
/// <summary>
/// Load design from input stream
/// </summary>
/// <param name="design"></param>
/// <param name="assigner"></param>
/// <param name="resolver"></param>
/// <returns></returns>
public static IModelDesign LoadTypeDictionary(Stream design,
INodeIdAssigner assigner = null, INodeResolver resolver = null)
{
var types = Types.Load(design, resolver as ITypeResolver);
return(new ModelDesignFile(types.ToModelDesign(), assigner,
resolver ?? new CompositeModelResolver()));
}
public virtual INode Resolve(INodeAddress address, NodeType nodeType)
{
INode node;
var fromCache = GetFromCache(address, nodeType);
if (fromCache != null)
{
return(fromCache);
}
lock (this.SyncLock)
{
if (IsContainedInShortcut(address))
{
var parent = (IDirectory)this.Resolve(address.Parent, NodeType.Directory);
node = parent.Resolve(address.Name, nodeType);
AddToCache(address, node);
return(node);
}
INodeResolver resolver = this;
if (this.Extenders != null)
{
foreach (INodeResolutionFilter filter in this.Extenders.NodeResolutionFilters)
{
bool canCache;
if ((node = filter.Filter(ref resolver, ref address, ref nodeType, out canCache)) != null)
{
node = Decorate(node);
if (canCache)
{
if (node is IDirectory)
{
AttachShortcut((IDirectory)node);
}
AddToCache(node);
}
return(node);
}
}
}
}
if (!AddressOk(address))
{
throw new MalformedUriException(address.Uri, "Malformed or unsupported URI");
}
lock (this.SyncLock)
{
if (fromCache == null)
{
node = CreateNode(address, nodeType);
node = Decorate(node);
if (node is IDirectory)
{
AttachShortcut((IDirectory)node);
}
AddToCache(node);
}
else
{
node = fromCache;
}
return(node);
}
}
public DelegatingResolver(INodeResolver resolver)
{
this.resolver = resolver;
}
/// <summary>
/// For dynamic contents
/// </summary>
/// <param name="nodes"></param>
public QueryResult(IEnumerable <Node> nodes)
{
_result = new _NodeResolver(nodes);
}
public abstract INode Filter(ref INodeResolver resolver, ref INodeAddress address, ref NodeType nodeType, out bool canCache);
protected DirectoryDelegationWrapper(IDirectory innerDirectory, INodeResolver resolver, Converter <INode, INode> nodeAdapter)
: base(innerDirectory, resolver, nodeAdapter)
{
}
