Esempio n. 1
0
        public IEnumerable <Failure> Check()
        {
            List <Failure> failures = new List <Failure>();

            foreach (ResolutionMatchesConfig config in Config)
            {
                DataResolver resolver = new DataResolver(config.Source);
                resolver.ResolveAdditional("target", config.Target);

                foreach (ResolvedData resolvedFile in resolver.Data)
                {
                    using (IMagickImage magickSource = resolvedFile.ToMagickImage())
                    {
                        ResolvedData resolvedData = resolver.ResolvedData("target", resolvedFile, config.Pattern);

                        if (resolvedData == null)
                        {
                            continue;
                        }

                        using (IMagickImage magickTarget = resolvedData.ToMagickImage())
                        {
                            if (magickSource.Height != magickTarget.Height || magickSource.Width != magickTarget.Width)
                            {
                                failures.Add(new Failure(resolvedFile, "resolutions does not much with target."));
                            }
                        }
                    }
                }
            }

            return(failures);
        }
Esempio n. 2
0
        public IEnumerable <Failure> Check()
        {
            List <Failure> failures = new List <Failure>();

            foreach (FileExistsConfig config in Config)
            {
                DataResolver resolver = new DataResolver(config.Source);
                resolver.ResolveAdditional("target", config.Target);

                foreach (ResolvedData resolvedFile in resolver.Data)
                {
                    foreach (string pattern in config.Patterns)
                    {
                        ResolvedData resolvedData = resolver.ResolvedData("target", resolvedFile, pattern);

                        if (resolvedData == null)
                        {
                            failures.Add(new Failure(resolvedFile, $"{pattern} does not exist in target data."));
                        }
                    }
                }
            }

            return(failures);
        }
Esempio n. 3
0
        /// <summary>Start building all images.</summary>
        /// <exception cref="InvalidOperationException">If the configuration is malformed.</exception>
        public void Execute()
        {
            Logger.Trace("Executed build command, started working.");

            Build build = Config.Build;

            if (build == null)
            {
                throw new ConfigurationException("Build command was called, but no build configuration was defined, doing nothing.");
            }

            List <DataSource> input = build.Input;

            if (input == null)
            {
                throw new ConfigurationException("Build command was called but build.input configuration was not specified, this is required.");
            }

            DataResolver        resolver      = new DataResolver(input);
            List <ResolvedData> resolvedDatas = new DataResolver(input).Data;

            Logger.Debug("Found {0} files matching collection pattern.", resolvedDatas.Count);

            List <IBuildStep> pipeline = new List <IBuildStep>();

            if (Config.Build.Metadata != null)
            {
                pipeline.Add(new ExifBuildStep(Config));
                pipeline.Add(new IptcBuildStep(Config));
            }

            if (Config.Build.Recolor != null)
            {
                if (Config.Build.Recolor.Mask != null)
                {
                    resolver.ResolveAdditional("masks", Config.Build.Recolor.Mask.Sources);
                }

                pipeline.Add(new RecolorBuildStep(Config));
            }

            if (Config.Build.Resize != null)
            {
                pipeline.Add(new ResizeBuildStep(Config));
            }

            pipeline.Add(new WriteBuildStep());

            Parallel.ForEach(resolvedDatas, (resolvedData) =>
            {
                PipelineContext context = new PipelineContext(resolver, pipeline, resolvedData);
                context.AppendPath("export");

                using (MagickImage magickImage = resolvedData.ToMagickImage())
                {
                    context.Next(magickImage);
                }

                Logger.Info("Finished all exports for {0}.", resolvedData);
            });
        }