/// <summary> /// The method returns the value corresponding to the DCO field specified, from the current DCO for the field. /// <param name="DCOTree">DCO Expression in the format [DCO].[page_type].[field_name]</param> /// <returns>The value corresponding to the DCO field specified, from the current DCO.</returns> /// </summary> public override string getDCOValueForField(string DCOTree) { // DCO reference in the template file should adhere to a 3 part string [DCO].[page_type].[field_name] // Parse the DCO reference and extract the page_type and field_name which can then be used to look up in the // current document that is being processed DCOTree = DCOTree.Replace("[", "").Replace("]", ""); char[] sep = { '.' }; string[] dcoArray = DCOTree.Split(sep, 4, StringSplitOptions.None); TDCOLib.DCO page = CurrentDCO.Parent(); string pageID = page.ID; string output = ""; try { // this is to pick up the field from the right page type if (dcoArray[2] == CurrentDCO.ID && dcoArray[1] == page.Type) { output = CurrentDCO.Text; } else { ExportCore.WriteLog(" Current field " + CurrentDCO.ID + " is different from required field which is" + DCOTree); } } catch (Exception exp) { // There could be reference in the template for the documents that are not processed in the current batch // Template in TravelDocs can have reference to a field under Flight but the current batch doesn't have // any flight related input. Alternatively, Flight and Car Rental gets processed but for the Car Rental // data output, there cannot be any Flight reference ExportCore.WriteErrorLog(" Unable to find DCO reference for the field : " + DCOTree); ExportCore.WriteErrorLog(" Error while reading DCO reference: " + exp.ToString()); } return(output); }
public bool Parse() { try { XmlDocument templateXML = new XmlDocument(); templateXML.Load(TemplateFilePath); ExportCore.WriteInfoLog("template file :" + TemplateFilePath); this.NameSpcManager = new XmlNamespaceManager(templateXML.NameTable); this.NameSpcManager.AddNamespace(Constants.SE_NAMESPACE_NAME, Constants.SE_NAMESPACE_URL); this.TemplateRoot = templateXML.DocumentElement; if (this.TemplateRoot.HasChildNodes) { this.HasMoreNodes = true; this.CurrentNode = TemplateRoot.FirstChild; } templateContents = System.IO.File.ReadAllLines(TemplateFilePath); } catch (Exception exp) { ExportCore.WriteErrorLog("Error while parsing the template file, terminating. Details: " + exp.Message); throw new SmartExportException("Error while parsing template file. Please verify the syntax and semantics of the template file."); } return(true); }
public void writeToFile(Dictionary <String, String> singleOutputFileNameMap) { try { // this ckeck is done to prevent empty file getting generated if (outputStringList.Count == 0 && !tempFileNameMap.ContainsKey(templateParser.GetOutputFileName())) { exportCore.WriteLog("Empty content. Skipping writing to file: " + templateParser.GetOutputFileName()); return; } bool clearBuffer = false; string outputFileName = null; string outputFilePath = null; //this scenario happens only when the project doesn't have document and the action is attached at batch level //and the collate batch output flag is false if (null == singleOutputFileNameMap) { string prefix = ""; //names output file with the name of the input file if true if (templateParser.NameBatchOutputAfterInput()) { prefix = Path.GetFileNameWithoutExtension((string)Globals.Instance.GetData(Constants.forLoopString.CURRENTFILE)); } else { //names output file with thevalue sepcified in filename tag or use the default name prefix = templateParser.GetOutputFileName(); } outputFileName = prefix + "_" + DateTime.Now.ToString("yyyy-MM-dd_HH-mm-ss-fffffff") + '.' + templateParser.GetOutputFileExt(); outputFilePath = Path.Combine(templateParser.GetOutputDirectory(), outputFileName); clearBuffer = true; } else { outputFileName = templateParser.GetOutputFileName() + "_" + DateTime.Now.ToString("yyyy-MM-dd_HH-mm-ss-fffffff") + '.' + templateParser.GetOutputFileExt(); outputFilePath = Path.Combine(templateParser.GetOutputDirectory(), templateParser.AppendToFile() ? singleOutputFileNameMap[templateParser.GetOutputFileName()] + "." + templateParser.GetOutputFileExt() : outputFileName); } //If append to file is false and one iteration is complete, then code will rename temp file to actual file name //and delete the entry in the map, so in next iteration new temp file is created for this template //as append to file is false if (!templateParser.AppendToFile() && tempFileNameMap.ContainsKey(templateParser.GetOutputFileName())) { string tempPath = tempFileNameMap[templateParser.GetOutputFileName()]; createOrAppendToFile(tempPath, clearBuffer); File.Move(tempPath, outputFilePath); tempFileNameMap.Remove(templateParser.GetOutputFileName()); return; } //if appendtofile is true and temp map has an entry for temp file, for first iteration data is written in temp file //and then renamed to actual file, for all next iteration the data from the list is added to the actual file //not in temp file. //this condition will pass only for first iteration. if (templateParser.AppendToFile() && tempFileNameMap.ContainsKey(templateParser.GetOutputFileName()) && !File.Exists(outputFilePath)) { string tempPath = tempFileNameMap[templateParser.GetOutputFileName()]; createOrAppendToFile(tempPath, clearBuffer); File.Move(tempPath, outputFilePath); tempFileNameMap[templateParser.GetOutputFileName()] = outputFilePath; return; } //if there are no temp file created then data is flushed to output file here. createOrAppendToFile(outputFilePath, clearBuffer); } catch (System.Exception exp) { exportCore.WriteErrorLog(exp.StackTrace); throw new SmartExportException("Error while writing output to file: " + exp.Message); } }
private bool EvaluateIndividualCondition(string conditionText) { ExportCore.WriteLog(" Evaluating condition " + conditionText); bool response = false; List <string> operands = new List <string>(Regex.Split(conditionText, Constants.ALLOWED_OPERATORS)); // check if there are 2 operands if (3 != operands.Count) { throw new SmartExportException("Unsupported syntax. Check documentation: " + conditionText); } //check if allowed operator are used if (!Regex.Match(operands[1].Trim(), Constants.ALLOWED_OPERATORS).Success) { throw new SmartExportException("Unsupported syntax. Check documentation: " + conditionText); } if (operands[1].Trim() == Constants.Operators.CONTAINS && !operands[0].Trim().Equals(Constants.ConditionString.FILE_PAGE_TYPES)) { throw new SmartExportException("CONTAINS operator can be used only with " + Constants.ConditionString.FILE_PAGE_TYPES + ". Invalid usage: " + conditionText); } Regex rx = new Regex(pattern); for (int i = 0; i < operands.Count; i++) { //replace DCO referencing expressions if (rx.IsMatch(operands[i].Trim())) { string expr = operands[i]; operands[i] = dCODataRetriever.getDCOValue(operands[i].Trim()); if ("" == operands[i]) { ExportCore.WriteLog("Could not find value for " + expr + " in " + conditionText); return(false); } } else if (Constants.ConditionString.DOCUMENT_TYPE == operands[i].Trim()) { operands[i] = dCODataRetriever.getDocumentType(); } else if (Constants.ConditionString.PAGE_TYPE == operands[i].Trim()) { operands[i] = dCODataRetriever.getPageType(); } else if (Constants.ConditionString.TABLE_TYPE == operands[i].Trim()) { operands[i] = dCODataRetriever.getTableType(); } else if (Constants.ConditionString.FILE_PAGE_TYPES == operands[i].Trim()) { operands[i] = dCODataRetriever.getPageTypesInFile(); } else { operands[i] = operands[i].Trim(); } } //check if comparisons are done for same data types string operandOneType = dataTypeChecker.getType(operands[0].Trim()); string operandTwoType = dataTypeChecker.getType(operands[2].Trim()); // allow operations on numeric opernads even if they are not of the same data type if (operandOneType != operandTwoType && dataTypeChecker.numericTypes.Contains(operandOneType) && dataTypeChecker.numericTypes.Contains(operandTwoType)) { operandTwoType = operandOneType = castNumericDataTypes(operandOneType, operandTwoType); } if (operandOneType != operandTwoType) { throw new SmartExportException("Invalid comparisons in : " + conditionText + " " + operandOneType + " " + operands[1] + " " + operandTwoType); } try { response = ExpressionEvaluator.evaluateExpression(operands[0].Trim(), operands[2].Trim(), operandOneType, operands[1].Trim()); } catch (Exception exp) { // Evaluating conditions using this technique is risky (injections) // Moreover, this API is deprecated. This is for the timebeing (to prototype and define the POV) // If conditions do not evaluate properly, write log and skip the condition // TODO: Lexical parser to get the conditions and transform them to c# code constructs string message = "Condition evalution failed for condition:" + conditionText; ExportCore.WriteErrorLog(message); ExportCore.WriteErrorLog(exp.StackTrace); throw new SmartExportException(message); } ExportCore.WriteLog(" Condition " + conditionText + " is evaluated as " + response); return(response); }