protected override PropertyItem CalculateAggregation(IProcessorPipeline pipeline, IEnumerable <ProcessorItem> items) { double minimum = double.MaxValue; Enum unit = null; foreach (ProcessorItem item in items) { PropertyItem property = GetProperty(pipeline, item); if (property == null) { continue; } if (!property.IsNumeric) { pipeline.Output.WriteLine(Level.Warn, "The avg processor can only average numeric properties!"); return(null); } minimum = Math.Min(minimum, property.ValueNumber); unit = property.Unit; } return(new PropertyItem(minimum, unit)); }
public IEnumerable <ProcessorItem> Process(IProcessorPipeline pipeline, IEnumerable <ProcessorItem> items) { foreach (ProcessorItem item in items) { string propertyValue = item.GetProperty(pipeline.PropertyProvider, property).ValueText; Match match = regex.Match(propertyValue); if (match.Success) { item.TryCachePropertyValue(key, CreatePropertyItem(match.Value)); if (match.Groups.Count > 1) { for (int i = 1; i < match.Groups.Count; i++) { Group group = match.Groups[i]; if (!group.Success) { continue; } item.TryCachePropertyValue($"{key}{i - 1}", CreatePropertyItem(group.Value)); } } } yield return(item); } }
protected override PropertyItem CalculateAggregation(IProcessorPipeline pipeline, IEnumerable <ProcessorItem> items) { double total = 0; Enum unit = null; foreach (ProcessorItem item in items) { PropertyItem property = GetProperty(pipeline, item); if (property == null) { continue; } if (!property.IsNumeric) { pipeline.Output.WriteLine(Level.Warn, "The sum processor can only sum numeric properties!"); return(null); } total += property.ValueNumber; unit = property.Unit; } return(new PropertyItem(total, unit)); }
public IEnumerable <ProcessorItem> Process(IProcessorPipeline pipeline, IEnumerable <ProcessorItem> items) { if (!pipeline.Simulate) { File.WriteAllLines(path, items.Select(x => x.Value), Encoding.UTF8); } return(items); }
public IEnumerable <ProcessorItem> Process(IProcessorPipeline pipeline, IEnumerable <ProcessorItem> items) { foreach (ProcessorItem item in items) { item.Value = template.Make(pipeline.PropertyProvider, pipeline.PropertyStore, item); yield return(item); } }
public IEnumerable <ProcessorItem> Process(IProcessorPipeline pipeline, IEnumerable <ProcessorItem> items) { int i = 1; foreach (ProcessorItem item in items) { item.TryCachePropertyValue("index", new PropertyItem(i++, null), true); yield return(item); } }
private IEnumerable <ProcessorItem> Eval(IProcessorPipeline pipeline, string value) { List <IProcessor> processors = pipeline.Interpreter.Eval(value); if (processors.Count > 0) { return(pipeline.Process(processors)); } return(Enumerable.Empty <ProcessorItem>()); }
public IEnumerable <ProcessorItem> Process(IProcessorPipeline pipeline, IEnumerable <ProcessorItem> items) { object selector(ProcessorItem item) { PropertyItem property = item.GetProperty(pipeline.PropertyProvider, itemPropertyName); return(property.IsNumeric ? property.ValueNumber : 0); } return(isDescending ? items.OrderByDescending(selector) : items.OrderBy(selector)); }
public IEnumerable <ProcessorItem> Process(IProcessorPipeline pipeline, IEnumerable <ProcessorItem> items) { if (!File.Exists(path)) { return(items); } IEnumerable <ProcessorItem> fileItems = File.ReadLines(path, Encoding.UTF8).Select(x => new ProcessorItem(x)); return(items.Concat(fileItems)); }
public IEnumerable <ProcessorItem> Process(IProcessorPipeline pipeline, IEnumerable <ProcessorItem> items) { int i = 0; foreach (ProcessorItem item in items) { pipeline.Output.WriteLine(Level.None, $"&-8;{i++,3}:&-^; {item.Value}"); } return(items); }
public IEnumerable <ProcessorItem> Process(IProcessorPipeline pipeline, IEnumerable <ProcessorItem> items) { PropertyItem result = CalculateAggregation(pipeline, items); if (result != null) { string gPropertyName = outputPropertyName ?? $"{Key}_{itemPropertyName}"; pipeline.PropertyStore.SetProperty(gPropertyName, result); } return(items); }
public IEnumerable <ProcessorItem> Process(IProcessorPipeline pipeline, IEnumerable <ProcessorItem> items) { if (pipeline.Simulate) { pipeline.Output.WriteLine(Utility.Level.Info, $"\n&-c;-------- Simulation Mode Active! --------&-^;\n"); } foreach (ProcessorItem item in items) { string srcFilepath = item.Value; string dstFilepath = dstTemplate.Make(pipeline.PropertyProvider, pipeline.PropertyStore, item); pipeline.Output.WriteLine(Utility.Level.Info, $"Copying: &-6;{srcFilepath}&-^; -> &-6;{dstFilepath}&-^;"); if (!pipeline.Simulate) { if (File.Exists(srcFilepath)) { string dir = Path.GetDirectoryName(dstFilepath); if (!string.IsNullOrEmpty(dir)) { Directory.CreateDirectory(dir); } if (!File.Exists(dstFilepath)) { File.Copy(srcFilepath, dstFilepath); } else { pipeline.Output.WriteLine(Utility.Level.Info, $" - &-c;Destination filepath already exists! Ignoring...&-^;"); } } else { pipeline.Output.WriteLine(Utility.Level.Info, $" - &-c;Source filepath doesn't exist! Ignoring...&-^;"); } } } return(items); }
public IEnumerable <ProcessorItem> Process(IProcessorPipeline pipeline, IEnumerable <ProcessorItem> items) { IEnumerable <ProcessorItem> result = appendOutput ? items : Enumerable.Empty <ProcessorItem>(); if (joinInput) { string value = string.Join(" ", items.Select(x => x.Value)); result = result.Concat(Eval(pipeline, value)); } else { foreach (ProcessorItem item in items) { result = result.Concat(Eval(pipeline, item.Value)); } } return(result); }
public IEnumerable <ProcessorItem> Process(IProcessorPipeline pipeline, IEnumerable <ProcessorItem> items) { if (pipeline.Simulate) { pipeline.Output.WriteLine(Level.Info, $"\n&-c;-------- Simulation Mode Active! --------&-^;\n"); } foreach (ProcessorItem item in items) { string path = template.Make(pipeline.PropertyProvider, pipeline.PropertyStore, item); pipeline.Output.WriteLine(Level.Info, $"MkDir: &-6;{path}&-^;"); if (!pipeline.Simulate) { Directory.CreateDirectory(path); } } return(items); }
public IEnumerable <ProcessorItem> Process(IProcessorPipeline pipeline, IEnumerable <ProcessorItem> items) { foreach (ProcessorItem inputItem in items) { if (!Directory.Exists(inputItem.Value)) { continue; } IEnumerable <string> enumerable = isFiles ? Directory.EnumerateFiles(inputItem.Value, "*", searchOption) : Directory.EnumerateDirectories(inputItem.Value, "*", searchOption); foreach (string filepath in enumerable) { yield return(new ProcessorItem(filepath, inputItem.Value)); } } }
public IEnumerable <ProcessorItem> Process(IProcessorPipeline pipeline, IEnumerable <ProcessorItem> items) { return(items.Where(x => glob.IsMatch(x.Value))); }
public IEnumerable <ProcessorItem> Process(IProcessorPipeline pipeline, IEnumerable <ProcessorItem> items) { return(items.Concat(newItems.Select(x => new ProcessorItem(x)))); }
// scan files top >> extract "S(\d\d)E(\d\d)" from @{name} as @{ep} >> set @{ep1} + 51 >> rename "Black Clover - Season @{ep0} - Episode @{ep1}.@{ext}" public IEnumerable <ProcessorItem> Process(IProcessorPipeline pipeline, IEnumerable <ProcessorItem> items) { return(items); }
protected abstract PropertyItem CalculateAggregation(IProcessorPipeline pipeline, IEnumerable <ProcessorItem> items);
public IEnumerable <ProcessorItem> Process(IProcessorPipeline pipeline, IEnumerable <ProcessorItem> items) { System.Diagnostics.ProcessStartInfo info = new System.Diagnostics.ProcessStartInfo() { CreateNoWindow = noWindow, ErrorDialog = false, UseShellExecute = !noWindow, RedirectStandardOutput = noWindow, RedirectStandardError = noWindow }; if (pipeline.Simulate) { pipeline.Output.WriteLine(Utility.Level.Info, $"\n&-c;-------- Simulation Mode Active! --------&-^;\n"); } foreach (ProcessorItem item in items) { string exeFilepath = exeTemplate.Make(pipeline.PropertyProvider, pipeline.PropertyStore, item); string exeArguments = argsTemplate.Make(pipeline.PropertyProvider, pipeline.PropertyStore, item); info.FileName = exeFilepath; info.Arguments = exeArguments; System.Diagnostics.Process process = !pipeline.Simulate ? new System.Diagnostics.Process { StartInfo = info } : null; if (noWindow && !pipeline.Simulate) { process.OutputDataReceived += (p, data) => pipeline.Output.WriteLine(Level.None, data.Data, true); process.ErrorDataReceived += (p, data) => pipeline.Output.WriteLine(Level.None, data.Data, true); } try { process?.Start(); pipeline.Output.WriteLine(Level.None, $"Executing: {exeFilepath} {exeArguments}"); if (noWindow) { process?.BeginErrorReadLine(); process?.BeginOutputReadLine(); } if (wait) { process?.WaitForExit(); } } catch (Win32Exception) { pipeline.Output.WriteLine(Level.Error, $"&-c;Failed to execute: {exeFilepath} {exeArguments}&-^;"); } } return(items); }
protected PropertyItem GetProperty(IProcessorPipeline pipeline, ProcessorItem item) { return(item.GetProperty(pipeline.PropertyProvider, itemPropertyName)); }
public IEnumerable <ProcessorItem> Process(IProcessorPipeline pipeline, IEnumerable <ProcessorItem> items) { return(items.Where(item => filter.Check(pipeline.Output, pipeline.PropertyProvider, pipeline.PropertyStore, item))); }