Example #1
0
        private Task OnPreLoadFile(PreLoadFileArgs args)
        {
            var contentLoc = m_PromoteLocations?.FirstOrDefault(l => args.File.Location.IsInLocation(l));

            if (contentLoc != null)
            {
                args.File = new PluginFile(args.File.Content, args.File.Location.GetRelative(contentLoc), args.File.Id);
            }

            return(Task.CompletedTask);
        }
Example #2
0
 public Task PreLoadFile(PreLoadFileArgs args)
 {
     if (RequestPreLoadFile != null)
     {
         return(RequestPreLoadFile.Invoke(args));
     }
     else
     {
         return(Task.CompletedTask);
     }
 }
Example #3
0
        private async Task OnRequestPreLoadFile(PreLoadFileArgs args)
        {
            if (PreLoadFile != null)
            {
                foreach (PreLoadFileDelegate del in PreLoadFile.GetInvocationList())
                {
                    var thisArg = new PreLoadFileArgs()
                    {
                        File     = args.File,
                        SkipFile = false
                    };

                    await del.Invoke(thisArg);

                    args.File      = thisArg.File;
                    args.SkipFile |= thisArg.SkipFile;
                }
            }
        }
Example #4
0
        public async IAsyncEnumerable <IFile> Load(ILocation[] locations)
        {
            var resFileIds = new List <string>();

            await m_PluginsManager.LoadPlugins(LoadPluginFiles(locations, resFileIds));

            foreach (var loc in locations)
            {
                m_Logger.LogInformation($"Loading project files from {loc.ToId()}");

                var filter = new List <string>();

                if (m_Filter != null)
                {
                    filter.AddRange(m_Filter);
                }

                var pluginExcludeFilter = LocationExtension.NEGATIVE_FILTER
                                          + Path.Combine(Location.Library.PluginsFolderName, LocationExtension.ANY_FILTER);

                filter.Add(pluginExcludeFilter);

                await foreach (var srcFile in m_FileLoader.LoadFolder(loc, filter.ToArray()))
                {
                    var args = new PreLoadFileArgs()
                    {
                        File     = srcFile,
                        SkipFile = false
                    };

                    await m_Ext.PreLoadFile(args);

                    if (!args.SkipFile)
                    {
                        var id = args.File.Location.ToId();

                        if (!resFileIds.Contains(id))
                        {
                            resFileIds.Add(id);
                            yield return(args.File);
                        }
                        else
                        {
                            throw new DuplicateFileException(id, loc.ToId());
                        }
                    }
                }
            }

            if (m_Config.Components?.Any() == true)
            {
                foreach (var compName in m_Config.Components)
                {
                    await foreach (var srcFile in ProcessLibraryItems(
                                       m_LibraryLoader.LoadComponentFiles(compName, m_Filter), resFileIds, false))
                    {
                        yield return(srcFile);
                    }
                }
            }

            if (m_Config.ThemesHierarchy?.Any() == true)
            {
                foreach (var theme in m_Config.ThemesHierarchy)
                {
                    foreach (var themeName in m_Config.ThemesHierarchy)
                    {
                        await foreach (var srcFile in ProcessLibraryItems(
                                           m_LibraryLoader.LoadThemeFiles(themeName, m_Filter), resFileIds, true))
                        {
                            yield return(srcFile);
                        }
                    }
                }
            }
        }