|
public SelectSingleNode ( |
||
| expression | ||
| return | ||
public ForEachComponent (BuildAssembler assembler, XPathNavigator configuration) : base(assembler, configuration) {
// set up the context
XPathNodeIterator context_nodes = configuration.Select("context");
foreach (XPathNavigator context_node in context_nodes)
{
string prefix = context_node.GetAttribute("prefix", String.Empty);
string name = context_node.GetAttribute("name", String.Empty);
context.AddNamespace(prefix, name);
}
// load the expression format
XPathNavigator variable_node = configuration.SelectSingleNode("variable");
if (variable_node == null) throw new ConfigurationErrorsException("When instantiating a ForEach component, you must specify a variable using the <variable> element.");
string xpath_format = variable_node.GetAttribute("expression", String.Empty);
if ((xpath_format == null) || (xpath_format.Length == 0)) throw new ConfigurationErrorsException("When instantiating a ForEach component, you must specify a variable expression using the expression attribute");
xpath = XPathExpression.Compile(xpath_format);
// load the subcomponents
WriteMessage(MessageLevel.Info, "Loading subcomponents.");
XPathNavigator components_node = configuration.SelectSingleNode("components");
if (components_node == null) throw new ConfigurationErrorsException("When instantiating a ForEach component, you must specify subcomponents using the <components> element.");
components = BuildAssembler.LoadComponents(components_node);
WriteMessage(MessageLevel.Info, String.Format("Loaded {0} subcomponents.", components.Count));
}
public override void Emit(XPathNavigator patternNavigator)
{
if (patternNavigator != null)
{
string name = patternNavigator.SelectSingleNode("@Name").Value;
string sourcePath = patternNavigator.SelectSingleNode("@SourcePath").Value;
string destPath = patternNavigator.SelectSingleNode("@DestinationPath").Value;
string operationAsString = patternNavigator.SelectSingleNode("@Operation").Value;
DTSTasks.FileSystemTask.DTSFileSystemOperation operation = DTSTasks.FileSystemTask.DTSFileSystemOperation.CopyDirectory;
switch (operationAsString.ToUpperInvariant())
{
case "COPYDIRECTORY":
operation = DTSTasks.FileSystemTask.DTSFileSystemOperation.CopyDirectory;
break;
default:
break;
}
FileSystemTask ft = new FileSystemTask(VulcanPackage, name, name, ParentContainer, sourcePath, destPath, operation);
ft.SetExpression("OverwriteDestinationFile", "True");
this.FirstExecutableGeneratedByPattern = ft.TaskHost;
this.LastExecutableGeneratedByPattern = ft.TaskHost;
}
}
public override void Emit(XPathNavigator patternNavigator)
{
if (patternNavigator != null)
{
string name = patternNavigator.SelectSingleNode("@Name").Value;
string fileName =
Resources.Create+
name +
Resources.ExtensionSQLFile;
string filePath = VulcanPackage.AddFileToProject(fileName);
TableHelper th = new TableHelper(name, VulcanPackage.VulcanConfig, patternNavigator.SelectSingleNode("rc:Table",VulcanPackage.VulcanConfig.NamespaceManager));
th.TraceHelper();
th.TraceHelper();
TableEmitterEx tex = new TableEmitterEx(th, VulcanPackage);
tex.Emit(filePath,false);
Connection connection = Connection.GetExistingConnection(VulcanPackage, patternNavigator);
SQLTask sqlTask = new SQLTask(VulcanPackage,
Resources.Create + name,
Resources.Create + name,
ParentContainer,
connection
);
sqlTask.TransmuteToFileTask(fileName);
this.FirstExecutableGeneratedByPattern = sqlTask.SQLTaskHost;
this.LastExecutableGeneratedByPattern = this.FirstExecutableGeneratedByPattern;
}
}
public override void Emit(XPathNavigator patternNavigator)
{
string name = patternNavigator.SelectSingleNode("@Name").Value;
string constraintMode = patternNavigator.SelectSingleNode("@ConstraintMode").Value;
DTS.Sequence newParentContainer = VulcanPackage.AddSequenceContainer(name, ParentContainer);
DTS.Executable previousExec = null;
Pattern p = null;
foreach (XPathNavigator nav in patternNavigator.SelectChildren(XPathNodeType.Element))
{
p = PatternFactory.ProcessPattern(VulcanPackage,newParentContainer, nav,p);
switch (constraintMode)
{
case "Linear":
VulcanPackage.AddPrecedenceConstraint(previousExec, p.FirstExecutableGeneratedByPattern, newParentContainer);
break;
case "Parallel":
break;
default:
Message.Trace(Severity.Error, "Unknown ConstraintMode {0}", constraintMode);
break;
}
previousExec = p.LastExecutableGeneratedByPattern;
}
this.FirstExecutableGeneratedByPattern = newParentContainer;
this.LastExecutableGeneratedByPattern = this.FirstExecutableGeneratedByPattern;
}
//=====================================================================
/// <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;
}
/// <summary>
/// Parses the various properties from the XML document and populates the given SearchResult.
/// </summary>
/// <param name="result">The Google.CustomSearch.SearchResult to populate.</param>
/// <param name="nav">The XPathNavigator for the response document.</param>
private void ParseResponseProperties(SearchResult result, XPathNavigator nav)
{
XPathNavigator timeNode = nav.SelectSingleNode("/GSP/TM");
if (timeNode != null)
result.Time = timeNode.Value;
XPathNavigator titleNode = nav.SelectSingleNode("/GSP/Context/title");
if (titleNode != null)
result.Title = titleNode.Value;
XPathNavigator resultContainer = nav.SelectSingleNode("/GSP/RES");
if (resultContainer != null)
{
// See http://www.google.com/cse/docs/resultsxml.html#results_xml_tag_XT
result.Exact = resultContainer.SelectSingleNode("XT") != null;
result.Filtered = resultContainer.SelectSingleNode("FI") != null;
int startIndex;
string start = resultContainer.GetAttribute("SN", string.Empty);
if (int.TryParse(start, out startIndex))
{
result.StartIndex = startIndex;
}
int endIndex;
string end = resultContainer.GetAttribute("EN", string.Empty);
if (int.TryParse(end, out endIndex))
{
result.EndIndex = endIndex;
}
// Next and previous URLs
XPathNavigator navigation = resultContainer.SelectSingleNode("NB");
if (null != navigation)
{
XPathNavigator nextLink = navigation.SelectSingleNode("NU");
if (null != nextLink)
result.NextPageLink = nextLink.Value;
XPathNavigator previousLink = navigation.SelectSingleNode("NP");
if (null != previousLink)
result.PreviousPageLink = previousLink.Value;
}
XPathNavigator totalNode = resultContainer.SelectSingleNode("M");
if (totalNode != null)
{
int total;
if (int.TryParse(totalNode.Value, out total))
{
result.Total = total;
}
}
}
this.ParseSpellings(result, nav);
this.ParseFacets(result, nav);
}
public ObsRequestNode(XPathNavigator nav)
{
ID = nav.SelectSingleNode ("@id").Value;
Description = nav.SelectSingleNode ("description").Value;
State = new RequestState (nav.SelectSingleNode ("state"));
Action = new RequestAction (nav.SelectSingleNode ("action"));
}
internal Argument(XPathNavigator navigator, string nspace)
{
XmlNamespaceManager nsmanager = new XmlNamespaceManager(navigator.NameTable);
nsmanager.AddNamespace("u", nspace);
name = navigator.SelectSingleNode("u:name", nsmanager).Value;
name = name.Trim();
related = navigator.SelectSingleNode("u:relatedStateVariable", nsmanager).Value;
related = related.Trim();
}
/// <summary>
/// Populates the class members with data from the specified
/// active person information XML.
/// </summary>
///
/// <param name="navigator">
/// The XML to get the active person information from.
/// </param>
///
internal override void ParseXml(XPathNavigator navigator)
{
base.ParseXml(navigator);
Email = navigator.SelectSingleNode("contact-email").Value;
RecordAuthorizationState = AuthorizedRecordState.Active;
_name = navigator.SelectSingleNode("name").Value;
}
private ReferenceNode CreateNode(XPathNavigator nav)
{
var hintPathNode = nav.SelectSingleNode("n:HintPath", ns);
var isPrivateNode = nav.SelectSingleNode("n:Private", ns);
var name = GetSimpleReferenceName(nav.GetAttribute("Include", ""));
return new ReferenceNode
{
Include = name,
HintPath = hintPathNode == null ? string.Empty : hintPathNode.Value,
IsPrivate = isPrivateNode == null ? GetDefaultPrivateValue(name) : bool.Parse(isPrivateNode.Value)
};
}
public override void Emit(XPathNavigator patternNavigator)
{
if (patternNavigator != null)
{
string firstOrLast = patternNavigator.SelectSingleNode("@FirstOrLast").Value;
string status = patternNavigator.SelectSingleNode("@Status").Value;
string notes = patternNavigator.SelectSingleNode("@Notes").Value;
Connection tableConnection =
Connection.GetExistingConnection(VulcanPackage, LogtainerPattern.CurrentLog.TableConnectionName);
string execSqlTaskName = LogtainerPattern.CurrentLog.LogName + Resources.Seperator + firstOrLast + Guid.NewGuid();
TemplateEmitter te = new TemplateEmitter(VulcanPackage.TemplateManager["LogSelectQuery"]);
if (
LogtainerPattern.CurrentLog.SourceColumn == null ||
LogtainerPattern.CurrentLog.DestinationColumn == null ||
LogtainerPattern.CurrentLog.TableConnectionName == null ||
LogtainerPattern.CurrentLog.Table == null)
{
Message.Trace(Severity.Error,
"Could not perform LogUpdate (On Log: {0}), Parent Logtainer does not contain all of the necessary information. Needs SourceColumn, DestinationColumn, TableConnectionName, and Table attributes.",LogtainerPattern.CurrentLog.LogName);
return;
}
te.SetNamedParameter("Source", LogtainerPattern.CurrentLog.SourceColumn);
te.SetNamedParameter("Destination", LogtainerPattern.CurrentLog.DestinationColumn);
te.SetNamedParameter("Table", LogtainerPattern.CurrentLog.Table);
te.SetNamedParameter("Status", status);
te.SetNamedParameter("Notes", notes);
te.SetNamedParameter("SourceConvertStyle", "21");
te.SetNamedParameter("DestinationConvertStyle", "21");
string query;
te.Emit(out query);
SQLTask readForLogTask = new SQLTask(VulcanPackage, execSqlTaskName, execSqlTaskName, ParentContainer, tableConnection);
readForLogTask.TransmuteToExpressionTask(String.Format("\"{0}\"", query));
readForLogTask.ExecuteSQLTask.ResultSetType = Microsoft.SqlServer.Dts.Tasks.ExecuteSQLTask.ResultSetType.ResultSetType_SingleRow;
DTS.Variable sourceVar = LogtainerPattern.CurrentLog[firstOrLast+"SourceRecord"];
DTS.Variable destVar = LogtainerPattern.CurrentLog[firstOrLast+"DestinationRecord"];
DTS.Variable statusVar = LogtainerPattern.CurrentLog["Status"];
DTS.Variable notesVar = LogtainerPattern.CurrentLog["Notes"];
readForLogTask.BindResult("0", sourceVar.QualifiedName);
readForLogTask.BindResult("1", destVar.QualifiedName);
readForLogTask.BindResult("2", statusVar.QualifiedName);
readForLogTask.BindResult("3", notesVar.QualifiedName);
this.FirstExecutableGeneratedByPattern = readForLogTask.SQLTaskHost;
this.LastExecutableGeneratedByPattern = this.FirstExecutableGeneratedByPattern;
}
}
/// <summary>
/// Initializes the syndication extension context using the supplied <see cref="XPathNavigator"/>.
/// </summary>
/// <param name="source">The <b>XPathNavigator</b> used to load this <see cref="SDataExtensionContext"/>.</param>
/// <param name="manager">The <see cref="XmlNamespaceManager"/> object used to resolve prefixed syndication extension elements and attributes.</param>
/// <returns><b>true</b> if the <see cref="SDataExtensionContext"/> was able to be initialized using the supplied <paramref name="source"/>; otherwise <b>false</b>.</returns>
/// <exception cref="ArgumentNullException">The <paramref name="source"/> is a null reference (Nothing in Visual Basic).</exception>
/// <exception cref="ArgumentNullException">The <paramref name="manager"/> is a null reference (Nothing in Visual Basic).</exception>
public bool Load(XPathNavigator source, XmlNamespaceManager manager)
{
//------------------------------------------------------------
// Local members
//------------------------------------------------------------
var wasLoaded = false;
//------------------------------------------------------------
// Validate parameter
//------------------------------------------------------------
Guard.ArgumentNotNull(source, "source");
Guard.ArgumentNotNull(manager, "manager");
//------------------------------------------------------------
// Attempt to extract syndication extension information
//------------------------------------------------------------
if (source.HasChildren)
{
var syncModeNavigator = source.SelectSingleNode("sync:syncMode", manager);
if (syncModeNavigator != null && !string.IsNullOrEmpty(syncModeNavigator.Value))
{
SyncMode = (SyncMode) Enum.Parse(typeof (SyncMode), syncModeNavigator.Value, true);
wasLoaded = true;
}
var digestNavigator = source.SelectSingleNode("sync:digest", manager);
if (digestNavigator != null)
{
var digest = new Digest();
if (digest.Load(digestNavigator, manager))
{
Digest = digest;
wasLoaded = true;
}
}
var syncStateNavigator = source.SelectSingleNode("sync:syncState", manager);
if (syncStateNavigator != null)
{
var syncState = new SyncState();
if (syncState.Load(syncStateNavigator, manager))
{
SyncState = syncState;
wasLoaded = true;
}
}
}
return wasLoaded;
}
public ZoneGroup(Discover disc, XPathNavigator node)
{
_coordinator = node.SelectSingleNode("@Coordinator").Value;
_id = node.SelectSingleNode("@ID").Value;
foreach (XPathNavigator nav in node.Select("ZoneGroupMember"))
{
ZonePlayer zp = disc.Intern(String.Concat("uuid:", nav.SelectSingleNode("@UUID").Value));
_members.Add(zp);
}
_coordinatorZone = disc.Intern(String.Concat("uuid:", _coordinator));
_members.CollectionChanged += new System.Collections.Specialized.NotifyCollectionChangedEventHandler(_members_CollectionChanged);
}
public override void WriteClassSyntax (XPathNavigator reflection, SyntaxWriter writer) {
if (IsUnsupportedGeneric(reflection, writer)) return;
string name = reflection.Evaluate(apiNameExpression).ToString();
bool isAbstract = (bool) reflection.Evaluate(apiIsAbstractTypeExpression);
bool isSealed = (bool) reflection.Evaluate(apiIsSealedTypeExpression);
bool isSerializable = (bool) reflection.Evaluate(apiIsSerializableTypeExpression);
if (isSerializable) WriteAttribute("T:System.SerializableAttribute", writer);
WriteAttributes(reflection, writer);
WriteVisibility(reflection, writer);
writer.WriteString(" ");
if (isSealed) {
writer.WriteKeyword("final");
writer.WriteString(" ");
} else if (isAbstract) {
writer.WriteKeyword("abstract");
writer.WriteString(" ");
}
writer.WriteKeyword("class");
writer.WriteString(" ");
writer.WriteIdentifier(name);
XPathNavigator baseClass = reflection.SelectSingleNode(apiBaseClassExpression);
if ((baseClass != null) && !((bool) baseClass.Evaluate(typeIsObjectExpression))) {
writer.WriteString(" ");
writer.WriteKeyword("extends");
writer.WriteString(" ");
WriteTypeReference(baseClass, writer);
}
WriteImplementedInterfaces(reflection, writer);
}
public override void WriteSyntax (XPathNavigator reflection, SyntaxWriter writer) {
string group = (string)reflection.Evaluate(groupExpression);
string subgroup = (string)reflection.Evaluate(subgroupExpression);
if (group == "type" && subgroup == "class") {
string prefix = WebControlPrefix(reflection);
if (!String.IsNullOrEmpty(prefix)) {
WriteClassSyntax(reflection, writer, prefix);
}
}
if (group == "member") {
string prefix = null;
XPathNavigator containingType = reflection.SelectSingleNode(containingTypeExpression);
if (containingType != null) prefix = WebControlPrefix(containingType);
if (!String.IsNullOrEmpty(prefix)) {
if (subgroup == "property") {
WritePropertySyntax(reflection, writer, prefix);
} else if (subgroup == "event") {
WriteEventSyntax(reflection, writer, prefix);
}
}
}
}
//=====================================================================
/// <inheritdoc />
public override void Initialize(XPathNavigator configuration)
{
// get the condition
XPathNavigator condition_element = configuration.SelectSingleNode("switch");
if(condition_element == null)
throw new ConfigurationErrorsException("You must specify a condition using the <switch> statement with a 'value' attribute.");
string condition_value = condition_element.GetAttribute("value", String.Empty);
if(String.IsNullOrEmpty(condition_value))
throw new ConfigurationErrorsException("The switch statement must have a 'value' attribute, which is an xpath expression.");
condition = XPathExpression.Compile(condition_value);
// load the component stacks for each case
XPathNodeIterator case_elements = configuration.Select("case");
foreach(XPathNavigator case_element in case_elements)
{
string case_value = case_element.GetAttribute("value", String.Empty);
cases.Add(case_value, BuildAssembler.LoadComponents(case_element));
}
}
public static string GetNodeValue(XPathNavigator node, string query)
{
if (node == null) return "N/A";
var rtnNode = node.SelectSingleNode(query);
return rtnNode == null ? "N/A" : rtnNode.Value.Trim();
}
private void ReadLegacyManifest(XPathNavigator legacyManifest, bool processModule)
{
XPathNavigator folderNav = legacyManifest.SelectSingleNode("folders/folder");
if (processModule)
{
Package.Name = Util.ReadElement(folderNav, "name");
Package.FriendlyName = Package.Name;
foreach (XPathNavigator controlNav in folderNav.Select("modules/module/controls/control"))
{
SkinControl.ControlKey = Util.ReadElement(controlNav, "key");
SkinControl.ControlSrc = Path.Combine(Path.Combine("DesktopModules", Package.Name.ToLower()), Util.ReadElement(controlNav, "src")).Replace("\\", "/");
string supportsPartialRendering = Util.ReadElement(controlNav, "supportspartialrendering");
if (!string.IsNullOrEmpty(supportsPartialRendering))
{
SkinControl.SupportsPartialRendering = bool.Parse(supportsPartialRendering);
}
}
}
foreach (XPathNavigator fileNav in folderNav.Select("files/file"))
{
string fileName = Util.ReadElement(fileNav, "name");
string filePath = Util.ReadElement(fileNav, "path");
AddFile(Path.Combine(filePath, fileName), fileName);
}
if (!string.IsNullOrEmpty(Util.ReadElement(folderNav, "resourcefile")))
{
AddFile(Util.ReadElement(folderNav, "resourcefile"));
}
}
public string Value(XPathNavigator node, string xpath)
{
XPathNavigator n = node.SelectSingleNode(xpath, ns);
if (n == null)
throw new InvalidStructureException("Missing value in profile: {0}", xpath);
return n.Value;
}
public static DerivedColumns CreateDerivedColumnsFromXml(Packages.VulcanPackage vulcanPackage, IDTSComponentMetaData90 parentComponent, MainPipe dataFlowTask, XPathNavigator derivedNav)
{
if (derivedNav == null || derivedNav.Name.ToUpperInvariant() != "DerivedColumns".ToUpperInvariant())
{
//We don't handle this.
return null;
}
string componentName = derivedNav.SelectSingleNode("@Name", vulcanPackage.VulcanConfig.NamespaceManager).Value;
Message.Trace(Severity.Debug, "Begin: DerivedColumns Transformation {0}", componentName);
DerivedColumns dc = new DerivedColumns(vulcanPackage, dataFlowTask, parentComponent, componentName, componentName);
foreach (XPathNavigator nav in derivedNav.Select("rc:Column", vulcanPackage.VulcanConfig.NamespaceManager))
{
string colName = nav.SelectSingleNode("@Name").Value;
string typeAsString = nav.SelectSingleNode("@Type").Value;
int length = nav.SelectSingleNode("@Length").ValueAsInt;
int precision = nav.SelectSingleNode("@Precision").ValueAsInt;
int scale = nav.SelectSingleNode("@Scale").ValueAsInt;
int codepage = nav.SelectSingleNode("@Codepage").ValueAsInt;
string expression = nav.Value;
DataType type = TransformationFactory.GetDataTypeFromString(typeAsString);
dc.AddOutputColumn(colName, type, expression, length, precision, scale, codepage);
}
return dc;
}
private static string GetChildValueOrDefault(XPathNavigator node, string childExpression)
{
if (node == null) return null;
var childNode = node.SelectSingleNode(childExpression);
return (childNode == null) ? null : childNode.Value.Trim();
}
public void ReadPath(Element element, XPathNavigator node)
{
string s = node.SelectSingleNode("f:path/@value", ns).Value;
element.Path = new Path(s);
element.Name = element.Path.ElementName;
}
public IntellisenseComponent (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));
}
}
// 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);
}
}
context.AddNamespace("ddue", "http://ddue.schemas.microsoft.com/authoring/2003/5");
summaryExpression.SetContext(context);
memberSummaryExpression.SetContext(context);
returnsExpression.SetContext(context);
parametersExpression.SetContext(context);
parameterNameExpression.SetContext(context);
templatesExpression.SetContext(context);
templateNameExpression.SetContext(context);
exceptionExpression.SetContext(context);
exceptionCrefExpression.SetContext(context);
}
public SaveComponent (BuildAssembler assembler, XPathNavigator configuration) : base(assembler, configuration) {
// load the target path format
XPathNavigator save_node = configuration.SelectSingleNode("save");
if (save_node == null) throw new ConfigurationErrorsException("When instantiating a save component, you must specify a the target file using the <save> element.");
string base_value = save_node.GetAttribute("base", String.Empty);
if (!String.IsNullOrEmpty(base_value)) {
basePath = Path.GetFullPath(Environment.ExpandEnvironmentVariables(base_value));
}
string path_value = save_node.GetAttribute("path", String.Empty);
if (String.IsNullOrEmpty(path_value)) WriteMessage(MessageLevel.Error, "Each save element must have a path attribute specifying an XPath that evaluates to the location to save the file.");
path_expression = XPathExpression.Compile(path_value);
string select_value = save_node.GetAttribute("select", String.Empty);
if (!String.IsNullOrEmpty(select_value))
select_expression = XPathExpression.Compile(select_value);
settings.Encoding = Encoding.UTF8;
string indent_value = save_node.GetAttribute("indent", String.Empty);
if (!String.IsNullOrEmpty(indent_value)) settings.Indent = Convert.ToBoolean(indent_value);
string omit_value = save_node.GetAttribute("omit-xml-declaration", String.Empty);
if (!String.IsNullOrEmpty(omit_value)) settings.OmitXmlDeclaration = Convert.ToBoolean(omit_value);
linkPath = save_node.GetAttribute("link", String.Empty);
if (String.IsNullOrEmpty(linkPath)) linkPath = "../html";
// encoding
settings.CloseOutput = true;
}
public static bool GetXmlBoolValue(XPathNavigator parentNode, string valueName, bool emptyIsTrue)
{
if (parentNode == null || string.IsNullOrEmpty(valueName))
{
return false;
}
bool result = false;
try
{
XPathNavigator node = parentNode.SelectSingleNode(valueName);
if (emptyIsTrue)
{
result = (node == null || (node != null && node.Value == "yes" && string.IsNullOrEmpty(node.Value)));
}
else
{
result = (node != null && node.Value == "yes");
}
}
catch (NullReferenceException)
{
}
return result;
}
public override void Emit(XPathNavigator patternNavigator)
{
string containerName = patternNavigator.SelectSingleNode("@Name", VulcanPackage.VulcanConfig.NamespaceManager).Value;
string helperTableTaskName = "Set Up Helper Table Group "+containerName;
string helperTableFile = containerName + Resources.ExtensionSQLFile;
string helperTableFilePath = VulcanPackage.AddFileToProject(helperTableFile);
File.Delete(helperTableFilePath);
Connection c = Connection.GetExistingConnection(VulcanPackage, patternNavigator);
foreach (XPathNavigator nav in patternNavigator.Select("rc:HelperTable", VulcanPackage.VulcanConfig.NamespaceManager))
{
string tableName = nav.SelectSingleNode("@Name", VulcanPackage.VulcanConfig.NamespaceManager).Value;
XPathNavigator tableNavigator = nav.SelectSingleNode("rc:Table",VulcanPackage.VulcanConfig.NamespaceManager);
Message.Trace(Severity.Debug,"Adding Helper table "+tableName);
TableHelper th = new TableHelper(tableName, VulcanPackage.VulcanConfig, tableNavigator);
TableEmitterEx te = new TableEmitterEx(th,VulcanPackage);
te.Emit(VulcanPackage.QualifiedProjectPath+helperTableFile, true);
}
SQLTask setupSQLTask = new SQLTask(VulcanPackage, helperTableTaskName, helperTableTaskName, ParentContainer,c);
setupSQLTask.TransmuteToFileTask(helperTableFile);
this.ExecuteDuringDesignTime(patternNavigator, setupSQLTask.SQLTaskHost);
this.FirstExecutableGeneratedByPattern = setupSQLTask.SQLTaskHost;
this.LastExecutableGeneratedByPattern = this.FirstExecutableGeneratedByPattern;
}
//=====================================================================
/// <inheritdoc />
/// <remarks>If an <c>xpath</c> element is found in the configuration, it's inner text will be used as
/// a filter expression to select elements to dump. If not found, the entire document is dumped. The
/// expression can have a single replacement parameter (<c>{0}</c>). If present, it will be replaced
/// with the current document key.</remarks>
public override void Initialize(XPathNavigator configuration)
{
XPathNavigator xpathFormatNode = configuration.SelectSingleNode("xpath");
if(xpathFormatNode != null)
xpathFormat = xpathFormatNode.Value;
}
// ------------------------------------------
// Audio Management
// ------------------------------------------
public override void BeforeSpeechRecognition(string device, string text, double confidence, XPathNavigator xnav, string grammar, Stream stream, IDictionary<string, string> options) {
base.BeforeSpeechRecognition(device, text, confidence, xnav, grammar, stream, options);
var tts = xnav.SelectSingleNode("/SML/action/@tts");
if (tts != null) {
AddOnManager.GetInstance().BeforeHandleVoice(tts.Value, true);
}
}
/// <inheritdoc />
public override void Initialize(XPathNavigator configuration)
{
base.Initialize(configuration);
var lineCont = configuration.SelectSingleNode("includeLineContinuation/@value");
if(lineCont == null || !Boolean.TryParse(lineCont.Value, out includeLineContinuation))
includeLineContinuation = 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);
}
