public string Prepare(IEnumerable <IFile> inputFiles, IEnumerable <IFile> documents, ITransformationRule rule)
{
Logger.Info("=============================");
Logger.Info("START: {0}", rule.Title);
if (inputFiles == null)
{
throw new ArgumentNullException("inputFiles");
}
if (rule == null)
{
throw new ArgumentNullException("rule");
}
Logger.Info("input: order files count: {0}, document files count: {1}", inputFiles.Count(), documents != null ? documents.Count() : 0);
Logger.Info("rule file parsing: {0}", Path.GetFullPath(rule.RuleFilePath));
TransformationRule parsedRule;
try
{
parsedRule = _parcer.Parse(rule);
Logger.Info("rule file parsing: OK (file rules count: {0}, document rules count: {1})",
parsedRule.OrderFileRules != null ? parsedRule.OrderFileRules.Count() : 0,
parsedRule.DocumentFileRules != null ? parsedRule.DocumentFileRules.Count() : 0);
}
catch (Exception ex)
{
Logger.ErrorException(ex.Message, ex);
throw;
}
var replacementValues = new List <KeyValuePair <string, string> >();
if (rule.ReplacementValues != null)
{
replacementValues.AddRange(rule.ReplacementValues);
}
replacementValues.Add(new KeyValuePair <string, string>("%date_now%", DateTime.Now.ToString("yyyy-mm-dd")));
replacementValues.Add(new KeyValuePair <string, string>("%rule_title%", rule.Title));
var workingDirectoryName = parsedRule.CreateRandomSubfolderInOutput ? Path.GetRandomFileName() : string.Empty;
var workingDirectory = Path.Combine(rule.OutputPath, workingDirectoryName);
if (parsedRule.CreateRandomSubfolderInOutput && Directory.Exists(workingDirectory))
{
Directory.Delete(workingDirectory, true);
}
Directory.CreateDirectory(workingDirectory);
Logger.Info("working directory is: {0}", Path.GetFullPath(workingDirectory));
var context = new TaskContext(workingDirectory);
context.CommonParams.Clear();
foreach (var pair in replacementValues)
{
context.CommonParams.Add(pair.Key, pair.Value);
}
if (parsedRule.OrderFileRules != null)
{
Logger.Info("executing order file rules...");
foreach (var orderFileRule in parsedRule.OrderFileRules)
{
orderFileRule.Apply(inputFiles, context);
}
}
if (parsedRule.DocumentFileRules != null && documents != null)
{
Logger.Info("executing document file rules...");
foreach (var documentFileRule in parsedRule.DocumentFileRules)
{
documentFileRule.Apply(documents, context);
}
}
if (parsedRule.ZipResult && parsedRule.CreateRandomSubfolderInOutput)
{
try
{
var resultPath = ZipFolder(workingDirectory);
Directory.Delete(workingDirectory, true);
return(resultPath);
}
catch (Exception) { throw; }
}
else
{
return(workingDirectory);
}
}
internal ProcessingOrder(string orderFolder, OrderManager config)
{
if (Directory.Exists(orderFolder) && File.Exists(orderFolder + "\\" + Constants.OrderInfoXmlFileName))
{
if (!File.Exists(Config.TransformFile))
{
Config.RestoreDefaultTransformFile();
}
var rule = new Rule(config);
var files = new List <IFile>();
var docs = new List <IFile>
{
new ProcessingDoc(orderFolder + "\\" + Constants.OrderInfoXmlFileName, new KeyValuePair <string, string>("%xslt_file_path%", Config.TransformFile))
};
var settings = new XmlReaderSettings();
settings.IgnoreComments = true;
settings.IgnoreProcessingInstructions = true;
settings.IgnoreWhitespace = true;
using (var reader = XmlReader.Create(orderFolder + "\\" + Constants.OrderInfoXmlFileName, settings))
{
reader.ReadStartElement("order");
reader.ReadStartElement("info");
string action = reader.ReadElementString();
if (action != "OrderPhotos")
{
throw new NotSupportedException("Unsupported action.");
}
rule.ReplacementValues.Add(OrderManager.KioskIdTag, reader.ReadElementString());
rule.ReplacementValues.Add(OrderManager.DateTag, reader.ReadElementString().Substring(0, 10));
rule.ReplacementValues.Add(OrderManager.OrderIdTag, reader.ReadElementString());
rule.ReplacementValues.Add(OrderManager.PaperTypeTag, reader.ReadElementString());
rule.ReplacementValues.Add(OrderManager.CropModeTag, reader.ReadElementString());
// orderCost
reader.ReadElementString();
// totalCost
reader.ReadElementString();
reader.ReadEndElement();
reader.ReadStartElement("customer");
rule.ReplacementValues.Add(OrderManager.CustomerNameTag, reader.ReadElementString());
rule.ReplacementValues.Add(OrderManager.CustomerPhoneTag, reader.ReadElementString());
rule.ReplacementValues.Add(OrderManager.CustomerEmailTag, reader.ReadElementString());
reader.ReadEndElement();
reader.ReadStartElement("formats");
while (reader.Name == "format")
{
if (!reader.IsEmptyElement)
{
string format = reader.GetAttribute("name");
string channel = reader.GetAttribute("channel");
reader.Read();
while (reader.Name == "photo")
{
var file = new ProcessingFile(orderFolder + "\\" + reader.GetAttribute("file"));
file.Params.Add(new KeyValuePair <string, string>(OrderManager.FormatTag, format));
file.Params.Add(new KeyValuePair <string, string>(OrderManager.PrintsQuantityTag, reader.GetAttribute("quantity")));
if (config.IsDpof.Value && !string.IsNullOrEmpty(channel))
{
file.Params.Add(new KeyValuePair <string, string>(OrderManager.DpofPSizeTag, format + " " + rule.ReplacementValues[OrderManager.PaperTypeTag]));
file.Params.Add(new KeyValuePair <string, string>(OrderManager.ChannelTag, channel));
}
string[] crop = reader.GetAttribute("crop").Split(',');
file.Params.Add(new KeyValuePair <string, string>("%cropX%", crop[0]));
file.Params.Add(new KeyValuePair <string, string>("%cropY%", crop[1]));
file.Params.Add(new KeyValuePair <string, string>("%cropWidth%", crop[2]));
file.Params.Add(new KeyValuePair <string, string>("%cropHeight%", crop[3]));
files.Add(file);
reader.Read();
}
}
reader.Read();
}
reader.ReadEndElement();
}
Rule = rule;
OrderFiles = files;
OrderDocs = docs;
}
else
{
throw new FileNotFoundException(orderFolder + "\\" + Constants.OrderInfoXmlFileName);
}
}
public TransformationRule Parse(ITransformationRule ruleInfo)
{
if (ruleInfo == null)
{
throw new ArgumentNullException("ruleInfo");
}
if (!File.Exists(ruleInfo.RuleFilePath))
{
throw new FileNotFoundException("Rules file not found.", ruleInfo.RuleFilePath);
}
try
{
var document = new XmlDocument();
document.Load(ruleInfo.RuleFilePath);
var result = new TransformationRule();
var rootNode = document.SelectSingleNode("rule");
result.Title = rootNode.Attributes["title"].Value;
result.ZipResult = rootNode.Attributes["zip"] != null && rootNode.Attributes["zip"].Value == "true";
result.CreateRandomSubfolderInOutput = rootNode.Attributes["createRandomSubfolderInOutput"] == null ||
rootNode.Attributes["createRandomSubfolderInOutput"].Value == "true";
List <FileRule> orderFileRules = null;
List <FileRule> docsFileRules = null;
// processing order files
var orderFilesRulesNode = rootNode.SelectSingleNode("files");
if (orderFilesRulesNode != null)
{
orderFileRules = new List <FileRule>();
var fileRuleNodes = orderFilesRulesNode.SelectNodes("file");
if (fileRuleNodes != null)
{
foreach (XmlNode ruleNode in fileRuleNodes)
{
var fileRule = ParseFileRuleNode(ruleNode);
orderFileRules.Add(fileRule);
}
}
}
// processing document files
var docsFilesRulesNode = rootNode.SelectSingleNode("docs");
if (docsFilesRulesNode != null)
{
docsFileRules = new List <FileRule>();
var fileRuleNodes = docsFilesRulesNode.SelectNodes("file");
if (fileRuleNodes != null)
{
foreach (XmlNode ruleNode in fileRuleNodes)
{
var fileRule = ParseFileRuleNode(ruleNode);
docsFileRules.Add(fileRule);
}
}
}
result.OrderFileRules = orderFileRules;
result.DocumentFileRules = docsFileRules;
return(result);
}
catch (Exception)
{
throw new InvalidDataException("Rules file is not well formatted XML");
}
}
