public override bool Execute()
        {
            try
            {
                var manifest = ComputeDevelopmentManifest(
                    Assets.Select(a => StaticWebAsset.FromTaskItem(a)),
                    DiscoveryPatterns.Select(ComputeDiscoveryPattern));

                PersistManifest(manifest);
            }
            catch (Exception ex)
            {
                Log.LogError(ex.ToString());
                Log.LogErrorFromException(ex);
            }
            return(!Log.HasLoggedErrors);
        }
        public StaticWebAssetsDevelopmentManifest ComputeDevelopmentManifest(
            IEnumerable <StaticWebAsset> assets,
            IEnumerable <StaticWebAssetsManifest.DiscoveryPattern> discoveryPatterns)
        {
            var assetsWithPathSegments = assets
                                         .GroupBy(
                a => a.ComputeTargetPath("", '/'),
                ChooseAsset)
                                         .Where(pair => pair.Item2 != null)
                                         .ToArray();

            var discoveryPatternsByBasePath = DiscoveryPatterns
                                              .Select(ComputeDiscoveryPattern)
                                              .GroupBy(p => p.BasePath,
                                                       (key, values) => (key.Split('/'), values));

            var manifest = CreateManifest(assetsWithPathSegments, discoveryPatternsByBasePath);

            return(manifest);
        }
示例#3
0
        public override bool Execute()
        {
            try
            {
                var assets = Assets.OrderBy(a => a.GetMetadata("FullPath")).Select(StaticWebAsset.FromTaskItem);

                var assetsByTargetPath = assets.GroupBy(a => a.ComputeTargetPath("", '/'), StringComparer.OrdinalIgnoreCase);
                foreach (var group in assetsByTargetPath)
                {
                    if (!StaticWebAsset.ValidateAssetGroup(group.Key, group.ToArray(), ManifestType, out var reason))
                    {
                        Log.LogError(reason);
                        return(false);
                    }
                }

                var discoveryPatterns = DiscoveryPatterns
                                        .OrderBy(a => a.ItemSpec)
                                        .Select(StaticWebAssetsManifest.DiscoveryPattern.FromTaskItem)
                                        .ToArray();

                var referencedProjectsConfiguration = ReferencedProjectsConfigurations.OrderBy(a => a.ItemSpec)
                                                      .Select(StaticWebAssetsManifest.ReferencedProjectConfiguration.FromTaskItem)
                                                      .ToArray();

                PersistManifest(
                    StaticWebAssetsManifest.Create(
                        Source,
                        BasePath,
                        Mode,
                        ManifestType,
                        referencedProjectsConfiguration,
                        discoveryPatterns,
                        assets.ToArray()));
            }
            catch (Exception ex)
            {
                Log.LogErrorFromException(ex, showStackTrace: true, showDetail: true, file: null);
            }
            return(!Log.HasLoggedErrors);
        }
        public override bool Execute()
        {
            try
            {
                var assets = Assets.OrderBy(a => a.GetMetadata("FullPath")).Select(StaticWebAsset.FromTaskItem);

                var relatedManifests = RelatedManifests.OrderBy(a => a.GetMetadata("FullPath"))
                                       .Select(ComputeManifestReference)
                                       .Where(r => r != null)
                                       .ToArray();

                if (Log.HasLoggedErrors)
                {
                    return(false);
                }

                var discoveryPatterns = DiscoveryPatterns
                                        .OrderBy(a => a.ItemSpec)
                                        .Select(ComputeDiscoveryPattern)
                                        .ToArray();

                PersistManifest(
                    StaticWebAssetsManifest.Create(
                        Source,
                        BasePath,
                        Mode,
                        ManifestType,
                        relatedManifests,
                        discoveryPatterns,
                        assets.ToArray()));
            }
            catch (Exception ex)
            {
                Log.LogError(ex.ToString());
                Log.LogErrorFromException(ex);
            }
            return(!Log.HasLoggedErrors);
        }