public DatabaseIndexedDocument(bool isSystem, bool isComments,
string workingDir)
{
_isSystem = isSystem;
_isComments = isComments;
_dataDir = workingDir;
string keyXPath = null;
string valueXPath = null;
CustomContext context = new CustomContext();
// The following are the usual key/value in the configuration file...
if (_isComments)
{
// <index name="comments" value="/doc/members/member" key="@name" cache="100">
keyXPath = "@name";
valueXPath = "/doc/members/member";
}
else
{
// <index name="reflection" value="/reflection/apis/api" key="@id" cache="10">
keyXPath = "@id";
valueXPath = "/reflection/apis/api";
}
_keyExpression = XPathExpression.Compile(keyXPath);
_keyExpression.SetContext(context);
_valueExpression = XPathExpression.Compile(valueXPath);
_valueExpression.SetContext(context);
if (PersistentDictionaryFile.Exists(_dataDir))
{
PersistentDictionaryFile.DeleteFiles(_dataDir);
}
_plusTree = new PersistentDictionary <string, string>(_dataDir);
}
/// <summary>
/// evaluate xpath using provided XPath navigator and xpath property list
/// </summary>
/// <param name="xpathProperty">xpath property list</param>
/// <param name="navigator">xpath navigator</param>
/// <returns>primitive types or clone of sub-xpath-navigator</returns>
private object EvaluateXPath(string xpath, XPathNavigator navigator)
{
object result = null;
// create an xpath expression
XPathExpression expression = XPathExpression.Compile(xpath);
switch (expression.ReturnType)
{
case XPathResultType.String:
case XPathResultType.Number:
result = navigator.Evaluate(expression);
break;
case XPathResultType.NodeSet:
XPathNodeIterator ni = navigator.Select(expression);
if (ni.Count >= 1)
{
if (ni.MoveNext() == true)
{
if (ni.Current.NodeType.Equals(XPathNodeType.Text) ||
ni.Current.NodeType.Equals(XPathNodeType.Attribute))
{
result = ni.Current.ToString();
}
else
{
result = ni.Current.Clone();
}
}
}
break;
case XPathResultType.Boolean:
result = (bool)navigator.Evaluate(expression);
break;
}
return(result);
}
public override bool Execute()
{
try
{
var document = new XmlDocument();
document.Load(this.XmlFileName);
var navigator = document.CreateNavigator();
var nsResolver = new XmlNamespaceManager(navigator.NameTable);
if (!string.IsNullOrEmpty(this.Prefix) && !string.IsNullOrEmpty(this.Namespace))
{
nsResolver.AddNamespace(this.Prefix, this.Namespace);
}
var expr = XPathExpression.Compile(this.XPath, nsResolver);
var iterator = navigator.Select(expr);
while (iterator.MoveNext())
{
iterator.Current.DeleteSelf();
}
using (var writer = new XmlTextWriter(this.XmlFileName, Encoding.UTF8))
{
writer.Formatting = Formatting.Indented;
document.Save(writer);
writer.Close();
}
}
catch (Exception exception)
{
base.Log.LogErrorFromException(exception);
return(false);
}
base.Log.LogMessage("Updated file '{0}'", new object[] { this.XmlFileName });
return(true);
}
//=====================================================================
/// <inheritdoc />
public override void Initialize(XPathNavigator configuration)
{
// Get the condition
XPathNavigator if_node = configuration.SelectSingleNode("if");
if (if_node == null)
{
throw new ConfigurationErrorsException("You must specify a condition using the <if> element.");
}
string condition_xpath = if_node.GetAttribute("condition", String.Empty);
if (String.IsNullOrEmpty(condition_xpath))
{
throw new ConfigurationErrorsException("You must define a condition attribute on the <if> element");
}
condition = XPathExpression.Compile(condition_xpath);
// Construct the true branch
XPathNavigator then_node = configuration.SelectSingleNode("then");
if (then_node != null)
{
true_branch = BuildAssembler.LoadComponents(then_node);
}
// Construct the false branch
XPathNavigator else_node = configuration.SelectSingleNode("else");
if (else_node != null)
{
false_branch = BuildAssembler.LoadComponents(else_node);
}
// Keep a pointer to the context for future use
context = this.BuildAssembler.Context;
}
public void ProcessRequest(HttpContext ctx)
{
string userName = ctx.Request.QueryString["userName"];
// BAD: Use user-provided data directly in an XPath expression
string badXPathExpr = "//users/user[login/text()='" + userName + "']/home_dir/text()";
XPathExpression.Compile(badXPathExpr);
// GOOD: XPath expression uses variables to refer to parameters
string xpathExpression = "//users/user[login/text()=$username]/home_dir/text()";
XPathExpression xpath = XPathExpression.Compile(xpathExpression);
// Arguments are provided as a XsltArgumentList()
XsltArgumentList varList = new XsltArgumentList();
varList.AddParam("userName", string.Empty, userName);
// CustomContext is an application specific class, that looks up variables in the
// expression from the varList.
CustomContext context = new CustomContext(new NameTable(), varList)
xpath.SetContext(context);
}
protected override void Load(XPathNavigator navigator)
{
base.Load(navigator);
XmlNamespaceManager nsManager = new XmlNamespaceManager(navigator.NameTable);
nsManager.AddNamespace("p", Settings.NamespaceUri);
XPathExpression exp = XPathExpression.Compile("/p:settings/p:file", nsManager);
foreach (XPathNavigator node in navigator.Select(exp))
{
string file = node.GetAttribute("name", "");
if (!string.IsNullOrEmpty(file))
{
string text = node.GetAttribute("date", "");
DateTime date;
if (!string.IsNullOrEmpty(text) && DateTime.TryParse(text, out date))
{
this.recentFile[file] = date;
}
}
}
this.IsFirstRun = false;
}
public LiveExampleComponent(BuildAssembler assembler, XPathNavigator configuration)
: base(assembler, configuration)
{
XPathNavigator parsnip_node = configuration.SelectSingleNode("parsnip");
string approvedFile = null;
if (parsnip_node != null)
{
approvedFile = parsnip_node.GetAttribute("approved-file", String.Empty);
string omitBadExamplesValue = parsnip_node.GetAttribute("omit-bad-examples", String.Empty);
if (!string.IsNullOrEmpty(omitBadExamplesValue))
{
omitBadExamples = Boolean.Parse(omitBadExamplesValue);
}
//string runBadExamplesValue = parsnip_node.GetAttribute("run-bad-examples", String.Empty);
//if (!string.IsNullOrEmpty(runBadExamplesValue))
// runBadExamples = Boolean.Parse(runBadExamplesValue);
}
if (string.IsNullOrEmpty(approvedFile))
{
WriteMessage(MessageLevel.Warn, "No approved samples file specified; all available samples will be included.");
}
else
{
LoadApprovedFile(approvedFile);
}
context = new CustomContext();
context.AddNamespace("ddue", "http://ddue.schemas.microsoft.com/authoring/2003/5");
selector = XPathExpression.Compile("//ddue:codeReference");
selector.SetContext(context);
}
private XPathExpression createExpression(XmlDocument xmlDoc, XPathNavigator nav, string xpath)
{
XmlNamespaceManager xmlnsManager = new XmlNamespaceManager(xmlDoc.NameTable);
if (_chkUseNamespaces.IsChecked == true)
{
nav.MoveToFollowing(XPathNodeType.Element);
IDictionary <string, string> whatever = nav.GetNamespacesInScope(XmlNamespaceScope.All);
if (whatever != null)
{
foreach (KeyValuePair <string, string> keyValuePair in whatever)
{
xmlnsManager.AddNamespace(keyValuePair.Key, keyValuePair.Value);
}
}
}
else
{
Debug.Assert(_chkUseUserdefinedFunctions.IsChecked == true);
xmlnsManager = getContext();
}
return(XPathExpression.Compile(xpath, xmlnsManager));
}
public void Run(RegressionEnvironment env)
{
var ctx = new XPathNamespaceContext();
ctx.AddNamespace("n0", "samples:schemas:simpleSchema");
XmlNode node = SupportXML.GetDocument().DocumentElement;
var pathExprOne = XPathExpression.Compile("/n0:simpleEvent/n0:nested1", ctx);
var pathExprOneIterator = node.CreateNavigator().Select(pathExprOne);
Assert.That(pathExprOne.ReturnType, Is.EqualTo(XPathResultType.NodeSet));
Assert.That(pathExprOneIterator.MoveNext(), Is.True);
Assert.That(pathExprOneIterator.Current.UnderlyingObject, Is.InstanceOf<XmlElement>());
Assert.That(pathExprOneIterator.Current.NodeType, Is.EqualTo(XPathNodeType.Element));
//System.out.println("Result:\n" + SchemaUtil.serialize(result));
var pathExprTwo = XPathExpression.Compile("/n0:simpleEvent/n0:nested1/n0:prop1", ctx);
var pathExprTwoIterator = node.CreateNavigator().Select(pathExprTwo);
Assert.That(pathExprTwoIterator.MoveNext(), Is.True);
Assert.That(pathExprTwoIterator.Current.UnderlyingObject, Is.InstanceOf<XmlElement>());
Assert.That(pathExprTwoIterator.Current.NodeType, Is.EqualTo(XPathNodeType.Element));
Assert.That(pathExprTwoIterator.Current.MoveToFirstChild(), Is.True);
Assert.That(pathExprTwoIterator.Current.NodeType, Is.EqualTo(XPathNodeType.Text));
Assert.That(pathExprTwoIterator.Current.TypedValue, Is.EqualTo("SAMPLE_V1"));
//System.out.println("Result 2: <" + resultTwo + ">");
var pathExprThree = XPathExpression.Compile("/n0:simpleEvent/n0:nested3", ctx);
var pathExprThreeIterator = node.CreateNavigator().Select(pathExprThree);
Assert.That(pathExprThreeIterator.MoveNext(), Is.True);
Assert.That(pathExprThreeIterator.Current.UnderlyingObject, Is.InstanceOf<XmlElement>());
Assert.That(pathExprThreeIterator.Current.NodeType, Is.EqualTo(XPathNodeType.Element));
Assert.That(pathExprThreeIterator.Current.HasChildren, Is.True);
//System.out.println("Result 3: <" + resultThree + ">");
}
public void processRequest()
{
using (SqlConnection connection = new SqlConnection(""))
{
connection.Open();
SqlCommand customerCommand = new SqlCommand("SELECT * FROM customers", connection);
SqlDataReader customerReader = customerCommand.ExecuteReader();
while (customerReader.Read())
{
string userName = customerReader.GetString(1);
string password = customerReader.GetString(2);
// BAD: User input used directly in an XPath expression
XPathExpression.Compile("//users/user[login/text()='" + userName + "' and password/text() = '" + password + "']/home_dir/text()");
XmlNode xmlNode = null;
// BAD: User input used directly in an XPath expression to SelectNodes
xmlNode.SelectNodes("//users/user[login/text()='" + userName + "' and password/text() = '" + password + "']/home_dir/text()");
// GOOD: Uses parameters to avoid including user input directly in XPath expression
XPathExpression.Compile("//users/user[login/text()=$username]/home_dir/text()");
}
customerReader.Close();
}
}
public IfThenComponent(BuildAssembler assembler, XPathNavigator configuration) : base(assembler, configuration)
{
// get the condition
XPathNavigator if_node = configuration.SelectSingleNode("if");
if (if_node == null)
{
throw new ConfigurationErrorsException("You must specify a condition using the <if> element.");
}
string condition_xpath = if_node.GetAttribute("condition", String.Empty);
if (String.IsNullOrEmpty(condition_xpath))
{
throw new ConfigurationErrorsException();
}
condition = XPathExpression.Compile(condition_xpath);
// construct the true branch
XPathNavigator then_node = configuration.SelectSingleNode("then");
if (then_node != null)
{
true_branch = BuildAssembler.LoadComponents(then_node);
}
// construct the false branch
XPathNavigator else_node = configuration.SelectSingleNode("else");
if (else_node != null)
{
false_branch = BuildAssembler.LoadComponents(else_node);
}
// keep a pointer to the context for future use
context = assembler.Context;
}
/// <summary>
/// Selects a node set, using the specified XPath expression.
/// </summary>
/// <param name="navigator">A source XPathNavigator.</param>
/// <param name="expression">An XPath expression.</param>
/// <param name="variables">A set of XPathVariables.</param>
/// <returns>An iterator over the nodes matching the specified expression.</returns>
public static XPathNodeIterator Select(this XPathNavigator navigator, string expression, params XPathVariable[] variables)
{
if (variables == null || variables.Length == 0 || variables[0] == null)
{
return(navigator.Select(expression));
}
// Reflector shows that the standard XPathNavigator.Compile method just does
// return XPathExpression.Compile(xpath);
// only difference is, XPathNavigator.Compile is virtual so it could be overridden
// by a class inheriting from XPathNavigator... there does not seem to be any
// doing it in the Framework, though... so we'll assume it's much cleaner to use
// the static compile:
var compiled = XPathExpression.Compile(expression);
var context = new DynamicContext();
foreach (var variable in variables)
{
context.AddVariable(variable.Name, variable.Value);
}
compiled.SetContext(context);
return(navigator.Select(compiled));
}
public ConceptualMathComponent(BuildAssembler assembler,
XPathNavigator configuration) : base(assembler, configuration, true)
{
try
{
if (_latexFormatter != null)
{
_xsltContext = new CustomContext();
_xsltContext.AddNamespace("ddue",
"http://ddue.schemas.microsoft.com/authoring/2003/5");
_xpathSelector = XPathExpression.Compile(
"//ddue:math[starts-with(@address, 'Math')]");
_xpathSelector.SetContext(_xsltContext);
MathController.Create("conceptual", _numberShow,
_numberIncludesPage, _numberByPage, _numberFormat);
}
}
catch (Exception ex)
{
this.WriteMessage(MessageLevel.Error, ex);
}
}
public static CompiledXPath Compile(string path)
{
if (null == path)
{
throw Error.ArgumentNull("path");
}
// Compile whole path to catch errors
var result = new CompiledXPath();
result.Path = XPathExpression.Compile(path);
// Try to split into individual path steps
var tokenizer = new Tokenizer(path);
if (!ParsePath(tokenizer, result))
{
result.MakeNotCreatable();
}
// Finish compilation
result.Prepare();
return(result);
}
//=====================================================================
/// <inheritdoc />
public override void Initialize(XPathNavigator configuration)
{
TargetDictionary newTargets;
ReferenceLinkType type;
string attrValue, id;
targets = new TargetTypeDictionary();
resolver = new LinkTextResolver(targets);
// Get the shared instances dictionary. Create it if it doesn't exist.
if (BuildComponentCore.Data.ContainsKey(SharedReferenceTargetsId))
{
sharedTargets = BuildComponentCore.Data[SharedReferenceTargetsId] as Dictionary <string, TargetDictionary>;
}
if (sharedTargets == null)
{
BuildComponentCore.Data[SharedReferenceTargetsId] = sharedTargets = new Dictionary <string, TargetDictionary>();
}
// base-url is an xpath expression applied against the current document to pick up the save location of the
// document. If specified, local links will be made relative to the base-url.
string baseUrlValue = configuration.GetAttribute("base-url", String.Empty);
if (!String.IsNullOrEmpty(baseUrlValue))
{
baseUrl = XPathExpression.Compile(baseUrlValue);
}
// hrefFormat is a string format that is used to format the value of local href attributes. The
// default is "{0}.htm" if not specified.
hrefFormat = (string)configuration.Evaluate("string(hrefFormat/@value)");
if (String.IsNullOrWhiteSpace(hrefFormat))
{
hrefFormat = "{0}.htm";
}
// The container XPath can be replaced; this is useful
string containerValue = configuration.GetAttribute("container", String.Empty);
if (!String.IsNullOrEmpty(containerValue))
{
XmlTargetDictionaryUtilities.ContainerExpression = containerValue;
}
XPathNodeIterator targetsNodes = configuration.Select("targets");
#if DEBUG
this.WriteMessage(MessageLevel.Diagnostic, "Loading reference link target info");
DateTime startLoad = DateTime.Now;
#endif
foreach (XPathNavigator targetsNode in targetsNodes)
{
// Get target type
attrValue = targetsNode.GetAttribute("type", String.Empty);
if (String.IsNullOrEmpty(attrValue))
{
this.WriteMessage(MessageLevel.Error, "Each targets element must have a type attribute " +
"that specifies which type of links to create");
}
if (!Enum.TryParse <ReferenceLinkType>(attrValue, true, out type))
{
this.WriteMessage(MessageLevel.Error, "'{0}' is not a supported reference link type",
attrValue);
}
// Check for shared instance by ID. If not there, create it and add it.
id = targetsNode.GetAttribute("id", String.Empty);
if (!sharedTargets.TryGetValue(id, out newTargets))
{
this.WriteMessage(MessageLevel.Info, "Loading {0} reference link type targets", type);
newTargets = this.CreateTargetDictionary(targetsNode);
sharedTargets[newTargets.DictionaryId] = newTargets;
}
targets.Add(type, newTargets);
}
#if DEBUG
TimeSpan loadTime = (DateTime.Now - startLoad);
this.WriteMessage(MessageLevel.Diagnostic, "Load time: {0} seconds", loadTime.TotalSeconds);
// Dump targets for comparison to other versions
// targets.DumpTargetDictionary(Path.GetFullPath("TargetDictionary.xml"));
// Serialization test
// targets.SerializeDictionary(Directory.GetCurrentDirectory());
#endif
// Getting the count from a database cache can be expensive so only report it if it will be seen
if (this.BuildAssembler.VerbosityLevel == MessageLevel.Info)
{
this.WriteMessage(MessageLevel.Info, "{0} total reference link targets", targets.Count);
}
if (targets.NeedsMsdnResolver)
{
this.WriteMessage(MessageLevel.Info, "Creating MSDN URL resolver");
msdnResolver = this.CreateMsdnResolver(configuration);
string localeValue = (string)configuration.Evaluate("string(locale/@value)");
if (msdnResolver != null && !String.IsNullOrWhiteSpace(localeValue))
{
msdnResolver.Locale = localeValue;
}
}
linkTarget = (string)configuration.Evaluate("string(linkTarget/@value)");
if (String.IsNullOrWhiteSpace(linkTarget))
{
linkTarget = "_blank";
}
}
//=====================================================================
/// <inheritdoc />
public override void Initialize(XPathNavigator configuration)
{
XPathNavigator nav;
string attrValue;
Assembly asm = Assembly.GetExecutingAssembly();
FileVersionInfo fvi = FileVersionInfo.GetVersionInfo(asm.Location);
this.WriteMessage(MessageLevel.Info, "[{0}, version {1}]\r\n IntelliSense Component. " +
"Copyright \xA9 2006-2015, Eric Woodruff, All Rights Reserved.\r\n" +
" https://GitHub.com/EWSoftware/SHFB", fvi.ProductName, fvi.ProductVersion);
outputFolder = String.Empty;
namespacesFilename = "Namespaces";
assemblyExpression = XPathExpression.Compile("/document/reference/containers/library/@assembly");
subgroupExpression = XPathExpression.Compile("string(/document/reference/apidata/@subgroup)");
elementsExpression = XPathExpression.Compile("/document/reference/elements/element");
summaryExpression = XPathExpression.Compile("summary");
paramExpression = XPathExpression.Compile("param");
typeparamExpression = XPathExpression.Compile("typeparam");
returnsExpression = XPathExpression.Compile("returns");
valueExpression = XPathExpression.Compile("value");
exceptionExpression = XPathExpression.Compile("exception");
codeContractsExpression = XPathExpression.Compile("requires|ensures|ensuresOnThrow|pure|invariant|" +
"getter|setter");
nav = configuration.SelectSingleNode("output");
if (nav != null)
{
attrValue = nav.GetAttribute("includeNamespaces", String.Empty);
if (!String.IsNullOrEmpty(attrValue) && !Boolean.TryParse(attrValue, out includeNamespaces))
{
throw new ConfigurationErrorsException("You must specify a Boolean value for the <output> " +
"'includeNamespaces' attribute.");
}
attrValue = nav.GetAttribute("folder", String.Empty);
if (!String.IsNullOrEmpty(attrValue))
{
outputFolder = Environment.ExpandEnvironmentVariables(attrValue);
if (!Directory.Exists(outputFolder))
{
Directory.CreateDirectory(outputFolder);
}
}
attrValue = nav.GetAttribute("namespacesFile", String.Empty);
if (!String.IsNullOrEmpty(attrValue))
{
namespacesFilename = attrValue;
}
// Allow limiting the writer task collection to conserve memory
attrValue = nav.GetAttribute("boundedCapacity", String.Empty);
if (!String.IsNullOrWhiteSpace(attrValue) && Int32.TryParse(attrValue, out int boundedCapacity) &&
boundedCapacity > 0)
{
commentsList = new BlockingCollection <CommentsInfo>(boundedCapacity);
}
}
// Use a pipeline task to allow the actual saving to occur while other topics are being generated
commentsWriter = Task.Run(() => WriteComments());
}
// the actual work of the component
public override void Apply(XmlDocument document, string key)
{
// set the key in the XPath context
context["key"] = key;
// perform each copy action
foreach (CopyCommand copy_command in copy_commands)
{
// get the source comment
XPathExpression key_expression = copy_command.Key.Clone();
key_expression.SetContext(context);
// Console.WriteLine(key_expression.Expression);
string key_value = (string)document.CreateNavigator().Evaluate(key_expression);
// Console.WriteLine("got key '{0}'", key_value);
XPathNavigator data = copy_command.Index.GetContent(key_value);
if (data == null && copy_command.IgnoreCase == "true")
{
data = copy_command.Index.GetContent(key_value.ToLower());
}
// notify if no entry
if (data == null)
{
WriteMessage(copy_command.MissingEntry, String.Format("No index entry found for key '{0}'.", key_value));
continue;
}
// get the target node
String target_xpath = copy_command.Target.Clone().ToString();
XPathExpression target_expression = XPathExpression.Compile(string.Format(target_xpath, key_value));
target_expression.SetContext(context);
XPathNavigator target = document.CreateNavigator().SelectSingleNode(target_expression);
// notify if no target found
if (target == null)
{
WriteMessage(copy_command.MissingTarget, String.Format("Target node '{0}' not found.", target_expression.Expression));
continue;
}
// get the source nodes
XPathExpression source_expression = copy_command.Source.Clone();
source_expression.SetContext(context);
XPathNodeIterator sources = data.CreateNavigator().Select(source_expression);
// append the source nodes to the target node
int source_count = 0;
foreach (XPathNavigator source in sources)
{
source_count++;
// If attribute=true, add the source attributes to current target.
// Otherwise append source as a child element to target
if (copy_command.Attribute == "true" && source.HasAttributes)
{
string source_name = source.LocalName;
XmlWriter attributes = target.CreateAttributes();
source.MoveToFirstAttribute();
string attrFirst = target.GetAttribute(string.Format("{0}_{1}", source_name, source.Name), string.Empty);
if (string.IsNullOrEmpty(attrFirst))
{
attributes.WriteAttributeString(string.Format("{0}_{1}", source_name, source.Name), source.Value);
}
while (source.MoveToNextAttribute())
{
string attrNext = target.GetAttribute(string.Format("{0}_{1}", source_name, source.Name), string.Empty);
if (string.IsNullOrEmpty(attrNext))
{
attributes.WriteAttributeString(string.Format("{0}_{1}", source_name, source.Name), source.Value);
}
}
attributes.Close();
}
else
{
target.AppendChild(source);
}
}
// notify if no source found
if (source_count == 0)
{
WriteMessage(copy_command.MissingSource, String.Format("Source node '{0}' not found.", source_expression.Expression));
}
foreach (CopyComponent component in components)
{
component.Apply(document, key);
}
}
}
//-------------------------------------------------------------------------------------------------------------------------
//
//-------------------------------------------------------------------------------------------------------------------------
/// <summary>
/// 국세청으로 부터 전달 된 메시지를 기반으로 ISSUING, RESPONSE, RESULT 테이블을 Update 합니다.
/// </summary>
/// <param name="p_xmldoc"></param>
/// <param name="p_request_date"></param>
/// <param name="o_error"></param>
/// <returns></returns>
public bool DoSaveRequestAck(XmlDocument p_xmldoc, DateTime p_request_date, out string o_error)
{
var _result = false;
o_error = "";
try
{
IssuingTbl.Clear();
ResponseTbl.Clear();
ResultTbl.Clear();
XmlNamespaceManager _nsmgr = new XmlNamespaceManager(p_xmldoc.NameTable);
_nsmgr.AddNamespace("etax", XSignature.SNG.SignNameCollections[""]);
XPathExpression _xexpr = XPathExpression.Compile("//etax:TaxInvoiceResponse/etax:ResultDocument");
_xexpr.SetContext(_nsmgr);
DataRow _responseRow = ResponseTbl.NewRow();
{
_responseRow["totalCount"] = 0;
_responseRow["successCount"] = 0;
_responseRow["failCount"] = 0;
}
XPathNavigator _nav = p_xmldoc.CreateNavigator().SelectSingleNode(_xexpr);
if (_nav.MoveToChild(XPathNodeType.Element) == true)
{
do
{
if (_nav.Name == "ValidationDocument")
{
DataRow _resultRow = ResultTbl.NewRow();
{
XPathNodeIterator _iter = _nav.SelectChildren(XPathNodeType.Element);
while (_iter.MoveNext() == true)
{
string _name = _iter.Current.Name;
{
if (_name == "IssueID")
{
_name = "issueId";
}
else if (_name == "ResultStatusCode")
{
_name = "resultStatus";
}
}
if (_resultRow.Table.Columns.IndexOf(_name) >= 0)
{
string _value = _iter.Current.Value;
if (_resultRow.Table.Columns[_name].DataType == typeof(DateTime))
{
_resultRow[_name] = DateTime.ParseExact(_value, "yyyyMMddHHmmss", System.Globalization.CultureInfo.CurrentCulture);
}
else
{
_resultRow[_name] = _value;
}
}
}
_resultRow["isDone"] = "F";
_resultRow["created"] = p_request_date;
ResultTbl.Rows.Add(_resultRow);
}
var _issuingRow = IssuingTbl.NewRow();
{
// row.RowState Add상태를 제거하기 위해서 Temp자료를 넣는다.
_issuingRow["issueId"] = _resultRow["issueId"];
_issuingRow["isNTSConfirm"] = "X";
_issuingRow["isNTSSuccess"] = "X";
_issuingRow["ntsConfirmDate"] = DateTime.MinValue;
IssuingTbl.Rows.Add(_issuingRow);
_issuingRow.AcceptChanges();
_issuingRow["isNTSConfirm"] = "T";
_issuingRow["isNTSSuccess"] = "F";
string _status = Convert.ToString(_resultRow["resultStatus"]);
if (_status == "SUC001" || _status == "SYN003")
{
_issuingRow["isNTSSuccess"] = "T";
_resultRow["isDone"] = "T";
}
_issuingRow["ntsConfirmDate"] = p_request_date;
}
}
else
{
string _name = _nav.Name;
{
if (_name == "RefSubmitID")
{
_name = "submitId";
}
else if (_name == "ReceiptID")
{
_name = "receiptId";
}
else if (_name == "TypeCode")
{
_name = "typeCode";
}
else if (_name == "ResponseDateTime")
{
_name = "responseTime";
}
else if (_name == "ProcessStatusCode")
{
_name = "processStatus";
}
else if (_name == "FailReasonStatusCode")
{
_name = "failReason";
}
else if (_name == "TotalCountQuantity")
{
_name = "totalCount";
}
else if (_name == "SuccessCountQuantity")
{
_name = "successCount";
}
else if (_name == "FailCountQuantity")
{
_name = "failCount";
}
}
if (_responseRow.Table.Columns.IndexOf(_name) >= 0)
{
string _value = _nav.Value;
if (_responseRow.Table.Columns[_name].DataType == typeof(DateTime))
{
_responseRow[_name] = DateTime.ParseExact(_value, "yyyyMMddHHmmss", System.Globalization.CultureInfo.CurrentCulture);
}
else
{
_responseRow[_name] = _value;
}
}
}
}while (_nav.MoveToNext(XPathNodeType.Element));
ResponseTbl.Rows.Add(_responseRow);
LDltaHelper.InsertDeltaSet(UAppHelper.ConnectionString, ResponseSet);
}
o_error = String.Format("Update result deltaSet: {0}, {1} record(s)", ResponseTbl.Rows[0]["submitId"], ResultTbl.Rows.Count);
_result = true;
}
catch (Exception ex)
{
if (ex.InnerException != null)
{
o_error = ex.InnerException.Message;
}
else
{
o_error = ex.Message;
}
}
return(_result);
}
//=====================================================================
/// <summary>
/// Constructor.
/// </summary>
/// <param name="assembler">A reference to the build assembler.</param>
/// <param name="configuration">The configuration information</param>
public IntelliSenseComponent(BuildAssembler assembler,
XPathNavigator configuration) : base(assembler, configuration)
{
XPathNavigator nav;
string attrValue;
Assembly asm = Assembly.GetExecutingAssembly();
FileVersionInfo fvi = FileVersionInfo.GetVersionInfo(asm.Location);
base.WriteMessage(MessageLevel.Info, String.Format(
CultureInfo.InvariantCulture,
"\r\n [{0}, version {1}]\r\n IntelliSense Component. " +
"{2}\r\n http://SHFB.CodePlex.com", fvi.ProductName,
fvi.ProductVersion, fvi.LegalCopyright));
outputFolder = String.Empty;
namespacesFilename = "Namespaces";
this.writers = new Dictionary <string, XmlWriter>();
assemblyExpression = XPathExpression.Compile(
"/document/reference/containers/library/@assembly");
subgroupExpression = XPathExpression.Compile(
"string(/document/reference/apidata/@subgroup)");
elementsExpression = XPathExpression.Compile(
"/document/reference/elements/element");
summaryExpression = XPathExpression.Compile("summary");
paramExpression = XPathExpression.Compile("param");
typeparamExpression = XPathExpression.Compile("typeparam");
returnsExpression = XPathExpression.Compile("returns");
exceptionExpression = XPathExpression.Compile("exception");
nav = configuration.SelectSingleNode("output");
if (nav != null)
{
attrValue = nav.GetAttribute("includeNamespaces",
String.Empty);
if (!String.IsNullOrEmpty(attrValue) && !Boolean.TryParse(
attrValue, out includeNamespaces))
{
throw new ConfigurationErrorsException("You must " +
"specify a Boolean value for the <output> " +
"'includeNamespaces' attribute.");
}
attrValue = nav.GetAttribute("folder", String.Empty);
if (!String.IsNullOrEmpty(attrValue))
{
outputFolder = Environment.ExpandEnvironmentVariables(
attrValue);
if (!Directory.Exists(outputFolder))
{
Directory.CreateDirectory(outputFolder);
}
}
attrValue = nav.GetAttribute("namespacesFile", String.Empty);
if (!String.IsNullOrEmpty(attrValue))
{
namespacesFilename = attrValue;
}
}
}
//=====================================================================
/// <summary>
/// Constructor
/// </summary>
/// <param name="parent">The parent build component</param>
/// <param name="sourceXPath">The source XPath expression</param>
/// <param name="targetXPath">The target XPath expression</param>
protected CopyCommand(BuildComponentCore parent, string sourceXPath, string targetXPath)
{
this.ParentComponent = parent;
this.Source = XPathExpression.Compile(sourceXPath);
this.Target = XPathExpression.Compile(targetXPath);
}
private void InitializeSettings(XmlTextReader settingsXml)
{
XmlTextReader dvdProfilerSettings = null;
bool disposeReader = false;
try
{
if (settingsXml != null)
{
dvdProfilerSettings = settingsXml;
}
else
{
string path = Path.Combine(SDKUtilities.PluginsDirectory, "DVDProfilerSettings.xml");
if (File.Exists(path))
{
disposeReader = true;
dvdProfilerSettings = new XmlTextReader(path);
}
}
if (dvdProfilerSettings != null)
{
while (dvdProfilerSettings.Read())
{
if (dvdProfilerSettings.NodeType != XmlNodeType.Element)
{
continue;
}
switch (dvdProfilerSettings.Name)
{
case "imagesPath":
imagesPath = (dvdProfilerSettings.ReadInnerXml());
break;
case "tag":
string tagName = dvdProfilerSettings.GetAttribute("name");
string tagExcludedName = dvdProfilerSettings.GetAttribute("excludedName");
string tagXPath = dvdProfilerSettings.GetAttribute("xpath");
if (string.IsNullOrEmpty(tagName) && string.IsNullOrEmpty(tagExcludedName))
{
SDKUtilities.DebugLine("[DVDProfilerImporter] Tag setting missing name");
AddError("Tag missing name or excludeName attribute in DVDProfilerSettings.xml");
}
if (string.IsNullOrEmpty(tagXPath))
{
SDKUtilities.DebugLine("[DVDProfilerImporter] Tag setting missing xpath");
AddError("Tag missing xpath attribute in DVDProfilerSettings.xml");
}
if (!string.IsNullOrEmpty(tagXPath))
{
try
{
tagDefinitions.Add(new TagDefinition
{
Name = tagName,
ExcludedName = tagExcludedName,
XPath = XPathExpression.Compile(tagXPath)
});
}
catch (ArgumentException e)
{
initializationErrors.Add(e);
}
catch (XPathException e)
{
initializationErrors.Add(e);
}
}
break;
}
}
}
}
catch (Exception e)
{
SDKUtilities.DebugLine("[DVDProfilerImporter] Unable to open DVDProfilerSettings.xml file: {0}",
e.Message);
initializationErrors.Add(e);
}
finally
{
if (disposeReader && dvdProfilerSettings != null)
{
dvdProfilerSettings.Close();
}
}
}
//=====================================================================
/// <inheritdoc />
public override void Initialize(XPathNavigator configuration)
{
settings.Encoding = Encoding.UTF8;
settings.CloseOutput = true;
// Load the target path format
XPathNavigator saveNode = configuration.SelectSingleNode("save");
if (saveNode == null)
{
throw new ConfigurationErrorsException("When instantiating a save component, you must specify " +
"a the target file using the <save> element.");
}
string baseValue = saveNode.GetAttribute("base", String.Empty);
if (!String.IsNullOrWhiteSpace(baseValue))
{
basePath = Path.GetFullPath(Environment.ExpandEnvironmentVariables(baseValue));
}
string pathValue = saveNode.GetAttribute("path", String.Empty);
if (String.IsNullOrWhiteSpace(pathValue))
{
base.WriteMessage(MessageLevel.Error, "Each save element must have a path attribute specifying " +
"an XPath expression that evaluates to the location to save the file.");
}
pathExpression = XPathExpression.Compile(pathValue);
string selectValue = saveNode.GetAttribute("select", String.Empty);
if (!String.IsNullOrWhiteSpace(selectValue))
{
settings.ConformanceLevel = ConformanceLevel.Auto;
selectExpression = XPathExpression.Compile(selectValue);
}
// If true, indent the rendered HTML (debugging aid)
string indentValue = saveNode.GetAttribute("indent", String.Empty);
if (!String.IsNullOrWhiteSpace(indentValue))
{
settings.Indent = Convert.ToBoolean(indentValue, CultureInfo.InvariantCulture);
}
// If true or not set, omit the XML declaration
string omitValue = saveNode.GetAttribute("omit-xml-declaration", String.Empty);
if (!String.IsNullOrWhiteSpace(omitValue))
{
settings.OmitXmlDeclaration = Convert.ToBoolean(omitValue, CultureInfo.InvariantCulture);
}
// If true, this adds a default namespace for XHTML. Required by Help Viewer documentation.
string addXhtmlDeclaration = saveNode.GetAttribute("add-xhtml-namespace", String.Empty);
if (!String.IsNullOrWhiteSpace(addXhtmlDeclaration))
{
writeXhtmlNamespace = Convert.ToBoolean(addXhtmlDeclaration, CultureInfo.InvariantCulture);
}
// By default, the output is serialized using the default XML rules. This attribute can be set to
// override that with a different output method such as HTML. While this will prevent it from
// converting empty elements to self-closing elements, it can have unintended side-effects such as
// converting self-closing elements to full opening/closing empty elements and using non-XHTML
// compliant versions of elements such as <br>, <hr>, and <link>. The empty element issue can be
// solved using an "<xsl:comment />" or "<xsl:text> </xsl:text>" element in the XSL transformations
// thus avoiding the other side-effects of enabling the HTML output method.
string outputMethod = saveNode.GetAttribute("outputMethod", String.Empty);
if (!String.IsNullOrWhiteSpace(outputMethod))
{
XmlOutputMethod method;
if (!Enum.TryParse(outputMethod, true, out method))
{
throw new ConfigurationErrorsException("The specified output method is not valid for the " +
"save component");
}
// This isn't a publicly settable property so we have to resort to reflection
var propertyInfo = typeof(XmlWriterSettings).GetProperty("OutputMethod", BindingFlags.Instance |
BindingFlags.Public | BindingFlags.NonPublic);
propertyInfo.SetValue(settings, method, null);
}
}
protected MediaComponent(BuildAssembler assembler, XPathNavigator configuration)
: base(assembler, configuration)
{
_artIdExpression = XPathExpression.Compile("string(@id)");
_artFileExpression = XPathExpression.Compile("string(image/@file)");
_artTextExpression = XPathExpression.Compile("string(image/altText)");
_artTargets = new Dictionary <string, MediaTarget>(
StringComparer.OrdinalIgnoreCase);
XPathNodeIterator targetsNodes = configuration.Select("targets");
foreach (XPathNavigator targetsNode in targetsNodes)
{
string input = targetsNode.GetAttribute("input", String.Empty);
if (String.IsNullOrEmpty(input))
{
this.WriteMessage(MessageLevel.Error,
"Each targets element must have an input attribute specifying a directory containing art files.");
}
input = Environment.ExpandEnvironmentVariables(input);
if (!Directory.Exists(input))
{
this.WriteMessage(MessageLevel.Error, String.Format(
"The art input directory '{0}' does not exist.", input));
}
string baseOutputPath = targetsNode.GetAttribute(
"baseOutput", String.Empty);
if (!String.IsNullOrEmpty(baseOutputPath))
{
baseOutputPath = Path.GetFullPath(
Environment.ExpandEnvironmentVariables(baseOutputPath));
}
string outputPathValue = targetsNode.GetAttribute(
"outputPath", String.Empty);
if (string.IsNullOrEmpty(outputPathValue))
{
this.WriteMessage(MessageLevel.Error,
"Each targets element must have an output attribute specifying a directory in which to place referenced art files.");
}
XPathExpression outputXPath = XPathExpression.Compile(
outputPathValue);
string linkValue = targetsNode.GetAttribute("link", String.Empty);
if (String.IsNullOrEmpty(linkValue))
{
linkValue = "../art";
}
//linkValue = Environment.ExpandEnvironmentVariables(linkValue);
string map = targetsNode.GetAttribute("map", String.Empty);
if (String.IsNullOrEmpty(map))
{
this.WriteMessage(MessageLevel.Error,
"Each targets element must have a map attribute specifying a file that maps art ids to files in the input directory.");
}
map = Environment.ExpandEnvironmentVariables(map);
if (!File.Exists(map))
{
WriteMessage(MessageLevel.Error, String.Format(
"The art map file '{0}' does not exist.", map));
}
string format = targetsNode.GetAttribute("format", String.Empty);
XPathExpression formatXPath = String.IsNullOrEmpty(format) ?
null : XPathExpression.Compile(format);
string relativeTo = targetsNode.GetAttribute(
"relative-to", String.Empty);
XPathExpression relativeToXPath = String.IsNullOrEmpty(
relativeTo) ? null : XPathExpression.Compile(relativeTo);
this.AddTargets(map, input, baseOutputPath, outputXPath, linkValue,
formatXPath, relativeToXPath);
}
this.WriteMessage(MessageLevel.Info, String.Format(
"Indexed {0} art targets.", _artTargets.Count));
}
public override void LocalInit()
{
base.LocalInit();
m_Expression = XPathExpression.Compile(m_Parameters.XPath);
}
private static bool XPathMatch(string xml, string testExpression, XmlNamespaceManager namespaceManager, string startingNodePath)
{
var xPathNavigator = CreateNavigator(xml, startingNodePath, namespaceManager);
var xPathExpression = xPathNavigator.Compile(testExpression);
if (namespaceManager != null)
{
xPathExpression.SetContext(namespaceManager);
}
var xPathNodeIterator = xPathNavigator.Select(xPathExpression);
xPathNodeIterator.MoveNext();
var current = xPathNodeIterator.Current;
return(namespaceManager == null?current.Matches(testExpression) : current.Matches(XPathExpression.Compile(testExpression, namespaceManager)));
}
public IntellisenseComponent2(BuildAssembler assembler, XPathNavigator configuration) : base(assembler, configuration)
{
XPathNavigator output_node = configuration.SelectSingleNode("output");
if (output_node != null)
{
string directory_value = output_node.GetAttribute("directory", String.Empty);
if (!String.IsNullOrEmpty(directory_value))
{
directory = Environment.ExpandEnvironmentVariables(directory_value);
if (!Directory.Exists(directory))
{
WriteMessage(MessageLevel.Error, String.Format("The output directory '{0}' does not exist.", directory));
}
}
}
XPathNavigator expression_node = configuration.SelectSingleNode("expressions");
if (expression_node != null)
{
string root = expression_node.GetAttribute("root", string.Empty);
try {
rootExpression = XPathExpression.Compile(root);
} catch (XPathException) {
WriteMessage(MessageLevel.Error, String.Format("The expression '{0}' is not a valid XPath expression.", root));
}
string assembly = expression_node.GetAttribute("assembly", string.Empty);
try {
assemblyExpression = XPathExpression.Compile(assembly);
} catch (XPathException) {
WriteMessage(MessageLevel.Error, String.Format("The expression '{0}' is not a valid XPath expression.", assembly));
}
string summary = expression_node.GetAttribute("summary", string.Empty);
try {
summaryExpression = XPathExpression.Compile(summary);
} catch (XPathException) {
WriteMessage(MessageLevel.Error, String.Format("The expression '{0}' is not a valid XPath expression.", summary));
}
string parameters = expression_node.GetAttribute("parameters", string.Empty);
try {
parametersExpression = XPathExpression.Compile(parameters);
} catch (XPathException) {
WriteMessage(MessageLevel.Error, String.Format("The expression '{0}' is not a valid XPath expression.", parameters));
}
string parameterContent = expression_node.GetAttribute("parameterContent", string.Empty);
try {
parameterContentExpression = XPathExpression.Compile(parameterContent);
} catch (XPathException) {
WriteMessage(MessageLevel.Error, String.Format("The expression '{0}' is not a valid XPath expression.", parameterContent));
}
string templates = expression_node.GetAttribute("templates", string.Empty);
try {
templatesExpression = XPathExpression.Compile(templates);
} catch (XPathException) {
WriteMessage(MessageLevel.Error, String.Format("The expression '{0}' is not a valid XPath expression.", templates));
}
string templateContent = expression_node.GetAttribute("templateContent", string.Empty);
try {
templateContentExpression = XPathExpression.Compile(templateContent);
} catch (XPathException) {
WriteMessage(MessageLevel.Error, String.Format("The expression '{0}' is not a valid XPath expression.", templateContent));
}
string returns = expression_node.GetAttribute("returns", string.Empty);
try {
returnsExpression = XPathExpression.Compile(returns);
} catch (XPathException) {
WriteMessage(MessageLevel.Error, String.Format("The expression '{0}' is not a valid XPath expression.", returns));
}
string exception = expression_node.GetAttribute("exception", string.Empty);
try {
exceptionExpression = XPathExpression.Compile(exception);
} catch (XPathException) {
WriteMessage(MessageLevel.Error, String.Format("The expression '{0}' is not a valid XPath expression.", exception));
}
string exceptionCref = expression_node.GetAttribute("exceptionCref", string.Empty);
try {
exceptionCrefExpression = XPathExpression.Compile(exceptionCref);
} catch (XPathException) {
WriteMessage(MessageLevel.Error, String.Format("The expression '{0}' is not a valid XPath expression.", exceptionCref));
}
string enumeration = expression_node.GetAttribute("enumeration", string.Empty);
try {
enumerationExpression = XPathExpression.Compile(enumeration);
} catch (XPathException) {
WriteMessage(MessageLevel.Error, String.Format("The expression '{0}' is not a valid XPath expression.", enumeration));
}
string enumerationApi = expression_node.GetAttribute("enumerationApi", string.Empty);
try {
enumerationApiExpression = XPathExpression.Compile(enumerationApi);
} catch (XPathException) {
WriteMessage(MessageLevel.Error, String.Format("The expression '{0}' is not a valid XPath expression.", enumerationApi));
}
string memberSummary = expression_node.GetAttribute("memberSummary", string.Empty);
try {
memberSummaryExpression = XPathExpression.Compile(memberSummary);
} catch (XPathException) {
WriteMessage(MessageLevel.Error, String.Format("The expression '{0}' is not a valid XPath expression.", memberSummary));
}
}
// a way to get additional information into the intellisense file
XPathNodeIterator input_nodes = configuration.Select("input");
foreach (XPathNavigator input_node in input_nodes)
{
string file_value = input_node.GetAttribute("file", String.Empty);
if (!String.IsNullOrEmpty(file_value))
{
string file = Environment.ExpandEnvironmentVariables(file_value);
ReadInputFile(file);
}
}
}
public override bool Matches(string xpath)
{
return(base.Matches(XPathExpression.Compile(xpath, XmlNamespaceManager)));
}
/// <summary>
/// Return the xPath corresponding to the given property. The PropertyName String
/// may be simple, nested, indexed or mapped.
/// </summary>
/// <param name="propertyName">is the event property name</param>
/// <param name="namespace">is the default namespace</param>
/// <param name="schemaModel">is the schema model</param>
/// <param name="xPathContext">is the xpath factory instance to use</param>
/// <param name="rootElementName">is the name of the root element</param>
/// <param name="eventBeanTypedEventFactory">for type lookup and creation</param>
/// <param name="xmlEventType">the resolving type</param>
/// <param name="isAllowFragment">whether fragmenting is allowed</param>
/// <param name="defaultNamespace">default namespace</param>
/// <returns>
/// xpath expression
/// </returns>
/// <throws>EPException is there are XPath errors</throws>
public static EventPropertyGetterSPI GetXPathResolution(
string propertyName,
XPathNamespaceContext xPathContext,
string rootElementName,
string @namespace,
SchemaModel schemaModel,
EventBeanTypedEventFactory eventBeanTypedEventFactory,
BaseXMLEventType xmlEventType,
bool isAllowFragment,
string defaultNamespace)
{
if (Log.IsDebugEnabled)
{
Log.Debug("Determining XPath expression for property '" + propertyName + "'");
}
var ctx = new XPathNamespaceContext();
var namespaces = schemaModel.Namespaces;
string defaultNamespacePrefix = null;
for (var i = 0; i < namespaces.Count; i++)
{
var namespacePrefix = "n" + i;
ctx.AddNamespace(namespacePrefix, namespaces[i]);
if (defaultNamespace != null && defaultNamespace == namespaces[i])
{
defaultNamespacePrefix = namespacePrefix;
}
}
var property = PropertyParser.ParseAndWalkLaxToSimple(propertyName);
var isDynamic = property.IsDynamic;
var rootComplexElement = SchemaUtil.FindRootElement(schemaModel, @namespace, rootElementName);
var prefix = ctx.LookupPrefix(rootComplexElement.Namespace);
if (prefix == null)
{
prefix = "";
}
else
{
prefix += ':';
}
var xPathBuf = new StringBuilder();
xPathBuf.Append('/');
xPathBuf.Append(prefix);
if (rootElementName.StartsWith("//"))
{
xPathBuf.Append(rootElementName.Substring(2));
}
else
{
xPathBuf.Append(rootElementName);
}
var parentComplexElement = rootComplexElement;
Pair <string, XPathResultType> pair = null;
if (!(property is NestedProperty))
{
pair = MakeProperty(rootComplexElement, property, ctx, true, isDynamic, defaultNamespacePrefix);
if (pair == null)
{
throw new PropertyAccessException("Failed to locate property '" + propertyName + "' in schema");
}
xPathBuf.Append(pair.First);
}
else
{
var nestedProperty = (NestedProperty)property;
var indexLast = nestedProperty.Properties.Count - 1;
for (var i = 0; i < indexLast + 1; i++)
{
var isLast = i == indexLast;
var propertyNested = nestedProperty.Properties[i];
pair = MakeProperty(
parentComplexElement,
propertyNested,
ctx,
isLast,
isDynamic,
defaultNamespacePrefix);
if (pair == null)
{
throw new PropertyAccessException(
"Failed to locate property '" +
propertyName +
"' nested property part '" +
property.PropertyNameAtomic +
"' in schema");
}
var text = propertyNested.PropertyNameAtomic;
var obj = SchemaUtil.FindPropertyMapping(parentComplexElement, text);
if (obj is SchemaElementComplex)
{
parentComplexElement = (SchemaElementComplex)obj;
}
xPathBuf.Append(pair.First);
}
}
var xPath = xPathBuf.ToString();
if (ExecutionPathDebugLog.IsDebugEnabled && Log.IsDebugEnabled)
{
Log.Debug(".parse XPath for property '" + propertyName + "' is expression=" + xPath);
}
// Compile assembled XPath expression
if (Log.IsDebugEnabled)
{
Log.Debug(
"Compiling XPath expression '" +
xPath +
"' for property '" +
propertyName +
"' using namespace context :" +
ctx);
}
XPathExpression expr;
try {
expr = XPathExpression.Compile(xPath, ctx);
}
catch (XPathException e) {
var detail = "Error constructing XPath expression from property expression '" +
propertyName +
"' expression '" +
xPath +
"'";
if (e.Message != null)
{
throw new EPException(detail + " :" + e.Message, e);
}
throw new EPException(detail, e);
}
// get type
var item = property.GetPropertyTypeSchema(rootComplexElement);
if (item == null && !isDynamic)
{
return(null);
}
var resultType = isDynamic ? typeof(XmlNode) : SchemaUtil.ToReturnType(item);
FragmentFactory fragmentFactory = null;
if (isAllowFragment)
{
fragmentFactory = new FragmentFactoryDOMGetter(eventBeanTypedEventFactory, xmlEventType, propertyName);
}
return(new XPathPropertyGetter(
xmlEventType,
propertyName,
xPath,
expr,
pair.Second,
resultType,
fragmentFactory));
}
//=====================================================================
/// <inheritdoc />
public override void Initialize(XPathNavigator configuration)
{
if (configuration == null)
{
throw new ArgumentNullException(nameof(configuration));
}
XPathExpression artIdExpression = XPathExpression.Compile("string(@id)"),
artFileExpression = XPathExpression.Compile("string(image/@file)"),
artTextExpression = XPathExpression.Compile("string(image/altText)");
XPathNodeIterator targetsNodes = configuration.Select("targets");
foreach (XPathNavigator targetsNode in targetsNodes)
{
// Get the configuration values for this target
string inputPath = targetsNode.GetAttribute("input", String.Empty);
if (String.IsNullOrEmpty(inputPath))
{
this.WriteMessage(MessageLevel.Error, "Each targets element must have an input attribute " +
"specifying a directory containing art files.");
}
inputPath = Environment.ExpandEnvironmentVariables(inputPath);
if (!Directory.Exists(inputPath))
{
this.WriteMessage(MessageLevel.Error, "The art input directory '{0}' does not exist.",
inputPath);
}
string baseOutputPath = targetsNode.GetAttribute("baseOutput", String.Empty);
if (!String.IsNullOrEmpty(baseOutputPath))
{
baseOutputPath = Path.GetFullPath(Environment.ExpandEnvironmentVariables(baseOutputPath));
}
string outputPathValue = targetsNode.GetAttribute("outputPath", String.Empty);
if (String.IsNullOrEmpty(outputPathValue))
{
this.WriteMessage(MessageLevel.Error, "Each targets element must have an output attribute " +
"specifying a directory in which to place referenced art files.");
}
XPathExpression outputXPath = XPathExpression.Compile(outputPathValue);
string linkPath = targetsNode.GetAttribute("link", String.Empty);
if (String.IsNullOrEmpty(linkPath))
{
linkPath = "../art";
}
string map = targetsNode.GetAttribute("map", String.Empty);
if (String.IsNullOrEmpty(map))
{
this.WriteMessage(MessageLevel.Error, "Each targets element must have a map attribute " +
"specifying a file that maps art IDs to files in the input directory.");
}
map = Environment.ExpandEnvironmentVariables(map);
if (!File.Exists(map))
{
this.WriteMessage(MessageLevel.Error, "The art map file '{0}' does not exist.", map);
}
string format = targetsNode.GetAttribute("format", String.Empty);
XPathExpression formatXPath = String.IsNullOrEmpty(format) ? null :
XPathExpression.Compile(format);
string relativeTo = targetsNode.GetAttribute("relative-to", String.Empty);
XPathExpression relativeToXPath = String.IsNullOrEmpty(relativeTo) ? null :
XPathExpression.Compile(relativeTo);
// Load the content of the media map file
using (var reader = XmlReader.Create(map, new XmlReaderSettings {
CloseInput = true
}))
{
XPathDocument mediaMap = new XPathDocument(reader);
XPathNodeIterator items = mediaMap.CreateNavigator().Select("/*/item");
foreach (XPathNavigator item in items)
{
string id = (string)item.Evaluate(artIdExpression);
string file = (string)item.Evaluate(artFileExpression);
string text = (string)item.Evaluate(artTextExpression);
string name = Path.GetFileName(file);
targets[id] = new ArtTarget
{
Id = id,
InputPath = Path.Combine(inputPath, file),
BaseOutputPath = baseOutputPath,
OutputXPath = outputXPath,
LinkPath = String.IsNullOrEmpty(name) ? linkPath : String.Concat(linkPath, "/", name),
Text = text,
Name = name,
FormatXPath = formatXPath,
RelativeToXPath = relativeToXPath
};
}
}
}
this.WriteMessage(MessageLevel.Info, "Indexed {0} art targets.", targets.Count);
}
//=====================================================================
/// <inheritdoc />
public override void Initialize(XPathNavigator configuration)
{
XPathNavigator syntaxNode = configuration.SelectSingleNode("syntax");
string syntaxInputXPath = syntaxNode.GetAttribute("input", String.Empty);
if (String.IsNullOrEmpty(syntaxInputXPath))
{
throw new ConfigurationErrorsException("You must specify an XPath for input in the syntax element");
}
syntaxInput = XPathExpression.Compile(syntaxInputXPath);
string syntaxOutputXPath = syntaxNode.GetAttribute("output", String.Empty);
if (String.IsNullOrEmpty(syntaxOutputXPath))
{
throw new ConfigurationErrorsException("You must specify an XPath for output in the syntax element");
}
syntaxOutput = XPathExpression.Compile(syntaxOutputXPath);
string attrValue = syntaxNode.GetAttribute("renderReferenceLinks", String.Empty);
if (String.IsNullOrWhiteSpace(attrValue) || !Boolean.TryParse(attrValue, out renderReferenceLinks))
{
renderReferenceLinks = false;
}
XPathNodeIterator generatorNodes = configuration.Select("generators/generator");
// Configuration changes are stored separately since the actual generators may be added to the
// configuration file at build time. Substitution of the edited configuration is easier to do here.
var generatorConfigs = configuration.SelectSingleNode("configurations");
// If we have configuration nodes, note the order of the syntax generators. These will be used to
// order the snippets.
if (generatorConfigs != null)
{
int order = 1;
foreach (XPathNavigator id in generatorConfigs.Select("generator/@id"))
{
languageOrder.Add(id.Value, order++);
}
}
foreach (XPathNavigator generatorNode in generatorNodes)
{
// Get the ID of the syntax generator
string id = generatorNode.GetAttribute("id", String.Empty);
if (String.IsNullOrWhiteSpace(id))
{
this.WriteMessage(MessageLevel.Error, "Each generator element must have an id attribute");
}
var generatorFactory = generatorFactories.FirstOrDefault(g => g.Metadata.Id == id);
if (generatorFactory == null)
{
this.WriteMessage(MessageLevel.Error, "A syntax generator with the ID '{0}' could not be found", id);
}
// Track the languages for grouping
generatorLanguages.Add(generatorFactory.Metadata.Id);
languageSet.Add(generatorFactory.Metadata);
foreach (string alternateId in (generatorFactory.Metadata.AlternateIds ?? String.Empty).Split(
new[] { ',', ' ', '\t' }, StringSplitOptions.RemoveEmptyEntries))
{
generatorLanguages.Add(alternateId);
}
try
{
var generator = generatorFactory.Value.Create();
var configNode = generatorNode.Clone();
if (generatorConfigs != null)
{
var alternateConfig = generatorConfigs.SelectSingleNode("generator[@id='" + id + "']");
if (alternateConfig != null && alternateConfig.HasChildren)
{
// Since there may be custom attributes on the generator node, we'll make a copy and
// substitute the child elements that make up the configuration.
var alternate = XElement.Parse(alternateConfig.OuterXml);
var genNode = XElement.Parse(configNode.OuterXml);
genNode.RemoveNodes();
genNode.Add(alternate.Elements());
configNode = genNode.CreateNavigator();
}
}
generator.Initialize(configNode);
generators.Add(generator);
}
catch (Exception ex)
{
this.WriteMessage(MessageLevel.Error, "An error occurred while attempting to instantiate " +
"the '{0}' syntax generator. The error message is: {1}{2}", id, ex.Message,
ex.InnerException != null ? "\r\n" + ex.InnerException.Message : String.Empty);
}
}
this.WriteMessage(MessageLevel.Info, "Loaded {0} syntax generators.", generators.Count);
// If this is not found or set, we'll assume the presentation style does not support grouping
var containerElement = configuration.SelectSingleNode("containerElement");
if (containerElement != null)
{
// If grouping is disabled, skip the remainder of the set up. This will happen if the user adds
// a custom configuration to a project for a presentation style that doesn't support it.
bool groupingEnabled;
containerElementName = containerElement.GetAttribute("name", String.Empty);
attrValue = containerElement.GetAttribute("groupingEnabled", String.Empty);
if (String.IsNullOrWhiteSpace(attrValue) || !Boolean.TryParse(attrValue, out groupingEnabled))
{
groupingEnabled = false;
}
if (!groupingEnabled || String.IsNullOrWhiteSpace(containerElementName))
{
return;
}
// Get the "no example tab" options
attrValue = containerElement.GetAttribute("addNoExampleTabs", String.Empty);
if (String.IsNullOrWhiteSpace(attrValue) || !Boolean.TryParse(attrValue, out addNoExampleTabs))
{
addNoExampleTabs = true;
}
attrValue = containerElement.GetAttribute("includeOnSingleSnippets", String.Empty);
if (String.IsNullOrWhiteSpace(attrValue) || !Boolean.TryParse(attrValue, out includeOnSingleSnippets))
{
includeOnSingleSnippets = false;
}
// Create the XPath queries used for code snippet grouping and sorting
var context = new CustomContext();
context.AddNamespace("ddue", "http://ddue.schemas.microsoft.com/authoring/2003/5");
referenceRoot = XPathExpression.Compile("document/comments|document/syntax");
referenceCode = XPathExpression.Compile("//code|//div[@codeLanguage]");
conceptualRoot = XPathExpression.Compile("document/topic");
conceptualCode = XPathExpression.Compile("//ddue:code|//ddue:snippet");
conceptualCode.SetContext(context);
// Hook up the event handler to group and sort code snippets just prior to XSL transformation
this.BuildAssembler.ComponentEvent += TransformComponent_TopicTransforming;
}
}
