Esempio n. 1
0
        internal override Task ResolveView(ResolveViewArgs resolveViewArgs)
        {
            if (resolveViewArgs.Success == true)
            {
                return(Task.CompletedTask);
            }

            var path = new[] { resolveViewArgs.Name }
            .SelectMany(pattern => ViewExtensions.Select(ext => $"{pattern}{ext}"))
            .SelectMany(pattern => SearchPaths.Select(searchPath => CombineAndRestrictPath(searchPath, pattern)))
            .Where(_ => File.Exists(_))
            .FirstOrDefault();

            if (path == null)
            {
                return(Task.CompletedTask);
            }

            if (RoutableOptions.TryGetMimeType(Path.GetExtension(path), out var mimeType) == false)
            {
                mimeType = DefaultMimeType;
            }
            resolveViewArgs.MimeType     = mimeType;
            resolveViewArgs.LastModified = File.GetLastWriteTimeUtc(path);
            resolveViewArgs.GetStream    = () => Task.FromResult <Stream>(File.OpenRead(path));
            resolveViewArgs.Success      = true;

            return(Task.CompletedTask);
        }
Esempio n. 2
0
        internal async override Task ResolveView(ResolveViewArgs resolveViewArgs)
        {
            foreach (var resolver in AsyncViewResolvers)
            {
                await resolver(resolveViewArgs);

                if (resolveViewArgs.Success == true)
                {
                    return;
                }
            }

            ViewResolvers?.Invoke(this, resolveViewArgs);
        }
        internal override Task ResolveView(ResolveViewArgs resolveViewArgs)
        {
            if (resolveViewArgs.Success == true)
            {
                return(Task.CompletedTask);
            }

            // build list of path patterns.
            var name  = resolveViewArgs.Name.Replace('/', '.').Replace('\\', '.');
            var paths = ViewExtensions.Select(ext => $"{name}{ext}");

            foreach (var search in SearchPaths.SelectMany(_ => _.Prefixes.Select(prefix => new { prefix = prefix, assembly = _.Assembly })))
            {
                // search every path pattern.
                foreach (var path in paths)
                {
                    var absolutePath = string.IsNullOrWhiteSpace(search.prefix) ? path : $"{search.prefix.TrimEnd('.')}.{path}";
                    var info         = search.assembly.GetManifestResourceInfo(absolutePath);
                    if (info == null)
                    {
                        continue;
                    }

                    // resolve mime type.
                    if (RoutableOptions.TryGetMimeType(Path.GetExtension(path), out var mimeType) == false)
                    {
                        mimeType = DefaultMimeType;
                    }

                    // construct response.
                    resolveViewArgs.MimeType     = mimeType;
                    resolveViewArgs.LastModified = DateTime.MinValue;                     // embedded resources will not ever change.
                    resolveViewArgs.GetStream    = () => Task.FromResult(search.assembly.GetManifestResourceStream(absolutePath));
                    resolveViewArgs.Success      = true;
                    return(Task.CompletedTask);
                }
            }

            // no matches.
            return(Task.CompletedTask);
        }
Esempio n. 4
0
        public static async Task <Template <TContext, TRequest, TResponse> > Find(RoutableOptions <TContext, TRequest, TResponse> options, string viewName)
        {
            if (options.TryGetFeatureOptions <List <SimpleViewOptions <TContext, TRequest, TResponse> > >(out var viewOptionsCollection) == false)
            {
                // use default options.
                viewOptionsCollection = new List <SimpleViewOptions <TContext, TRequest, TResponse> >()
                {
                    new SimpleFileSystemViewOptions <TContext, TRequest, TResponse>(options)
                };
            }

            foreach (var viewOptions in viewOptionsCollection)
            {
                // resolve view.
                var resolveViewArgs = new ResolveViewArgs {
                    Name = viewName
                };
                await viewOptions.ResolveView(resolveViewArgs);

                if (resolveViewArgs.Success == false)
                {
                    continue;
                }

                // parse view source and return a template.
                using (var stream = await resolveViewArgs.GetStream())
                    using (var reader = new StreamReader(stream)) {
                        try {
                            var parser   = new TemplateParser <TContext, TRequest, TResponse>(options, viewOptions);
                            var template = parser.TryParse(viewName, resolveViewArgs.LastModified, await reader.ReadToEndAsync());
                            template.MimeType = resolveViewArgs.MimeType;
                            return(template);
                        } catch (Exception ex) {
                            throw new SimpleViewParserException(viewName, ex);
                        }
                    }
            }

            throw new SimpleViewNotFoundException(viewName);
        }