public static List<Issue> GetIssueListFromXmlStream(Stream stream) {
List<Issue> issues = new List<Issue>();
XmlTextReader reader = new XmlTextReader(stream);
XmlDocument doc = new XmlDocument();
doc.Load(reader);
reader.Close();
XmlNodeList list = doc.DocumentElement.GetElementsByTagName("item");
XmlSerializer s = new XmlSerializer(typeof(Issue));
//Create the XmlNamespaceManager.
NameTable nt = new NameTable();
XmlNamespaceManager nsmgr = new XmlNamespaceManager(nt);
nsmgr.AddNamespace("jc", "urn:jiraconn");
//Create the XmlParserContext.
XmlParserContext context = new XmlParserContext(null, nsmgr, null, XmlSpace.None);
foreach (XmlNode item in list)
{
//Create the reader.
XmlTextReader itemReader = new XmlTextReader(item.OuterXml, XmlNodeType.Element, context);
Issue issue = (Issue)s.Deserialize(itemReader);
issues.Add(issue);
}
return issues;
}
/// <summary>
/// Implements ParseXML
/// </summary>
/// <returns></returns>
public IXmlResult ParseIATIXML(string url)
{
IXmlResult xmlResult;
var serializer = new XmlSerializer(typeof(XmlResultv1), new XmlRootAttribute("result"));
// Create an XmlNamespaceManager to resolve namespaces.
NameTable nameTable = new NameTable();
XmlNamespaceManager nsmgr = new XmlNamespaceManager(nameTable);
nsmgr.AddNamespace("iati-extra", "");
// Create an XmlParserContext. The XmlParserContext contains all the information
// required to parse the XML fragment, including the entity information and the
// XmlNamespaceManager to use for namespace resolution.
XmlParserContext xmlParserContext = new XmlParserContext(nameTable, nsmgr, null, XmlSpace.None);
// Create the reader.
XmlReaderSettings xmlReaderSettings = new XmlReaderSettings();
xmlReaderSettings.NameTable = nameTable;
using (var Reader = XmlReader.Create(url, xmlReaderSettings, xmlParserContext))
{
xmlResult = (XmlResultv1)serializer.Deserialize(Reader);
}
return xmlResult;
}
public Package(BinaryReader reader)
: this()
{
header = new PackageHeader(reader);
nameTable = new NameTable(reader);
exportTable = new ExportTable(reader);
importTable = new ImportTable(reader);
}
/// <summary>
/// Creates a namespace manager needed for XML XPath queries
/// </summary>
/// <param name="prefix"></param>
/// <returns></returns>
public static XmlNamespaceManager CreateTableauXmlNamespaceManager(string prefix)
{
var msTable = new NameTable();
var ns = new XmlNamespaceManager(msTable);
ns.AddNamespace(prefix, "http://tableausoftware.com/api");
return ns;
}
public XPathContext(NameTable nameTable)
: base(nameTable)
{
Arguments = new XsltArgumentList();
AddNamespace("xsi", Xsi);
AddNamespace("xsd", Xsd);
AddNamespace(Prefix, NamespaceUri);
AddFunction(Prefix, "match", MatchFunction.Instance);
}
public XPathContext(NameTable nameTable) : base(nameTable)
{
prefixCount = 0;
Arguments = new XsltArgumentList();
functions = new Dictionary<string, Func<IXsltContextFunction>>();
AddNamespace("xsi", Xsi);
AddNamespace("xsd", Xsd);
AddNamespace(Prefix, NamespaceUri);
AddFunction(Prefix, "match", MatchFunction.Instance);
}
// Test the default namespace manager properties.
public void TestXmlNamespaceManagerDefaults()
{
NameTable table = new NameTable();
XmlNamespaceManager ns = new XmlNamespaceManager(table);
AssertEquals("Defaults (1)",
"http://www.w3.org/XML/1998/namespace",
ns.LookupNamespace("xml"));
AssertEquals("Defaults (2)",
"http://www.w3.org/2000/xmlns/",
ns.LookupNamespace("xmlns"));
AssertEquals("Defaults (3)", "", ns.LookupNamespace(""));
Assert("Defaults (4)",
ReferenceEquals(table, ns.NameTable));
AssertEquals("Defaults (5)", "", ns.DefaultNamespace);
AssertNull("Defaults (6)", ns.LookupNamespace("foo"));
}
// Test parser context creation.
public void TestXmlParserContextConstruct()
{
NameTable nt = new NameTable();
NameTable nt2 = new NameTable();
XmlNamespaceManager ns = new XmlNamespaceManager(nt);
XmlParserContext ctx;
// Try to construct with the wrong name table.
try
{
ctx = new XmlParserContext(nt2, ns, null, XmlSpace.None);
Fail("Construct (1)");
}
catch(XmlException)
{
// Success
}
// Check default property values.
ctx = new XmlParserContext(null, ns, null, XmlSpace.None);
AssertEquals("Construct (2)", "", ctx.BaseURI);
AssertEquals("Construct (3)", "", ctx.DocTypeName);
AssertEquals("Construct (4)", null, ctx.Encoding);
AssertEquals("Construct (5)", "", ctx.InternalSubset);
AssertEquals("Construct (6)", nt, ctx.NameTable);
AssertEquals("Construct (7)", ns, ctx.NamespaceManager);
AssertEquals("Construct (8)", "", ctx.PublicId);
AssertEquals("Construct (9)", "", ctx.SystemId);
AssertEquals("Construct (10)", "", ctx.XmlLang);
AssertEquals("Construct (11)", XmlSpace.None, ctx.XmlSpace);
// Check overridden property values.
ctx = new XmlParserContext(nt, null, "doctype",
"pubid", "sysid", "internal",
"base", "lang", XmlSpace.Preserve,
Encoding.UTF8);
AssertEquals("Construct (12)", "base", ctx.BaseURI);
AssertEquals("Construct (13)", "doctype", ctx.DocTypeName);
AssertEquals("Construct (14)", Encoding.UTF8, ctx.Encoding);
AssertEquals("Construct (15)", "internal", ctx.InternalSubset);
AssertEquals("Construct (16)", nt, ctx.NameTable);
AssertEquals("Construct (17)", null, ctx.NamespaceManager);
AssertEquals("Construct (18)", "pubid", ctx.PublicId);
AssertEquals("Construct (19)", "sysid", ctx.SystemId);
AssertEquals("Construct (20)", "lang", ctx.XmlLang);
AssertEquals("Construct (21)", XmlSpace.Preserve, ctx.XmlSpace);
}
protected void Page_Load(object sender, EventArgs e)
{
int bookcount = 0;
decimal booktotal = 0;
XmlReaderSettings settings = new XmlReaderSettings();
NameTable nt = new NameTable();
object book = nt.Add("book");
object price = nt.Add("price");
settings.NameTable = nt;
string booksSchemaFile = Path.Combine(Request.PhysicalApplicationPath, "books.xsd");
settings.Schemas.Add(null, XmlReader.Create(booksSchemaFile));
settings.ValidationType = ValidationType.Schema;
settings.ValidationFlags =
XmlSchemaValidationFlags.ReportValidationWarnings;
settings.ValidationEventHandler +=
new ValidationEventHandler(settings_ValidationEventHandler);
settings.IgnoreWhitespace = true;
settings.IgnoreComments = true;
string booksFile = Path.Combine(Request.PhysicalApplicationPath, "books.xml");
using (XmlReader reader = XmlReader.Create(booksFile, settings))
{
while (reader.Read())
{
if (reader.NodeType == XmlNodeType.Element &&
book.Equals(reader.LocalName)) //A subtle, but significant change!
{
bookcount++;
}
if (reader.NodeType == XmlNodeType.Element && price.Equals(reader.LocalName))
{
booktotal +=
reader.ReadElementContentAsDecimal();
}
}
}
Response.Write(String.Format("Found {0} books that total {1:C}!",
bookcount, booktotal));
}
protected void Page_Load(object sender, EventArgs e)
{
//Create factory early
XmlSerializerFactory factory = new XmlSerializerFactory();
XmlReaderSettings settings = new XmlReaderSettings();
NameTable nt = new NameTable();
object book = nt.Add("book");
object price = nt.Add("price");
object author = nt.Add("author");
settings.NameTable = nt;
string booksSchemaFile = Path.Combine(Request.PhysicalApplicationPath, "books.xsd");
settings.Schemas.Add(null, XmlReader.Create(booksSchemaFile));
settings.ValidationType = ValidationType.Schema;
settings.ValidationFlags =
XmlSchemaValidationFlags.ReportValidationWarnings;
settings.ValidationEventHandler +=
new ValidationEventHandler(settings_ValidationEventHandler);
settings.IgnoreWhitespace = true;
settings.IgnoreComments = true;
string booksFile = Path.Combine(Request.PhysicalApplicationPath, "books.xml");
using (XmlReader reader = XmlReader.Create(booksFile, settings))
{
while (reader.Read())
{
if (reader.NodeType == XmlNodeType.Element &&
author.Equals(reader.LocalName))
{
//Then use the factory to create and cache serializers
XmlSerializer xs = factory.CreateSerializer(typeof(Author));
Author a = (Author)xs.Deserialize(reader.ReadSubtree());
Response.Write(String.Format("Author: {1}, {0}<BR/>",
a.FirstName, a.LastName));
}
}
}
}
protected XsltContext(NameTable table) : base(table) { }
public static void FixReferralSpam (string path)
{
string bad = ConfigurationManager.AppSettings["badWords"];
long badWordsCount = 0;
long totalBadWordsCount = 0;
DirectoryInfo info = new DirectoryInfo("../../");
ReferralBlackListFactory.AddBlacklist(new MovableTypeBlacklist(), Path.Combine(info.FullName, "blacklist.txt"));
if (bad != null && bad.Length > 0)
ReferralBlackListFactory.AddBlacklist(new ReferralUrlBlacklist(), bad);
string ourNamespace = "urn:newtelligence-com:dasblog:runtime:data";
foreach (string file in Directory.GetFiles(path,"*.dayfeedback.xml"))
{
badWordsCount = 0;
NameTable nt = new NameTable();
object permaLink = nt.Add("PermaLink");
XmlNamespaceManager ns = new XmlNamespaceManager(nt);
ns.AddNamespace("def", ourNamespace);
XmlDocument x = new XmlDocument(nt);
try
{
x.Load(file);
}
catch (XmlException ex)
{
WriteLine(String.Format("ERROR: Malformed Xml in file: {0}",file));
WriteLine(ex.ToString());
Console.WriteLine("Press ENTER to continue...");
Console.ReadLine();
}
XmlNodeList nodes = x.SelectNodes("/def:DayExtra/def:Trackings/def:Tracking", ns);
Console.WriteLine("Found {0} trackings/referrals in {1}",nodes.Count,file);
for (int i = 0; i < nodes.Count; i++)
{
XmlNode node = nodes[i];
XmlNode permaLinkNode = node[(string)permaLink];
if (permaLinkNode != null && IsBadNode(permaLinkNode.InnerText))
{
badWordsCount++;
totalBadWordsCount++;
node.ParentNode.RemoveChild(node);
}
}
if (badWordsCount > 0)
{
x.Save(file);
}
WriteLine(String.Format("Found {0} bad words in {1}...", badWordsCount, Path.GetFileName(file)));
}
}
public static int Main(string[] args)
{
ParseCommandLine(args);
CommandLineTraceHandler.Enable();
if (s_listRules)
{
CompositionHost c = GetCompositionHost();
ExportCciSettings.StaticSettings = CciComparers.Default.GetEqualityComparer <ITypeReference>();
var rules = c.GetExports <IDifferenceRule>();
foreach (var rule in rules.Select(r => r.GetType().Name).OrderBy(r => r, StringComparer.OrdinalIgnoreCase))
{
Console.WriteLine(rule);
}
return(0);
}
using (TextWriter output = GetOutput())
{
if (DifferenceWriter.ExitCode != 0)
{
return(0);
}
if (output != Console.Out)
{
Trace.Listeners.Add(new TextWriterTraceListener(output)
{
Filter = new EventTypeFilter(SourceLevels.Error | SourceLevels.Warning)
});
}
try
{
BaselineDifferenceFilter filter = GetBaselineDifferenceFilter();
NameTable sharedNameTable = new NameTable();
HostEnvironment contractHost = new HostEnvironment(sharedNameTable);
contractHost.UnableToResolve += new EventHandler <UnresolvedReference <IUnit, AssemblyIdentity> >(contractHost_UnableToResolve);
contractHost.ResolveAgainstRunningFramework = s_resolveFx;
contractHost.UnifyToLibPath = s_unifyToLibPaths;
contractHost.AddLibPaths(HostEnvironment.SplitPaths(s_contractLibDirs));
IEnumerable <IAssembly> contractAssemblies = contractHost.LoadAssemblies(s_contractSet, s_contractCoreAssembly);
if (s_ignoreDesignTimeFacades)
{
contractAssemblies = contractAssemblies.Where(a => !a.IsFacade());
}
HostEnvironment implHost = new HostEnvironment(sharedNameTable);
implHost.UnableToResolve += new EventHandler <UnresolvedReference <IUnit, AssemblyIdentity> >(implHost_UnableToResolve);
implHost.ResolveAgainstRunningFramework = s_resolveFx;
implHost.UnifyToLibPath = s_unifyToLibPaths;
implHost.AddLibPaths(HostEnvironment.SplitPaths(s_implDirs));
if (s_warnOnMissingAssemblies)
{
implHost.LoadErrorTreatment = ErrorTreatment.TreatAsWarning;
}
// The list of contractAssemblies already has the core assembly as the first one (if _contractCoreAssembly was specified).
IEnumerable <IAssembly> implAssemblies = implHost.LoadAssemblies(contractAssemblies.Select(a => a.AssemblyIdentity), s_warnOnIncorrectVersion);
// Exit after loading if the code is set to non-zero
if (DifferenceWriter.ExitCode != 0)
{
return(0);
}
ICciDifferenceWriter writer = GetDifferenceWriter(output, filter);
writer.Write(s_implDirs, implAssemblies, s_contractSet, contractAssemblies);
return(0);
}
catch (FileNotFoundException)
{
// FileNotFoundException will be thrown by GetBaselineDifferenceFilter if it doesn't find the baseline file
// OR if GetComparers doesn't find the remap file.
return(2);
}
}
}
/// <summary>
/// Same as <see cref="XmlNamespaceManager"/>.
/// </summary>
public override string?LookupNamespace(string prefix)
{
var key = NameTable?.Get(prefix);
return(key == null ? null : base.LookupNamespace(key));
}
// Test parser context property changes.
public void TestXmlParserContextProperties()
{
NameTable nt = new NameTable();
NameTable nt2 = new NameTable();
XmlNamespaceManager ns = new XmlNamespaceManager(nt);
XmlParserContext ctx = new XmlParserContext
(nt, ns, null, XmlSpace.None);
// Set and check the various properties.
ctx.BaseURI = "xyzzy";
AssertEquals("BaseURI (1)", "xyzzy", ctx.BaseURI);
ctx.BaseURI = null;
AssertEquals("BaseURI (2)", "", ctx.BaseURI);
ctx.DocTypeName = "xyzzy";
AssertEquals("DocTypeName (1)", "xyzzy", ctx.DocTypeName);
ctx.DocTypeName = null;
AssertEquals("DocTypeName (2)", "", ctx.DocTypeName);
ctx.Encoding = Encoding.UTF8;
AssertEquals("Encoding (1)", Encoding.UTF8, ctx.Encoding);
ctx.Encoding = null;
AssertEquals("Encoding (2)", null, ctx.Encoding);
ctx.InternalSubset = "xyzzy";
AssertEquals("InternalSubset (1)", "xyzzy", ctx.InternalSubset);
ctx.InternalSubset = null;
AssertEquals("InternalSubset (2)", "", ctx.InternalSubset);
ctx.NameTable = nt2;
AssertEquals("NameTable (1)", nt2, ctx.NameTable);
ctx.NameTable = null;
AssertEquals("NameTable (2)", null, ctx.NameTable);
ctx.NamespaceManager = null;
AssertEquals("NamespaceManager (1)", null,
ctx.NamespaceManager);
ctx.NamespaceManager = ns;
AssertEquals("NamespaceManager (2)", ns, ctx.NamespaceManager);
ctx.PublicId = "xyzzy";
AssertEquals("PublicId (1)", "xyzzy", ctx.PublicId);
ctx.PublicId = null;
AssertEquals("PublicId (2)", "", ctx.PublicId);
ctx.SystemId = "xyzzy";
AssertEquals("SystemId (1)", "xyzzy", ctx.SystemId);
ctx.SystemId = null;
AssertEquals("PublicId (2)", "", ctx.SystemId);
ctx.XmlLang = "xyzzy";
AssertEquals("XmlLang (1)", "xyzzy", ctx.XmlLang);
ctx.XmlLang = null;
AssertEquals("XmlLang (2)", "", ctx.XmlLang);
ctx.XmlSpace = XmlSpace.Default;
AssertEquals("XmlSpace (1)", XmlSpace.Default, ctx.XmlSpace);
ctx.XmlSpace = XmlSpace.None;
AssertEquals("XmlSpace (2)", XmlSpace.None, ctx.XmlSpace);
}
// Check the "RemoveNamespace" method.
public void TestXmlNamespaceManagerRemove()
{
NameTable table = new NameTable();
XmlNamespaceManager ns = new XmlNamespaceManager(table);
// Test the exception behaviour.
try
{
ns.AddNamespace(null, "uri");
Fail("Remove (1)");
}
catch(ArgumentNullException)
{
// Success
}
try
{
ns.AddNamespace("prefix", null);
Fail("Remove (2)");
}
catch(ArgumentNullException)
{
// Success
}
// Cannot remove standard namespaces.
ns.RemoveNamespace
("xml", "http://www.w3.org/XML/1998/namespace");
AssertEquals("Remove (3)",
"http://www.w3.org/XML/1998/namespace",
ns.LookupNamespace("xml"));
ns.RemoveNamespace
("xmlns", "http://www.w3.org/2000/xmlns/");
AssertEquals("Remove (3)",
"http://www.w3.org/2000/xmlns/",
ns.LookupNamespace("xmlns"));
// Add and remove a particular namespace.
ns.AddNamespace("foo", "uri");
ns.RemoveNamespace("foo", "uri");
AssertNull("Remove (4)", ns.LookupNamespace("foo"));
// Make sure that we cannot remove namespaces in parent scopes.
ns.AddNamespace("foo", "uri");
ns.PushScope();
ns.RemoveNamespace("foo", "uri");
AssertEquals("Remove (5)", "uri", ns.LookupNamespace("foo"));
// Try removing a namespace with the wrong URI or prefix.
ns.AddNamespace("foo", "uri2");
ns.RemoveNamespace("foo", "uri");
AssertEquals("Remove (6)", "uri2", ns.LookupNamespace("foo"));
ns.RemoveNamespace("foo2", "uri");
AssertEquals("Remove (7)", "uri2", ns.LookupNamespace("foo"));
}
public static bool Execute(
string seeds,
string contracts,
string facadePath,
Version assemblyFileVersion = null,
bool clearBuildAndRevision = false,
bool ignoreMissingTypes = false,
bool ignoreBuildAndRevisionMismatch = false,
bool buildDesignTimeFacades = false,
string inclusionContracts = null,
ErrorTreatment seedLoadErrorTreatment = ErrorTreatment.Default,
ErrorTreatment contractLoadErrorTreatment = ErrorTreatment.Default,
string[] seedTypePreferencesUnsplit = null,
bool forceZeroVersionSeeds = false,
bool producePdb = true,
string partialFacadeAssemblyPath = null,
bool buildPartialReferenceFacade = false)
{
if (!Directory.Exists(facadePath))
{
Directory.CreateDirectory(facadePath);
}
var nameTable = new NameTable();
var internFactory = new InternFactory();
try
{
Dictionary <string, string> seedTypePreferences = ParseSeedTypePreferences(seedTypePreferencesUnsplit);
using (var contractHost = new HostEnvironment(nameTable, internFactory))
using (var seedHost = new HostEnvironment(nameTable, internFactory))
{
contractHost.LoadErrorTreatment = contractLoadErrorTreatment;
seedHost.LoadErrorTreatment = seedLoadErrorTreatment;
var contractAssemblies = LoadAssemblies(contractHost, contracts);
IReadOnlyDictionary <string, IEnumerable <string> > docIdTable = GenerateDocIdTable(contractAssemblies, inclusionContracts);
IAssembly[] seedAssemblies = LoadAssemblies(seedHost, seeds).ToArray();
IAssemblyReference seedCoreAssemblyRef = ((Microsoft.Cci.Immutable.PlatformType)seedHost.PlatformType).CoreAssemblyRef;
if (forceZeroVersionSeeds)
{
// Create a deep copier, copy the seed assemblies, and zero out their versions.
var copier = new MetadataDeepCopier(seedHost);
for (int i = 0; i < seedAssemblies.Length; i++)
{
var mutableSeed = copier.Copy(seedAssemblies[i]);
mutableSeed.Version = new Version(0, 0, 0, 0);
// Copy the modified seed assembly back.
seedAssemblies[i] = mutableSeed;
if (mutableSeed.Name.UniqueKey == seedCoreAssemblyRef.Name.UniqueKey)
{
seedCoreAssemblyRef = mutableSeed;
}
}
}
var typeTable = GenerateTypeTable(seedAssemblies);
var facadeGenerator = new FacadeGenerator(seedHost, contractHost, docIdTable, typeTable, seedTypePreferences, clearBuildAndRevision, buildDesignTimeFacades, assemblyFileVersion);
if (buildPartialReferenceFacade && ignoreMissingTypes)
{
throw new FacadeGenerationException(
"When buildPartialReferenceFacade is specified ignoreMissingTypes must not be specified.");
}
if (partialFacadeAssemblyPath != null)
{
if (contractAssemblies.Count() != 1)
{
throw new FacadeGenerationException(
"When partialFacadeAssemblyPath is specified, only exactly one corresponding contract assembly can be specified.");
}
if (buildPartialReferenceFacade)
{
throw new FacadeGenerationException(
"When partialFacadeAssemblyPath is specified, buildPartialReferenceFacade must not be specified.");
}
IAssembly contractAssembly = contractAssemblies.First();
IAssembly partialFacadeAssembly = seedHost.LoadAssembly(partialFacadeAssemblyPath);
if (contractAssembly.Name != partialFacadeAssembly.Name ||
contractAssembly.Version.Major != partialFacadeAssembly.Version.Major ||
contractAssembly.Version.Minor != partialFacadeAssembly.Version.Minor ||
(!ignoreBuildAndRevisionMismatch && contractAssembly.Version.Build != partialFacadeAssembly.Version.Build) ||
(!ignoreBuildAndRevisionMismatch && contractAssembly.Version.Revision != partialFacadeAssembly.Version.Revision) ||
contractAssembly.GetPublicKeyToken() != partialFacadeAssembly.GetPublicKeyToken())
{
throw new FacadeGenerationException(
string.Format("The partial facade assembly's name, version, and public key token must exactly match the contract to be filled. Contract: {0}, Facade: {1}",
contractAssembly.AssemblyIdentity,
partialFacadeAssembly.AssemblyIdentity));
}
Assembly filledPartialFacade = facadeGenerator.GenerateFacade(contractAssembly, seedCoreAssemblyRef, ignoreMissingTypes,
overrideContractAssembly: partialFacadeAssembly,
forceAssemblyReferenceVersionsToZero: forceZeroVersionSeeds);
if (filledPartialFacade == null)
{
Trace.TraceError("Errors were encountered while generating the facade.");
return(false);
}
string pdbLocation = null;
if (producePdb)
{
string pdbFolder = Path.GetDirectoryName(partialFacadeAssemblyPath);
pdbLocation = Path.Combine(pdbFolder, contractAssembly.Name + ".pdb");
if (producePdb && !File.Exists(pdbLocation))
{
pdbLocation = null;
Trace.TraceWarning("No PDB file present for un-transformed partial facade. No PDB will be generated.");
}
}
OutputFacadeToFile(facadePath, seedHost, filledPartialFacade, contractAssembly, pdbLocation);
}
else
{
foreach (var contract in contractAssemblies)
{
Assembly facade = facadeGenerator.GenerateFacade(contract, seedCoreAssemblyRef, ignoreMissingTypes, buildPartialReferenceFacade: buildPartialReferenceFacade);
if (facade == null)
{
#if !COREFX
Debug.Assert(Environment.ExitCode != 0);
#endif
return(false);
}
OutputFacadeToFile(facadePath, seedHost, facade, contract);
}
}
}
return(true);
}
catch (FacadeGenerationException ex)
{
Trace.TraceError(ex.Message);
#if !COREFX
Debug.Assert(Environment.ExitCode != 0);
#endif
return(false);
}
}
static void Main(string[] args)
{
//if (args.Length < 1)
//{
// System.Console.Out.WriteLine("usage: SQLBibleAddRegEx connString");
// return;
//}
connString = null;
if (args.Length > 0)
{
connString = args[0];
}
else
{
connString = @"Server=localhost\SQLEXPRESS2014;Initial Catalog=AnalyzeBible_Dev;Trusted_Connection=true";
}
if (args.Length > 1)
{
outputFile = args[1];
}
else
{
//outputFile = Environment.ExpandEnvironmentVariables(@"%USERPROFILE%\documents\RDF\bible.rdf");
outputFile = Environment.ExpandEnvironmentVariables(@"%USERPROFILE%\documents\RDF\genesis.rdf");
System.IO.FileInfo fileInfo = new System.IO.FileInfo(outputFile);
if (!fileInfo.Directory.Exists)
{
fileInfo.Directory.Create();
}
}
XmlNameTable nameTable = new NameTable();
XmlNamespaceManager namespaceManager = new XmlNamespaceManager(nameTable);
namespaceManager.AddNamespace("person", "http://www.rdfbible.com/dev3/ns/person.owl");
namespaceManager.AddNamespace("xsd", "http://www.w3.org/2001/XMLSchema#");
namespaceManager.AddNamespace("rdf", "http://www.w3.org/1999/02/22-rdf-syntax-ns#");
namespaceManager.AddNamespace("rdfs", "http://www.w3.org/2000/01/rdf-schema#");
XmlDocument xmlDocument = new XmlDocument(namespaceManager.NameTable);
XmlNode root = xmlDocument.CreateElement("rdf", "RDF", "http://www.w3.org/1999/02/22-rdf-syntax-ns#");
xmlDocument.AppendChild(root);
Dictionary <string, HashSet <string> > parentChildren = new Dictionary <string, HashSet <string> >();
Dictionary <string, Tuple <string, bool, bool> > nameGenderVisionDreams = new Dictionary <string, Tuple <string, bool, bool> >();
BibleEdition bibleEdition = new BibleEdition();
bibleEdition.BibleKey = "kjv";
bibleEdition.BibleName = "KJV";
bibleEdition.BibleBooks = new List <BibleBook>();
using (SqlConnection con = new SqlConnection(connString))
{
con.Open();
using (SqlCommand cmd = new SqlCommand())
{
cmd.Connection = con;
cmd.CommandText = "dbo.GetBibleVerses";
cmd.CommandType = System.Data.CommandType.StoredProcedure;
cmd.Parameters.AddWithValue("@BibleName", "KJV");
cmd.Parameters.AddWithValue("@BibleBook", "Genesis");
using (SqlDataReader reader = cmd.ExecuteReader())
{
while (reader.Read())
{
string bookName = (string)reader["BookName"];
short chapterNumber = (short)reader["ChapterNumber"];
short verseNumber = (short)reader["VerseNumber"];
string verseText = (string)reader["VerseText"];
BibleBook book = GetBook(bibleEdition, bookName);
BibleChapter chapter = GetChapter(book, chapterNumber);
BibleVerse verse = GetVerse(chapter, verseNumber);
verse.VerseText = verseText;
List <string> words = GetWords(verseText).ToList();
SetWords(verse, words);
}
}
}
}
XmlNode xbibleEdition = xmlDocument.CreateElement("bible", "BibleEdition", "http://www.rdfbible.com/dev3/ns/bible.owl");
root.AppendChild(xbibleEdition);
XmlAttribute id = xmlDocument.CreateAttribute("rdf", "ID", "http://www.w3.org/1999/02/22-rdf-syntax-ns#");
id.Value = bibleEdition.BibleKey;
xbibleEdition.Attributes.Append(id);
XmlNode editionName = xmlDocument.CreateElement("bible", "name", "http://www.rdfbible.com/dev3/ns/bible.owl");
editionName.InnerText = bibleEdition.BibleName;
xbibleEdition.AppendChild(editionName);
foreach (var bibleBook in bibleEdition.BibleBooks)
{
XmlNode book = xmlDocument.CreateElement("bible", "BibleBook", "http://www.rdfbible.com/dev3/ns/bible.owl");
root.AppendChild(book);
XmlAttribute id2 = xmlDocument.CreateAttribute("rdf", "ID", "http://www.w3.org/1999/02/22-rdf-syntax-ns#");
id2.Value = bibleBook.BookKey;
book.Attributes.Append(id2);
XmlNode bookName = xmlDocument.CreateElement("bible", "name", "http://www.rdfbible.com/dev3/ns/bible.owl");
bookName.InnerText = bibleBook.BookName;
book.AppendChild(bookName);
XmlNode hasBibleBook = xmlDocument.CreateElement("bible", "hasBibleBook", "http://www.rdfbible.com/dev3/ns/bible.owl");
xbibleEdition.AppendChild(hasBibleBook);
XmlAttribute hasBibleBookReference = xmlDocument.CreateAttribute("rdf", "resource", "http://www.w3.org/1999/02/22-rdf-syntax-ns#");
hasBibleBookReference.Value = "#" + bibleBook.BookKey;
hasBibleBook.Attributes.Append(hasBibleBookReference);
foreach (var bibleChapter in bibleBook.BibleChapters)
{
XmlNode chapter = xmlDocument.CreateElement("bible", "BibleChapter", "http://www.rdfbible.com/dev3/ns/bible.owl");
root.AppendChild(chapter);
XmlAttribute id3 = xmlDocument.CreateAttribute("rdf", "ID", "http://www.w3.org/1999/02/22-rdf-syntax-ns#");
id3.Value = bibleChapter.ChapterKey;
chapter.Attributes.Append(id3);
XmlNode chapterNumber = xmlDocument.CreateElement("bible", "number", "http://www.rdfbible.com/dev3/ns/bible.owl");
chapterNumber.InnerText = bibleChapter.ChapterNumber.ToString();
chapter.AppendChild(chapterNumber);
XmlNode hasBibleChapter = xmlDocument.CreateElement("bible", "hasBibleChapter", "http://www.w3.org/1999/02/22-rdf-syntax-ns#");
book.AppendChild(hasBibleChapter);
XmlAttribute hasBibleChapterReference = xmlDocument.CreateAttribute("rdf", "resource", "http://www.w3.org/1999/02/22-rdf-syntax-ns#");
hasBibleChapterReference.Value = "#" + bibleChapter.ChapterKey;
hasBibleChapter.Attributes.Append(hasBibleChapterReference);
foreach (var bibleVerse in bibleChapter.BibleVerses)
{
XmlNode verse = xmlDocument.CreateElement("bible", "BibleVerse", "http://www.rdfbible.com/dev3/ns/bible.owl");
root.AppendChild(verse);
XmlAttribute id4 = xmlDocument.CreateAttribute("rdf", "ID", "http://www.w3.org/1999/02/22-rdf-syntax-ns#");
id4.Value = bibleVerse.VerseKey;
verse.Attributes.Append(id4);
XmlNode verseNumber = xmlDocument.CreateElement("bible", "number", "http://www.rdfbible.com/dev3/ns/bible.owl");
verseNumber.InnerText = bibleVerse.VerseNumber.ToString();
verse.AppendChild(verseNumber);
XmlNode verseText = xmlDocument.CreateElement("bible", "text", "http://www.rdfbible.com/dev3/ns/bible.owl");
verseText.InnerText = bibleVerse.VerseText;
verse.AppendChild(verseText);
XmlNode hasBibleVerse = xmlDocument.CreateElement("bible", "hasBibleVerse", "http://www.rdfbible.com/dev3/ns/bible.owl");
chapter.AppendChild(hasBibleVerse);
XmlAttribute hasBibleVerseReference = xmlDocument.CreateAttribute("rdf", "resource", "http://www.w3.org/1999/02/22-rdf-syntax-ns#");
hasBibleVerseReference.Value = "#" + bibleVerse.VerseKey;
hasBibleVerse.Attributes.Append(hasBibleVerseReference);
foreach (var bibleWord in bibleVerse.Words)
{
XmlNode word = xmlDocument.CreateElement("bible", "BibleWord", "http://www.rdfbible.com/dev3/ns/bible.owl");
root.AppendChild(word);
XmlAttribute id5 = xmlDocument.CreateAttribute("rdf", "ID", "http://www.w3.org/1999/02/22-rdf-syntax-ns#");
id5.Value = bibleWord.WordKey;
word.Attributes.Append(id5);
XmlElement wordText = xmlDocument.CreateElement("bible", "text", "http://www.rdfbible.com/dev3/ns/bible.owl");
wordText.InnerText = bibleWord.Word;
word.AppendChild(wordText);
XmlNode hasBibleWord = xmlDocument.CreateElement("bible", "hasBibleWord", "http://www.rdfbible.com/dev3/ns/bible.owl");
verse.AppendChild(hasBibleWord);
XmlAttribute hasBibleWordReference = xmlDocument.CreateAttribute("rdf", "resource", "http://www.rdfbible.com/dev3/ns/bible.owl");
hasBibleWordReference.Value = "#" + bibleWord.WordKey;
hasBibleWord.Attributes.Append(hasBibleWordReference);
}
}
}
}
xmlDocument.Save(outputFile);
}
public override IEnumerable <LogItem> GetEntries(string dataSource, FilterParams filter)
{
var settings = new XmlReaderSettings {
ConformanceLevel = ConformanceLevel.Fragment
};
var nt = new NameTable();
var mgr = new XmlNamespaceManager(nt);
mgr.AddNamespace("log4j", Constants.LAYOUT_LOG4J);
var pc = new XmlParserContext(nt, mgr, string.Empty, XmlSpace.Default);
var date = new DateTime(1970, 1, 1, 0, 0, 0, 0);
using (var stream = new FileStream(dataSource, FileMode.OpenOrCreate, FileAccess.Read, FileShare.ReadWrite))
{
using (var reader = new StreamReader(stream, System.Text.Encoding.Default, true))
{
using (var xmlTextReader = XmlReader.Create(reader, settings, pc))
{
var entryId = 1;
DateTime?prevTimeStamp = null;
while (xmlTextReader.Read())
{
if ((xmlTextReader.NodeType != XmlNodeType.Element) || (xmlTextReader.Name != "log4j:event"))
{
continue;
}
var entry = new LogItem {
Id = entryId, Path = dataSource
};
entry.Logger = xmlTextReader.GetAttribute("logger");
entry.TimeStamp = date.AddMilliseconds(Convert.ToDouble(xmlTextReader.GetAttribute("timestamp"))).ToLocalTime();
if (prevTimeStamp.HasValue)
{
entry.Delta = (entry.TimeStamp - prevTimeStamp.Value).TotalSeconds;
}
prevTimeStamp = entry.TimeStamp;
entry.Level = xmlTextReader.GetAttribute("level");
entry.Thread = xmlTextReader.GetAttribute("thread");
while (xmlTextReader.Read())
{
var breakLoop = false;
switch (xmlTextReader.Name)
{
case "log4j:event":
breakLoop = true;
break;
default:
switch (xmlTextReader.Name)
{
case ("log4j:message"):
entry.Message = xmlTextReader.ReadString();
break;
case ("log4j:data"):
switch (xmlTextReader.GetAttribute("name"))
{
case ("log4net:UserName"):
entry.UserName = xmlTextReader.GetAttribute("value");
break;
case ("log4japp"):
entry.App = xmlTextReader.GetAttribute("value");
break;
case ("log4jmachinename"):
entry.MachineName = xmlTextReader.GetAttribute("value");
break;
case ("log4net:HostName"):
entry.HostName = xmlTextReader.GetAttribute("value");
break;
}
break;
case ("log4j:throwable"):
entry.Throwable = xmlTextReader.ReadString();
break;
case ("log4j:locationInfo"):
entry.Class = xmlTextReader.GetAttribute("class");
entry.Method = xmlTextReader.GetAttribute("method");
entry.File = xmlTextReader.GetAttribute("file");
entry.Line = xmlTextReader.GetAttribute("line");
break;
}
break;
}
if (breakLoop)
{
break;
}
}
if (filterByParameters(entry, filter))
{
yield return(entry);
entryId++;
}
}
}
}
}
}
public static IInitializeDocumentSpec InitializeDocumentSpec(IDocumentSpec documentSpec, string documentSpecName, string schemaFileName, ArrayList propertyAnnotations)
{
IInitializeDocumentSpec spec = (IInitializeDocumentSpec)documentSpec;
XmlDocument xmlDocument = new XmlDocument();
xmlDocument.Load(new XmlTextReader(schemaFileName));
string documentType = GetDocumentType(xmlDocument);
string targetNamespace = GetTargetNamespace(xmlDocument);
string bodyXPath = GetBodyXPath(xmlDocument);
Hashtable schemaList = new Hashtable();
schemaList.Add(targetNamespace, new FileStream(schemaFileName, FileMode.Open, FileAccess.Read));
spec.Initialize(targetNamespace, documentSpecName, documentType, bodyXPath, schemaList);
NameTable nameTable = new NameTable();
XmlNamespaceManager nsmgr = new XmlNamespaceManager(nameTable);
nsmgr.AddNamespace("xs", "http://www.w3.org/2001/XMLSchema");
nsmgr.AddNamespace("b", "http://schemas.microsoft.com/BizTalk/2003");
Hashtable hashtable2 = new Hashtable();
Hashtable hashtable3 = new Hashtable();
foreach (XmlNode node in xmlDocument.SelectNodes("/xs:schema/xs:annotation/xs:appinfo/b:imports/b:namespace", nsmgr))
{
hashtable2.Add(node.Attributes["prefix"].InnerText, node.Attributes["uri"].InnerText);
string innerText = node.Attributes["location"].InnerText;
if (new FileInfo(innerText).Exists)
{
XmlDocument document2 = new XmlDocument();
document2.Load(innerText);
hashtable3.Add(node.Attributes["uri"].InnerText, document2);
}
}
foreach (XmlNode node2 in xmlDocument.SelectNodes("/xs:schema//xs:annotation/xs:appinfo/b:properties/b:property[not(@distinguished='true')]", nsmgr))
{
PropertyAnnotation annotation = new PropertyAnnotation();
string str5 = node2.Attributes["name"].InnerText;
annotation.Name = str5.Split(new char[] { ':' })[1];
annotation.Namespace = (string)hashtable2[str5.Split(new char[] { ':' })[0]];
annotation.XPath = node2.Attributes["xpath"].InnerText;
annotation.XSDType = null;
XmlDocument document3 = (XmlDocument)hashtable3[annotation.Namespace];
if (document3 != null)
{
XmlNode node3 = document3.SelectSingleNode(string.Format(CultureInfo.CurrentCulture, "/xs:schema/xs:element[@name='{0}']", new object[] { annotation.Name }), nsmgr);
if (node3 != null)
{
XmlNode node4 = node3.Attributes["type"];
if (node4 != null)
{
string[] strArray = node4.InnerText.Split(new char[] { ':' });
if (2 == strArray.Length)
{
annotation.XSDType = strArray[1];
}
else if (1 == strArray.Length)
{
annotation.XSDType = strArray[0];
}
}
}
}
if (annotation.XSDType == null)
{
annotation.XSDType = "string";
}
if (propertyAnnotations != null)
{
propertyAnnotations.Add(annotation);
}
spec.AddAnnotation(annotation);
}
return(spec);
}
public static bool Import(TextReader streamReader, IResource rootGroup, bool addToWorkspace, Hashtable namespaces)
{
bool hasOPML = false;
bool lastOutlineIsGroup = false;
try
{
NameTable nt = new NameTable();
// Fill name table
if (namespaces != null)
{
foreach (string key in namespaces.Keys)
{
nt.Add(key);
nt.Add(namespaces[key] as string);
}
}
XmlNamespaceManager nsmgr = new LooseNSManager(nt, namespaces);
XmlParserContext ctx = new XmlParserContext(nt, nsmgr, null, XmlSpace.None);
string xml = Utils.StreamReaderReadToEnd(streamReader);
XmlTextReader reader = new XmlTextReader(xml, XmlNodeType.Document, ctx);
try
{
IResource curGroup = rootGroup;
while (reader.Read())
{
if (reader.NodeType == XmlNodeType.Element)
{
if (reader.LocalName == "opml")
{
hasOPML = true;
}
else
if (hasOPML && reader.LocalName == "outline")
{
if (reader.MoveToAttribute("xmlUrl") || reader.MoveToAttribute("xmlurl"))
{
ProcessFeed(reader, curGroup, addToWorkspace);
}
else if (reader.MoveToAttribute("text") || reader.MoveToAttribute("title"))
{
IResource group = FindOrCreateGroup(curGroup, reader.Value);
reader.MoveToElement();
if (!reader.IsEmptyElement)
{
curGroup = group;
lastOutlineIsGroup = true;
}
}
}
}
else if (reader.NodeType == XmlNodeType.EndElement)
{
if (reader.LocalName == "outline")
{
if (lastOutlineIsGroup)
{
curGroup = curGroup.GetLinkProp("Parent");
lastOutlineIsGroup = true;
}
}
}
}
}
finally
{
reader.Close();
}
}
finally
{
streamReader.Close();
}
return(hasOPML);
}
public override string LookupPrefix(string uri)
{
var key = NameTable.Get(uri);
return(key == null ? null : base.LookupPrefix(key));
}
/// <summary>
/// Main entry point for sample application.
/// </summary>
/// <param name="args"></param>
public static void Main(string[] args)
{
XmlSchema myXmlSchema;
XmlTextWriter myXmlTextWriter;
try
{
Console.WriteLine("Creating Schema in the Schema Object Model...");
// Setup console output.
myXmlTextWriter = new XmlTextWriter(Console.Out);
myXmlTextWriter.Formatting = Formatting.Indented;
myXmlTextWriter.Indentation = 2;
//Create an XmlNameTable.
XmlNameTable myXmlNameTable = new NameTable();
//Add the nametable to the XmlSchemaCollection.
XmlSchemaCollection myXmlSchemaCollection = new XmlSchemaCollection(myXmlNameTable);
//Add some schemas to the XmlSchemaCollection.
Console.WriteLine("Reading and adding {0} schema.", BOOKSCHEMA);
myXmlSchemaCollection.Add(null, BOOKSCHEMA);
Console.WriteLine("Reading and adding {0} schema.", POSCHEMA);
myXmlSchemaCollection.Add(null, POSCHEMA);
Console.WriteLine("Added schemas successfully ...");
Console.WriteLine("Showing added schemas");
foreach (XmlSchema myTempXmlSchema in myXmlSchemaCollection)
{
myXmlSchema = myTempXmlSchema;
Console.WriteLine();
string outfile = myTempXmlSchema.SourceUri.Replace("file:///", "");
Console.WriteLine("Schema from: {0}", outfile);
Console.WriteLine();
Console.WriteLine("=== Start of Schema ===");
Console.WriteLine();
// Write out the various schema parts
WriteXSDSchema(myXmlSchema, myXmlTextWriter);
Console.WriteLine();
Console.WriteLine();
Console.WriteLine("=== End of Schema ===");
Console.WriteLine();
Console.WriteLine("Example of possible XML contents for: {0}", outfile);
Console.WriteLine();
Console.WriteLine("=== Start of Example ===");
// Write out an example of the XML for the schema
WriteExample(myXmlSchema, myXmlTextWriter);
Console.WriteLine();
Console.WriteLine();
Console.WriteLine("=== End of Example ===");
} //foreach
} //try
catch (Exception e)
{
Console.WriteLine("Exception: {0}", e.ToString());
} //catch
} //Main()
/// <summary>
/// Constructor
/// </summary>
/// <param name="nametable"></param>
public ExtendedXPathFunctions(NameTable nametable)
: base(nametable)
{
}
// Check the "HasNamespace" method.
public void TestXmlNamespaceManagerHas()
{
NameTable table = new NameTable();
XmlNamespaceManager ns = new XmlNamespaceManager(table);
Assert("Has (1)", ns.HasNamespace("xml"));
Assert("Has (2)", ns.HasNamespace("xmlns"));
Assert("Has (3)", ns.HasNamespace(""));
Assert("Has (4)", !ns.HasNamespace("foo"));
ns.AddNamespace("foo", "uri");
Assert("Has (5)", ns.HasNamespace("xml"));
Assert("Has (6)", ns.HasNamespace("xmlns"));
Assert("Has (7)", ns.HasNamespace(""));
Assert("Has (8)", ns.HasNamespace("foo"));
ns.PushScope();
ns.AddNamespace("bar", "uri2");
Assert("Has (9)", ns.HasNamespace("xml"));
Assert("Has (10)", ns.HasNamespace("xmlns"));
Assert("Has (11)", ns.HasNamespace(""));
Assert("Has (12)", ns.HasNamespace("foo"));
Assert("Has (13)", ns.HasNamespace("bar"));
ns.PopScope();
Assert("Has (14)", ns.HasNamespace("xml"));
Assert("Has (15)", ns.HasNamespace("xmlns"));
Assert("Has (16)", ns.HasNamespace(""));
Assert("Has (17)", ns.HasNamespace("foo"));
Assert("Has (18)", !ns.HasNamespace("bar"));
ns.RemoveNamespace("foo", "uri");
Assert("Has (19)", ns.HasNamespace("xml"));
Assert("Has (20)", ns.HasNamespace("xmlns"));
Assert("Has (21)", ns.HasNamespace(""));
Assert("Has (22)", !ns.HasNamespace("foo"));
Assert("Has (23)", !ns.HasNamespace("bar"));
ns.RemoveNamespace("", "");
Assert("Has (24)", ns.HasNamespace("xml"));
Assert("Has (25)", ns.HasNamespace("xmlns"));
Assert("Has (26)", ns.HasNamespace(""));
Assert("Has (27)", !ns.HasNamespace("foo"));
Assert("Has (28)", !ns.HasNamespace("bar"));
Assert("Has (29)", !ns.HasNamespace(null));
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="nametable"></param>
/// <param name="Args"></param>
public ExtendedXPathFunctions(NameTable nametable, XsltArgumentList Args)
: base(nametable)
{
ArgumentList = Args;
}
public DynamicContext(NameTable table)
: base(table)
{
}
private NameManager(NameTable nameTable)
{
_names = nameTable;
InitKnownNames();
}
/// <summary>
/// Creates new ExsltContext instance.
/// </summary>
public ExsltContext(NameTable nt, ExsltFunctionNamespace supportedFunctions)
: this(nt)
{
SupportedFunctions = supportedFunctions;
}
void WebClient_OpenReadCompleted(object sender, OpenReadCompletedEventArgs e)
{
if (e.Cancelled || _targetItem == null)
{
return;
}
Exception ex = e.Error;
if (ex == null)
{
try
{
if (_targetItem.Tile == null)
{
var doc = new XmlDocument();
doc.Load(e.Result);
var nameTable = new NameTable();
var nm = new XmlNamespaceManager(nameTable);
nm.AddNamespace("ns", "http://www.w3.org/2005/Atom");
nm.AddNamespace("flickr", "urn:flickr:user");
List <FlickrPhoto> result = new List <FlickrPhoto>();
TileCollection tiles = flickrTiles.Groups[0].Tiles;
bool keepExistent = _targetItem.IsBuddyIcon;
foreach (XmlNode node in doc.DocumentElement.SelectNodes("ns:entry", nm))
{
string id = node.SelectSingleNode("ns:id", nm).InnerText;
if (keepExistent)
{
bool found = false;
foreach (Tile tile in tiles)
{
if (((FlickrPhoto)tile.Tag).ID == id)
{
found = true;
break;
}
}
if (found)
{
continue;
}
}
var photo = new FlickrPhoto();
photo.ID = id;
photo.Title = PrepareTitle(node.SelectSingleNode("ns:title", nm).InnerText);
var authorNode = node.SelectSingleNode("ns:author", nm);
if (authorNode != null)
{
photo.AuthorName = authorNode.SelectSingleNode("ns:name", nm).InnerText;
photo.AuthorBuddyIconUri = authorNode.SelectSingleNode("flickr:buddyicon", nm).InnerText;
}
var linkNode = node.SelectSingleNode("ns:link[@rel='enclosure']", nm);
if (linkNode != null)
{
photo.ContentUri = linkNode.Attributes["href"].Value;
photo.ThumbnailUri = photo.ContentUri.Replace("_b.jpg", "_m.jpg");
}
result.Add(photo);
}
UpdatePhotos(result, tiles, keepExistent);
}
else
{
Image img = Image.FromStream(e.Result);
Tile tile = _targetItem.Tile;
if (!_targetItem.IsBuddyIcon)
{
tile.Image = img;
}
else
{
tile.Image1 = img;
}
}
}
catch (Exception exception)
{
ex = exception;
}
}
if (ex != null && _targetItem.Tile == null && !_targetItem.IsBuddyIcon)
{
_targetItem = null;
_lastError = ex.Message;
ShowErrorTile();
}
else
{
_targetItem = null;
_lastError = null;
if (_outOfTurnItem != null)
{
_targetItem = _outOfTurnItem;
_outOfTurnItem = null;
}
else if (_downloadQueue.Count > 0)
{
_targetItem = _downloadQueue.Dequeue();
}
if (_targetItem != null)
{
_client.OpenReadAsync(new Uri(_targetItem.Uri));
}
}
waitLabel.Visible = false;
}
/// <summary>Initializes a new instance of the <see cref="FortifyConverter"/> class.</summary>
public FortifyConverter()
{
_nameTable = new NameTable();
_strings = new FortifyStrings(_nameTable);
}
public override SubscribeResponse Subscribe([System.Xml.Serialization.XmlElementAttribute("Subscribe", Namespace = "http://docs.oasis-open.org/wsn/b-2")] Subscribe Subscribe1)
{
ConfStorageLoad();
EventServerLoad();
SubscribeResponse res = new SubscribeResponse();
DateTime terminationTime;
try
{
TimeSpan timeSpan = System.Xml.XmlConvert.ToTimeSpan(Subscribe1.InitialTerminationTime);
terminationTime = DateTime.Now.Add(timeSpan);
}
catch (Exception)
{
try
{
terminationTime = System.Xml.XmlConvert.ToDateTime(Subscribe1.InitialTerminationTime, XmlDateTimeSerializationMode.Utc);
}
catch (Exception)
{
throw FaultLib.GetSoapException(FaultType.General, "Wrong Initial Termination Time.");
}
}
string rawRequest = RequestListener.Take();
XmlElement filterElement = Utils.GetFilterElements(rawRequest);
EventServer.AddSubscribtion(Subscribe1.ConsumerReference.Address.Value, Subscribe1.Filter, filterElement, terminationTime, false);
res.CurrentTimeSpecified = true;
res.CurrentTime = DateTime.Now;
res.TerminationTimeSpecified = true;
res.TerminationTime = terminationTime;
res.SubscriptionReference = new EndpointReferenceType();
res.SubscriptionReference.Address = new AttributedURIType();
string hostAndPort = HttpContext.Current.Request.Url.Authority;
res.SubscriptionReference.Address.Value = "http://" + hostAndPort + "/ServiceEvents10/NotificationProducer.asmx";
res.SubscriptionReference.ReferenceParameters = new ReferenceParametersType();
res.SubscriptionReference.ReferenceParameters.Any = new System.Xml.XmlElement[1];
NameTable nt = new NameTable();
XmlNamespaceManager nsmgr = new XmlNamespaceManager(nt);
nsmgr.AddNamespace("xs", "http://www.w3.org/2001/XMLSchema");
nsmgr.AddNamespace("dut", "http://dut");
nsmgr.AddNamespace("tdc", "http://www.onvif.org/ver10/doorcontrol/wsdl");
XmlDocument referenceParameters = new XmlDocument(nt);
res.SubscriptionReference.ReferenceParameters.Any[0] = referenceParameters.CreateElement("dut", "id", "http://dut");
EventServerSave();
ConfStorageSave();
throw new NotImplementedException();
}
public JsonXPathNavigator(JsonXPathNavigator source)
{
copyState(source._state);
_nameTable = source._nameTable;
}
public ActionResult dqSync()
{
using (var dm = new DatasetManager())
{
List <long> datasetIds = dm.GetDatasetLatestIds(); //get latest
EntityPermissionManager entityPermissionManager = new EntityPermissionManager();
DataStructureManager dsm = new DataStructureManager();
try
{
//datasetManager.SyncView(datasetIds, ViewCreationBehavior.Create | ViewCreationBehavior.Refresh);
// if the viewData has a model error, the redirect forgets about it.
string pathPerformers = @"C:\Data\DatasetQualities\Performers.csv";
StreamWriter writerPerformers = new StreamWriter(pathPerformers);
string pathPerformerDataset = @"C:\Data\DatasetQualities\PerformerDataset.csv";
StreamWriter writerPerformerDataset = new StreamWriter(pathPerformerDataset);
string pathComparison = @"C:\Data\DatasetQualities\Comparison.csv";
StreamWriter writerComparison = new StreamWriter(pathComparison);
string pathDatasets = @"C:\Data\DatasetQualities\datasetInfo.csv";
StreamWriter writerDatasets = new StreamWriter(pathDatasets);
string pathVariable = @"C:\Data\DatasetQualities\Variables.csv";
StreamWriter writerVariable = new StreamWriter(pathVariable);
string pathFiles = @"C:\Data\DatasetQualities\Files.csv";
StreamWriter writerFiles = new StreamWriter(pathFiles);
string variableHeader = "datasetId,VarLabel,varType,varDescription,varUse,varMissing";
writerVariable.WriteLine(variableHeader);
string performer;
List <string> performerDataset = new List <string>();
Dictionary <string, int> performerCount = new Dictionary <string, int>();
List <int> metadataRates = new List <int>();
int allValidMetadas = 0;
//int publicDatasets = 0; //could not get result
//int restrictedDatasets = 0; //could not get result
List <int> dsDescLength = new List <int>();
List <int> dstrDescLength = new List <int>();
List <int> dstrUsage = new List <int>();
List <int> datasetSizeTabular = new List <int>();
List <int> datasetRows = new List <int>();
List <int> datasetCols = new List <int>();
List <double> datasetSizeFiles = new List <double>(); //all files in all datasets
List <int> datasetFileNumber = new List <int>();
List <int> sizeTabular = new List <int>(); //collect size, column number, and row number for one dataset
int fileDatasets = 0;
int tabularDatasets = 0;
int fileNumber = 0;
List <double> datasetTotalSize = new List <double>(); //total file size of each dataset
List <double> sizeFile = new List <double>(); ///////////////////////////
foreach (long datasetId in datasetIds)
{
DatasetVersion datasetLatestVersion = dm.GetDatasetLatestVersion(datasetId); //get last dataset versions
DataStructure dataStr = dsm.AllTypesDataStructureRepo.Get(datasetLatestVersion.Dataset.DataStructure.Id); //get data structure
#region performers
List <string> pers = new List <string>();
var dsvs = dm.GetDatasetVersions(datasetId);
foreach (var d in dsvs)
{
performer = d.ModificationInfo.Performer;
if (performer != null && !pers.Contains(performer))
{
pers.Add(performer); //a list of performers
}
}
foreach (var p in pers)
{
writerPerformerDataset.WriteLine(p + "," + datasetId); //fill the file PerformerDataset with a list of 'performer,datasetId'
if (performerCount.ContainsKey(p))
{
performerCount[p] += 1;
}
else
{
performerCount.Add(p, 1);
}
}
#endregion
#region allValidmetadatas
long metadataStructureId = dm.DatasetRepo.Get(datasetId).MetadataStructure.Id;
int validMetadata = 0;
if (datasetLatestVersion.StateInfo != null)
{
validMetadata = DatasetStateInfo.Valid.ToString().Equals(datasetLatestVersion.StateInfo.State) ? 1 : 0; //1:valid; 0:invalid.
}
else
{
validMetadata = 0;
}
if (validMetadata == 1) //count how many datasets have valid metadata
{
allValidMetadas += 1;
}
#endregion
#region metadataRates
XmlDocument metadata = datasetLatestVersion.Metadata;
string xmlFrag = metadata.OuterXml;
List <int> metaInfo = new List <int>();
NameTable nt = new NameTable();
XmlNamespaceManager nsmgr = new XmlNamespaceManager(nt);
// Create the XmlParserContext.
XmlParserContext context = new XmlParserContext(null, nsmgr, null, XmlSpace.None);
// Create the reader.
XmlTextReader reader = new XmlTextReader(xmlFrag, XmlNodeType.Element, context);
int countMetaAttr = 0;
int countMetaComplition = 0;
// Parse the XML and display each node.
while (reader.Read())
{
//XmlTextReader myReader = reader;
if (reader.NodeType == XmlNodeType.Element)
{
if (reader.HasAttributes && reader.GetAttribute("type") == "MetadataAttribute")
{
countMetaAttr += 1;
reader.Read();
if (reader.NodeType == XmlNodeType.Text)
{
string text = reader.Value;
countMetaComplition += 1;
}
}
}
}
// Close the reader.
reader.Close();
int rate = (countMetaComplition * 100) / countMetaAttr; //percentage of all metadata fields contains information
metadataRates.Add(rate);
#endregion
////find how many public dataset exist
//int publicRights = entityPermissionManager.GetRights(null, 1, datasetId); //1:public; 0:restricted
//if (publicRights == 1) { publicDatasets += 1; }
//if (publicRights == 0) { restrictedDatasets += 1; }
///issue here is that when a dataset has an empty dataset description field, the datasetLatestVersion.Description has the "not available" as value.
int datasetLatestVersionDescriptionLength = 0;
if (datasetLatestVersion.Description == "not available")
{
dsDescLength.Add(0);
}
else
{
dsDescLength.Add(datasetLatestVersion.Description.Length); //get dataset description length
datasetLatestVersionDescriptionLength = datasetLatestVersion.Description.Length;
}
dstrDescLength.Add(datasetLatestVersion.Dataset.DataStructure.Description.Length); //get data structure description length
dstrUsage.Add(dataStr.Datasets.Count() - 1); //data structure is used in how many other datasets (doesn't contain the current one)
string type = "file";
if (dataStr.Self.GetType() == typeof(StructuredDataStructure))
{
type = "tabular";
} //get dataset type
int colNum = 0;
int rowNum = 0;
#region tabular dataset
if (type == "tabular")
{
tabularDatasets += 1;
try
{
DataTable table = dm.GetLatestDatasetVersionTuples(datasetId, true);
DataRowCollection rowss = table.Rows;
DataColumnCollection columns = table.Columns;
StructuredDataStructure sds = dsm.StructuredDataStructureRepo.Get(datasetLatestVersion.Dataset.DataStructure.Id); //get data structure
var variables = sds.Variables; //get variables
//sizeTabular[1] = variables.Count; //columns.Count - 4;
//if (sizeTabular[1] < 0) //if data structure has not been designed.
//{
// sizeTabular[1] = 0;
//}
//sizeTabular[2] = rowss.Count;
//sizeTabular[0] = sizeTabular[1] * sizeTabular[2];
colNum = variables.Count;
rowNum = rowss.Count;
#region variables
int columnNumber = -1; //First four columns are added from system.
if (variables.Count() > 0)
{
foreach (var variable in variables)
{
columnNumber += 1;
//string missingValue = variable.MissingValue; //MISSING VALUE
List <string> missingValues = new List <string>(); //creat a list contains missing values
DataTable missTable = new DataTable();
foreach (var missValue in variable.MissingValues) //if data is equal missing value
{
missingValues.Add(missValue.Placeholder);
}
var varUse = variable.DataAttribute.UsagesAsVariable.Count() - 1;
string varType = variable.DataAttribute.DataType.SystemType;
int varMissing = 100; //suppose 100% is completed
try
{
if (rowss.Count > 0)
{
int missing = rowss.Count;
foreach (DataRow row in rowss)
{
var value = row.ItemArray[columnNumber]; //.ToString();
if (value == null || missingValues.Contains(value.ToString())) //check if cell is emty or contains a missing value
{
missing -= 1;
}
}
varMissing = 100 * missing / rowss.Count; //% of existing values
}
else
{
varMissing = 0;
}
}
catch
{
varMissing = 0;
}
string variableLine = datasetId + "," //0: dataset Id
+ variable.Label + "," //1: variable name
+ varType + "," //2: data type
+ variable.Description.Count() + "," //3: variable description length
+ varUse + "," //4: variable usage
+ varMissing; //5: % completed
writerVariable.WriteLine(variableLine);
}
}
#endregion
}
catch
{
colNum = 0;
rowNum = 0;
//sizeTabular.Add(0);
//sizeTabular.Add(0);
//sizeTabular.Add(0);
}
datasetSizeTabular.Add(colNum * rowNum); //sizeTabular[0]);
datasetCols.Add(colNum); // sizeTabular[1]); //column number
datasetRows.Add(rowNum); // sizeTabular[2]); //row number
}
#endregion
#region file dataset
else if (type == "file")
{
fileDatasets += 1;
List <ContentDescriptor> contentDescriptors = datasetLatestVersion.ContentDescriptors.ToList();
fileNumber = contentDescriptors.Count;
//datasetFileNumber.Add(fileNumber);
//sizeFile.Add(fileNumber);
int fileNum = 0;
double totalSize = 0;
string fileInDataset = "";
if (contentDescriptors.Count > 0)
{
foreach (ContentDescriptor cd in contentDescriptors)
{
if (cd.Name.ToLower().Equals("unstructureddata"))
{
fileNum += 1;
string uri = cd.URI;
String path = Server.UrlDecode(uri);
path = Path.Combine(AppConfiguration.DataPath, path);
try
{
Stream fileStream = System.IO.File.OpenRead(path);
FileStream fs = fileStream as FileStream;
if (fs != null)
{
FileInformation fileInfo = new FileInformation(fs.Name.Split('\\').LastOrDefault(), MimeMapping.GetMimeMapping(fs.Name), (uint)fs.Length, uri);
totalSize += fileInfo.Size;
fileInDataset = datasetId + "," + fileInfo.Name.Split('.')[0] + "," + fileInfo.Name.Split('.')[1].ToLower() + "," + fileInfo.Size; //datasetId,file name,file extension,file size
writerFiles.WriteLine(fileInDataset);
}
}
catch
{
datasetSizeFiles.Add(0); //file size
}
}
}
datasetFileNumber.Add(fileNum);
datasetTotalSize.Add(totalSize);
}
else
{
datasetFileNumber.Add(0);
datasetTotalSize.Add(0);
}
}
#endregion
//[0]datasetId, [1]dataType, [2]IsValid, [3]metadataComplitionRate,
//[4]datasetDescLength, [5]dataStrDescrLength, [6]DataStrUsage,
//[7]columns, [8]rows, [9]file numbers, [10]file sizes, [11]performers
string datasetInfo = datasetId + ";" + type + ";" + validMetadata + ";" + rate + ";"
+ datasetLatestVersionDescriptionLength + ";"
+ datasetLatestVersion.Dataset.DataStructure.Description.Length + ";"
+ (dataStr.Datasets.Count() - 1);
if (type == "tabular")
{
datasetInfo = datasetInfo + ";" + datasetCols.Last() //column number
+ ";" + datasetRows.Last() //row number
+ ";0;0"; //file number and size
}
if (type == "file")
{
datasetInfo = datasetInfo + ";0;0" //column and row number
+ ";" + datasetFileNumber.Last() //sizeFile[0] //file number
+ ";" + datasetTotalSize.Last(); //sizeFile[1]; //total size
}
string prfmrs = "";
foreach (string p in pers)
{
prfmrs = prfmrs + FindPerformerNameFromUsername(p) + ",";
}
prfmrs.Remove(prfmrs.Length - 1, 1);
datasetInfo = datasetInfo + ";" + prfmrs;
writerDatasets.WriteLine(datasetInfo);
}
writerDatasets.Close();
#region performersInFile
//write a list of 'performer,activity' in Performers.csv
foreach (string p in performerCount.Keys)
{
string l = p + "," + performerCount[p];
writerPerformers.WriteLine(l);
}
// performer activities
int performerMin = performerCount.Values.Min();
int performerMax = performerCount.Values.Max();
List <int> performerActivities = new List <int>();
foreach (int s in performerCount.Values)
{
performerActivities.Add(s);
}
double performerMedian = medianCalc(performerActivities);
string performerCompare = "performersActivity," + performerMin + "," + performerMedian + "," + performerMax;
writerComparison.WriteLine(performerCompare); //performersActivity
writerPerformers.Close();
writerPerformerDataset.Close();
#endregion
#region datasetInfo in file
#endregion //datasetInfo in file
#region compare in file
string m = "metadataRates," + metadataRates.Min() + "," + medianCalc(metadataRates) + "," + metadataRates.Max();
writerComparison.WriteLine(m);
string allValids = "allValidMetadas," + allValidMetadas;
writerComparison.WriteLine(allValids);
//string pd = "publicDatasets," + publicDatasets;
//string rd = "restrictedDatasets," + restrictedDatasets;
//writerComparison.WriteLine(pd);
//writerComparison.WriteLine(rd);
string datasetDescriptionLength = "datasetDescriptionLength," + dsDescLength.Min() + "," + medianCalc(dsDescLength) + "," + dsDescLength.Max();
string dataStrDescriptionLength = "dataStrDescriptionLength," + dstrDescLength.Min() + "," + medianCalc(dstrDescLength) + "," + dstrDescLength.Max();
string dataStrUsage = "dataStrUsage," + dstrUsage.Min() + "," + medianCalc(dstrUsage) + "," + dstrUsage.Max();
writerComparison.WriteLine(datasetDescriptionLength);
writerComparison.WriteLine(dataStrDescriptionLength);
writerComparison.WriteLine(dataStrUsage);
string typeDataset = "type," + (tabularDatasets + fileDatasets) + "," + tabularDatasets + "," + fileDatasets;
writerComparison.WriteLine(typeDataset);
string cols = "datasetColNumber," + datasetCols.Min() + "," + medianCalc(datasetCols) + "," + datasetCols.Max();
string rows = "datasetRowNumber," + datasetRows.Min() + "," + medianCalc(datasetRows) + "," + datasetRows.Max();
string fileNums = "";
string fileSizes = "";
string totalFileSize = "";
//if (datasetFileNumber.Count > 0)
//{
fileNums = "datasetFileNumber," + datasetFileNumber.Min() + "," + medianCalc(datasetFileNumber) + "," + datasetFileNumber.Max();
//fileSizes = "datasetSizeFiles," + datasetSizeFiles.Min() + "," + medianCalc(datasetSizeFiles) + "," + datasetSizeFiles.Max();
totalFileSize = "datasetTotalSizeFiles," + datasetTotalSize.Min() + "," + medianCalc(datasetTotalSize) + "," + datasetTotalSize.Max();
//}
//else
//{
// fileNums = "datasetFileNumber," + 0 + "," + 0 + "," + 0;
// //fileSizes = "datasetSizeFiles," + 0 + "," + 0 + "," + 0;
// totalFileSize = "datasetTotalSizeFiles," + 0 + "," + 0 + "," + 0;
//}
writerComparison.WriteLine(cols);
writerComparison.WriteLine(rows);
writerComparison.WriteLine(fileNums);
writerComparison.WriteLine(fileSizes);
writerComparison.WriteLine(totalFileSize);
#endregion
writerComparison.Close();
//writerDatasets.Close();
writerVariable.Close();
writerFiles.Close();
return(View());
//return RedirectToAction("Index", new { area = "dqm" });
}
catch (Exception ex)
{
ViewData.ModelState.AddModelError("", $@"'{ex.Message}'");
return(RedirectToAction("dqError", new { area = "dqm" }));
}
}
}
public static void YankReferrals (string path)
{
string ourNamespace = "urn:newtelligence-com:dasblog:runtime:data";
foreach (string file in Directory.GetFiles(path,"*.dayfeedback.xml"))
{
NameTable nt = new NameTable();
object permaLink = nt.Add("PermaLink");
XmlNamespaceManager ns = new XmlNamespaceManager(nt);
ns.AddNamespace("def", ourNamespace);
XmlDocument x = new XmlDocument(nt);
try
{
x.Load(file);
}
catch (XmlException ex)
{
WriteLine(String.Format("ERROR: Malformed Xml in file: {0}",file));
WriteLine(ex.ToString());
Console.WriteLine("Press ENTER to continue...");
Console.ReadLine();
}
XmlNodeList nodes = x.SelectNodes("/def:DayExtra/def:Trackings/def:Tracking[def:TrackingType = \"Referral\"]", ns);
for (int i = 0; i < nodes.Count; i++)
{
XmlNode node = nodes[i];
node.ParentNode.RemoveChild(node);
}
if (nodes.Count > 0)
{
x.Save(file);
}
WriteLine(String.Format("Removed {0} referrals in {1}",nodes.Count,file));
}
}
/// <summary>
/// xmlファイルをマージする
/// </summary>
/// <param name="patchedXml">パッチされるxml</param>
/// <param name="patchXml">パッチ用xml</param>
public void MergeXML(XDocument patchedXml, XDocument patchXml)
{
if (patchXml.Root.Name.LocalName == "diff")
{
var nsTbl = new NameTable();
var nsMng = new XmlNamespaceManager(nsTbl);
foreach (var attr in patchXml.Root.Attributes())
{
// 名前空間の場合
if (attr.IsNamespaceDeclaration)
{
if (attr.Name.LocalName.StartsWith("xmlns"))
{
nsMng.AddNamespace(attr.Name.NamespaceName, attr.Value);
}
else
{
nsMng.AddNamespace(attr.Name.LocalName, attr.Value);
}
}
}
foreach (var elm in patchXml.Root.Elements())
{
var sel = patchedXml.XPathEvaluate(elm.Attribute("sel").Value, nsMng);
if (!(sel is IEnumerable enumerable))
{
continue;
}
var targetNode = enumerable.OfType <XObject>().FirstOrDefault();
if (targetNode == null)
{
continue;
}
switch (elm.Name.LocalName)
{
case "add":
AddNode(elm, targetNode);
break;
case "replace":
Replace(elm, targetNode);
break;
case "remove":
Remove(patchedXml, targetNode);
break;
default:
break;
}
}
}
else
{
patchedXml.Root.Add(patchXml.Root.Elements());
}
}
public XmlParserContext GetParserContext()
{
NameTable nt = new NameTable();
XmlParserContext pc = new XmlParserContext(nt, new XmlNamespaceManager(nt), null, XmlSpace.Default);
return pc;
}
/// <summary>
/// Test various xpath expressionss
/// </summary>
static void TestXpaths()
{
Console.WriteLine("== Test various xpath expressionss");
// From: http://www.csharp-examples.net/xpath-top-xml-nodes/
// get top 2 nodes <book> nodes use XPath expression
// http://www.java2s.com/Code/CSharp/XML/FindElementswithanXPathSearch.htm
String xmlStr = "<Names>" +
"<Name>James</Name>" +
"<Name>John</Name>" +
"<Name>Robert</Name>" +
"<Name>Michael</Name>" +
"<Name>William</Name>" +
"<Name>David</Name>" +
"<Name>Richard</Name>" +
"</Names>";
XmlDocument xml = new XmlDocument();
xml.LoadXml(xmlStr);
XmlNodeList xnList = xml.SelectNodes("/Names/Name[position() <= 3]");
foreach (XmlNode xn in xnList)
{
Console.WriteLine(xn.InnerText);
}
Console.WriteLine("== Test Write XML To String");
// From: http://www.fincher.org/tips/Languages/csharp.shtml
//read an xml file and then write to a string
//(no error checking)
// http://www.java2s.com/Code/CSharp/XML/XPathQueryDemo.htm
// XmlDocument xmlDocument = new XmlDocument();
// xmlDocument.Load(args[0]);
StringWriter stringWriter = new StringWriter();
XmlTextWriter xmlTextWriter = new XmlTextWriter(stringWriter);
xmlTextWriter.Formatting = Formatting.Indented;
xml.WriteTo(xmlTextWriter); // xmlDocument
xmlTextWriter.Flush();
Console.WriteLine(stringWriter.ToString());
Console.WriteLine("== Test more xpath expressionss");
// From: http://mydotnet.wordpress.com/2008/05/29/worlds-smallest-xml-xpath-tutorial/
XmlDocument xmlDocument = new XmlDocument();
xmlDocument.Load(@"d:\books2.xml");
XmlElement root = xmlDocument.DocumentElement;
// define name space manager
XmlNameTable xmlNameTable = new NameTable();
XmlNamespaceManager manager = new XmlNamespaceManager(xmlNameTable);
manager.AddNamespace("bk", "http://www.contoso.com/books");
// select the first Node under the root node ("bookstore") which matches the name "book"
XmlNode xnRecord = root.SelectSingleNode("bk:book", manager);
Console.WriteLine(xnRecord.InnerText);
// Searching XMLNode by Attribute value: book genre="novel"
xnRecord = root.SelectSingleNode("bk:book[@genre='novel']", manager);
Console.WriteLine(xnRecord.InnerText);
// Searching XMLNode by ChildNode’s inner text: <price>9.99</price>
xnRecord = root.SelectSingleNode("bk:book[bk:price='9.99']", manager);
Console.WriteLine(xnRecord.InnerXml);
// Searching XMLNodeList
XmlNodeList xnlRecords = root.SelectNodes("bk:book", manager);
// Sorting
Console.WriteLine("== Test Xml Sorting");
XPathNavigator navigator = xml.CreateNavigator();
//XPathExpression selectExpression = navigator.Compile(navigateNode);
//selectExpression.SetContext(manager);
//selectExpression.AddSort("@EmpId", XmlSortOrder.Ascending, XmlCaseOrder.None, "", XmlDataType.Number);
XPathNodeIterator nodeIterator = navigator.Select("/Names/Name");
while (nodeIterator.MoveNext())
{
XmlElement xnm = (XmlElement)((IHasXmlNode)nodeIterator.Current).GetNode();
//Do other required operations here ??
Console.WriteLine(xnm.InnerText);
}
}
private void Ilogin(AuthorizationContext filterContext)
{
try
{
var path = filterContext.HttpContext.Request.CurrentExecutionFilePath.ToLower();
string[] urlItems = path.ToLower().Split('/');
string pageName = urlItems[urlItems.Length - 1];
string casTicket = filterContext.HttpContext.Request.QueryString["ticket"];
Code.LogHelper.Info("casTicket:" + casTicket);
//返回地址
string serviceUrl = filterContext.HttpContext.Request.Url.GetLeftPart(UriPartial.Path).ToLower().Split(new string[] { "/islogin", "/login" }, StringSplitOptions.None)[0];
if (!string.IsNullOrEmpty(ServerUrl))
{
serviceUrl = ServerUrl + serviceUrl.Replace("http://" + filterContext.HttpContext.Request.Url.Authority, "");
if (Code.Common.IsMobile)
{
if (casTicket == null || casTicket.Length == 0)
{
serviceUrl += "/sys/sysindex/login";//接入微信入口单点跳转地址不对
}
}
}
if (casTicket == null || casTicket.Length == 0)
{
string redir = casLogin + "?service=" + serviceUrl;
if (Code.Common.IsMobile)
{
Code.LogHelper.Info("IsMobile!");
redir = serviceUrl;
}
filterContext.HttpContext.Response.Redirect(redir);
return;
}
else
{
string validateurl = casValidate + "?ticket=" + casTicket + "&" + "service=" + serviceUrl;
WebClient client = new WebClient();
StreamReader Reader = new StreamReader(client.OpenRead(validateurl));
string resp = Reader.ReadToEnd();
StackTrace st = new StackTrace(new StackFrame(true));
NameTable nt = new NameTable();
XmlNamespaceManager nsmgr = new XmlNamespaceManager(nt);
XmlParserContext context = new XmlParserContext(null, nsmgr, null, XmlSpace.None);
XmlTextReader reader = new XmlTextReader(resp, XmlNodeType.Element, context);
string netid = null;
while (reader.Read())
{
if (reader.IsStartElement())
{
string tag = reader.LocalName;
if (tag == "user" && !string.IsNullOrEmpty(casTicket))
{
netid = reader.ReadString();
break;
}
}
}
reader.Close();
if (netid == null)
{
if (XkSystem.Code.Common.UserId != 0)
{
return;
}
else
{
string redir = casLogin + "?service=" + serviceUrl;
filterContext.HttpContext.Response.Redirect(redir);
return;
}
}
else
{
var rootPath = filterContext.HttpContext.Request.ApplicationPath;
if (!rootPath.EndsWith("/"))
{
rootPath = rootPath + "/";
}
if (XkSystem.Code.Common.UserId == 0)
{
//XkSystem.Code.Common.UserId = UserId(netid);
UserId(netid);
}
HttpContext.Current.Response.Cookies[Code.Common.AppName + "casTicket"].Value = casTicket;
filterContext.HttpContext.Response.Redirect(ServerUrl + "/" + Code.Common.FolderName + "/Sys/SysIndex/IsLogin?code=" + netid);
}
}
}
catch (Exception)
{
throw;
}
}
// Test adding items to a namespace manager.
public void TestXmlNamespaceManagerAdd()
{
NameTable table = new NameTable();
XmlNamespaceManager ns = new XmlNamespaceManager(table);
// Test exception behaviour.
try
{
ns.AddNamespace(null, "uri");
Fail("Add (1)");
}
catch(ArgumentNullException)
{
// Success
}
try
{
ns.AddNamespace("prefix", null);
Fail("Add (2)");
}
catch(ArgumentNullException)
{
// Success
}
try
{
ns.AddNamespace("xml", "uri");
Fail("Add (3)");
}
catch(ArgumentException)
{
// Success
}
try
{
ns.AddNamespace("xmlns", "uri");
Fail("Add (4)");
}
catch(ArgumentException)
{
// Success
}
try
{
// Work around intern'ed string handling in the engine.
ns.AddNamespace(String.Concat("xml", "ns"), "uri");
Fail("Add (5)");
}
catch(ArgumentException)
{
// Success
}
// Try changing the default namespace.
ns.AddNamespace("", "defuri");
AssertEquals("Add (6)", "defuri", ns.LookupNamespace(""));
AssertEquals("Add (7)", "defuri", ns.DefaultNamespace);
AssertEquals("Add (8)", "", ns.LookupPrefix("defuri"));
// Try changing some other namespace.
ns.AddNamespace("foo", "uri");
AssertEquals("Add (9)", "uri", ns.LookupNamespace("foo"));
AssertEquals("Add (10)", "foo", ns.LookupPrefix("uri"));
// Make sure that the standard are still set to their
// correct values after the modifications above.
AssertEquals("Add (11)",
"http://www.w3.org/XML/1998/namespace",
ns.LookupNamespace("xml"));
AssertEquals("Add (12)",
"http://www.w3.org/2000/xmlns/",
ns.LookupNamespace("xmlns"));
AssertEquals("Add (13)", "defuri", ns.LookupNamespace(""));
}
// Test enumerating over a namespace manager.
public void TestXmlNamespaceManagerEnumerate()
{
NameTable table = new NameTable();
XmlNamespaceManager ns = new XmlNamespaceManager(table);
ns.AddNamespace("foo", "uri1");
CheckEnum(ns, "uri1");
ns.PushScope();
ns.AddNamespace("foo", "uri2");
CheckEnum(ns, "uri2");
ns.AddNamespace("foo", "uri3");
CheckEnum(ns, "uri3");
ns.PopScope();
ns.AddNamespace("", "");
CheckEnum(ns, "uri1");
}
public static TracebackInfo ConstructTracebackInfo(UInt32 tracebackID, ArraySegment<UInt32> rawFrames, IDictionary<UInt32, TracebackFrame> symbols)
{
var tracebackFunctions = new NameTable(StringComparer.Ordinal);
var tracebackModules = new NameTable(StringComparer.Ordinal);
var tracebackFrames = ImmutableArrayPool<TracebackFrame>.Allocate(rawFrames.Count);
for (int i = 0, o = tracebackFrames.Offset, c = tracebackFrames.Count; i < c; i++) {
var rawFrame = rawFrames.Array[rawFrames.Offset + i];
var symbol = symbols[rawFrame];
if ((symbol.Offset == 0) && (!symbol.Offset2.HasValue))
tracebackFrames.Array[i + o] = new TracebackFrame(rawFrame);
else
tracebackFrames.Array[i + o] = symbol;
if (symbol.Function != null)
tracebackFunctions.Add(symbol.Function);
if (symbol.Module != null)
tracebackModules.Add(symbol.Module);
}
return new TracebackInfo {
Frames = tracebackFrames,
Functions = tracebackFunctions,
Modules = tracebackModules,
TraceId = tracebackID
};
}
// Check the "PopScope" method.
public void TestXmlNamespaceManagerPopScope()
{
NameTable table = new NameTable();
XmlNamespaceManager ns = new XmlNamespaceManager(table);
Assert("PopScope (1)", !ns.PopScope());
ns.PushScope();
Assert("PopScope (2)", ns.PopScope());
}
public IEnumerator<object> ResolveTracebackSymbols(
IEnumerable<HeapSnapshot.Traceback> unresolvedTracebacks,
Dictionary<UInt32, TracebackInfo> resolvedTracebacks,
NameTable functionNames
)
{
Dictionary<UInt32, TracebackFrame> frameSymbols;
{
var rawFrames = new HashSet<UInt32>();
yield return Future.RunInThread(() => {
foreach (var traceback in unresolvedTracebacks)
foreach (var rawFrame in traceback)
rawFrames.Add(rawFrame);
});
var fSymbols = Database.SymbolCache.Select(rawFrames);
using (fSymbols)
yield return fSymbols;
var fSymbolDict = Future.RunInThread(() =>
SequenceUtils.ToDictionary(rawFrames, fSymbols.Result)
);
yield return fSymbolDict;
frameSymbols = fSymbolDict.Result;
}
yield return Future.RunInThread(() => {
if (functionNames != null)
foreach (var tf in frameSymbols.Values) {
if (tf.Function != null)
functionNames.Add(tf.Function);
}
foreach (var traceback in unresolvedTracebacks) {
resolvedTracebacks[traceback.ID] = ConstructTracebackInfo(
traceback.ID, traceback.Frames, frameSymbols
);
}
});
}
public SimpleXsltContext(NameTable nameTable) : base(nameTable)
{
}
/// <summary>
/// Initializes a new instance of the <see cref="CustomQueryContext"/> class.
/// </summary>
/// <param name="table">A NameTable instance</param>
public CustomQueryContext(NameTable table)
: base(table)
{
}
public NameTableDataSource(NameTable nameTable)
: base(nameTable.items.Count)
{
dataGetters = new PackageTableDataGetter[] {
new PackageTableDataGetter { column = "#",
sort = (i => { return nameTable[i].index; }),
data = (i => { return nameTable[i].index.ToString(); }),
},
new PackageTableDataGetter { column = "offset",
sort = (i => { return nameTable[i].offset; }),
data = (i => { return String.Format("{0:X8}", nameTable[i].offset); }),
},
new PackageTableDataGetter { column = "name",
sort = (i => { return nameTable[i].name; }),
data = (i => { return nameTable[i].name.ToString(); }),
},
new PackageTableDataGetter { column = "flags",
sort = (i => { return nameTable[i].flags; }),
data = (i => { return nameTable[i].flags.ToString(); }),
},
};
}
static ThemeColorSet getColorSetFromTheme(Stream thmxFile)
{
XDocument themeDoc = null;
StreamResourceInfo thmxSRI = new StreamResourceInfo(thmxFile, null);
StreamResourceInfo sri = Application.GetResourceStream(thmxSRI, new Uri(ThmxThemeUri, UriKind.Relative));
//Add the namespace manager
NameTable nameTable = new NameTable();
XmlNamespaceManager manager = new XmlNamespaceManager(nameTable);
manager.AddNamespace("a", ThmxNamespace);
//Create XDocument from thmx stream
themeDoc = XDocument.Load(sri.Stream);
XDocument xDocTheme = XDocument.Parse(themeDoc.ToString());
//Get RGB Values for the 12 theme colors
string dk1 = getRGBFromTheme(xDocTheme, thmx_dk1, true); //Text
string dk2 = getRGBFromTheme(xDocTheme, thmx_dk2); //Main Dark Color
string lt1 = getRGBFromTheme(xDocTheme, thmx_lt1, true); //Window Background
string lt2 = getRGBFromTheme(xDocTheme, thmx_lt2); //Main Light Color
string a1 = getRGBFromTheme(xDocTheme, thmx_a1); //Accent1
string a2 = getRGBFromTheme(xDocTheme, thmx_a2); //Accent2
string a3 = getRGBFromTheme(xDocTheme, thmx_a3); //Accent3
string a4 = getRGBFromTheme(xDocTheme, thmx_a4); //Accent4
string a5 = getRGBFromTheme(xDocTheme, thmx_a5); //Accent5
string a6 = getRGBFromTheme(xDocTheme, thmx_a6); //Accent6
string hlink = getRGBFromTheme(xDocTheme, thmx_hlink); //Hyperlink
string flink = getRGBFromTheme(xDocTheme, thmx_flink); //Followed Link
//Get the two fonts
string majFont = getFontFamilyFromTheme(xDocTheme, thmx_majfont); //Heading Font
string minFont = getFontFamilyFromTheme(xDocTheme, thmx_minfont); //Body Font
ThemeColorSet theme = new ThemeColorSet()
{
TextBackgroundDark1 = fromHex(dk1),
TextBackgroundDark2 = fromHex(dk2),
TextBackgroundLight1 = fromHex(lt1),
TextBackgroundLight2 = fromHex(lt2),
Accent1 = fromHex(a1),
Accent2 = fromHex(a2),
Accent3 = fromHex(a3),
Accent4 = fromHex(a4),
Accent5 = fromHex(a5),
Accent6 = fromHex(a6),
Hyperlink = fromHex(hlink),
FollowedHyperlink = fromHex(flink),
};
//Color bkStart = fromHex(dk2);
//Color bkEnd = fromHex(lt2);
//Color text = fromHex(dk1);
//Color winBkgd = fromHex(lt1);
//Color separator = fromHex(a1);
//Color selected = fromHex(flink);
//Color mouseOver = fromHex(hlink);
//ApplicationColorSet appSet = new ApplicationColorSet()
//{
// ChildWindowColorSet = new ChildWindowColorSet()
// {
// BackgroundStartGradientColor = bkStart,
// //BackgroundEndGradientColor = bkEnd,
// TitleBarColor = winBkgd,
// TitleBarForegroundColor = text,
// },
// SidePanelControlColorSet = new SidePanelControlColorSet()
// {
// BackgroundStartGradientColor = bkStart,
// //BackgroundEndGradientColor = bkEnd,
// MouseOverFillColor = mouseOver,
// SelectedStateFillColor = selected,
// SeparatorLineColor = separator,
// },
//};
return(theme);
}
public IEnumerator<object> DiffSnapshots(HeapSnapshotInfo first, HeapSnapshotInfo last)
{
var moduleNames = new NameTable(StringComparer.Ordinal);
var heapIds = new HashSet<UInt32>();
var functionNames = new NameTable();
var deltas = new List<DeltaInfo>();
var tracebacks = new Dictionary<UInt32, TracebackInfo>();
{
var fModulesFirst = Database.SnapshotModules.Get(first.Index);
var fModulesLast = Database.SnapshotModules.Get(last.Index);
var fHeapsFirst = Database.SnapshotHeaps.Get(first.Index);
var fHeapsLast = Database.SnapshotHeaps.Get(last.Index);
yield return fModulesFirst;
foreach (var moduleName in fModulesFirst.Result)
moduleNames.Add(Path.GetFileNameWithoutExtension(moduleName));
yield return fHeapsFirst;
heapIds.UnionWith(from heap in fHeapsFirst.Result select heap.HeapID);
yield return fModulesLast;
foreach (var moduleName in fModulesLast.Result)
moduleNames.Add(Path.GetFileNameWithoutExtension(moduleName));
yield return fHeapsLast;
heapIds.UnionWith(from heap in fHeapsLast.Result select heap.HeapID);
}
var allocationIds = new HashSet<UInt32>();
{
var fAllocations = Database.HeapAllocations.Select(heapIds);
using (fAllocations)
yield return fAllocations;
yield return Future.RunInThread(() => {
foreach (var ids in fAllocations.Result)
allocationIds.UnionWith(ids);
});
}
{
var tracebackIds = new HashSet<UInt32>();
var oldCounts = new Dictionary<UInt32, int>();
var oldBytes = new Dictionary<UInt32, int>();
var newCounts = new Dictionary<UInt32, int>();
var newBytes = new Dictionary<UInt32, int>();
var deallocs = new Dictionary<UInt32, DeltaInfo>();
var allocs = new Dictionary<UInt32, DeltaInfo>();
var fAllocationRanges = Database.Allocations.Select(allocationIds);
using (fAllocationRanges)
yield return fAllocationRanges;
yield return Future.RunInThread(() => {
DeltaInfo delta;
foreach (var item in fAllocationRanges.Result) {
var ranges = item.Ranges.Array;
for (int i = 0, c = item.Ranges.Count, o = item.Ranges.Offset; i < c; i++) {
var range = ranges[i + o];
bool aliveAtStart = (range.First <= first.Index) && (range.Last > first.Index);
bool aliveAtEnd = (range.First <= last.Index) && (range.Last > last.Index);
bool allocatedInWindow = (range.First >= first.Index) && (range.First <= last.Index);
bool deallocatedInWindow = (range.Last >= first.Index) && (range.Last <= last.Index);
if (!aliveAtStart && !aliveAtEnd && !allocatedInWindow && !deallocatedInWindow)
continue;
if (aliveAtStart) {
int value;
if (!oldCounts.TryGetValue(range.TracebackID, out value))
value = 0;
oldCounts[range.TracebackID] = value + 1;
if (!oldBytes.TryGetValue(range.TracebackID, out value))
value = 0;
oldBytes[range.TracebackID] = (int)(value + range.Size);
}
if (aliveAtEnd) {
int value;
if (!newCounts.TryGetValue(range.TracebackID, out value))
value = 0;
newCounts[range.TracebackID] = value + 1;
if (!newBytes.TryGetValue(range.TracebackID, out value))
value = 0;
newBytes[range.TracebackID] = (int)(value + range.Size);
}
if (allocatedInWindow) {
// allocation
if (allocs.TryGetValue(range.TracebackID, out delta)) {
delta.CountDelta += 1;
delta.BytesDelta += (int)(range.Size);
} else {
allocs.Add(range.TracebackID, new DeltaInfo {
BytesDelta = (int)(range.Size),
CountDelta = 1,
TracebackID = range.TracebackID,
Traceback = null
});
}
tracebackIds.Add(range.TracebackID);
}
if (deallocatedInWindow) {
// deallocation
if (deallocs.TryGetValue(range.TracebackID, out delta)) {
delta.CountDelta -= 1;
delta.BytesDelta -= (int)(range.Size);
} else {
deallocs.Add(range.TracebackID, new DeltaInfo {
BytesDelta = -(int)(range.Size),
CountDelta = -1,
TracebackID = range.TracebackID,
Traceback = null
});
}
tracebackIds.Add(range.TracebackID);
}
}
}
foreach (var tracebackId in tracebackIds) {
DeltaInfo alloc = null, dealloc = null;
if (allocs.TryGetValue(tracebackId, out alloc) | deallocs.TryGetValue(tracebackId, out dealloc)) {
int currentOldBytes, currentOldCount;
int currentNewBytes, currentNewCount;
oldBytes.TryGetValue(tracebackId, out currentOldBytes);
oldCounts.TryGetValue(tracebackId, out currentOldCount);
newBytes.TryGetValue(tracebackId, out currentNewBytes);
newCounts.TryGetValue(tracebackId, out currentNewCount);
if (alloc != null) {
alloc.OldBytes = currentOldBytes;
alloc.OldCount = currentOldCount;
alloc.NewBytes = currentNewBytes;
alloc.NewCount = currentNewCount;
deltas.Add(alloc);
}
if (dealloc != null) {
dealloc.OldBytes = currentOldBytes;
dealloc.OldCount = currentOldCount;
dealloc.NewBytes = currentNewBytes;
dealloc.NewCount = currentNewCount;
deltas.Add(dealloc);
}
}
}
});
var fTracebacks = Database.FilteredTracebacks.CascadingSelect(
new [] { Database.Tracebacks },
tracebackIds
);
using (fTracebacks)
yield return fTracebacks;
yield return ResolveTracebackSymbols(
fTracebacks.Result, tracebacks, functionNames
);
yield return Future.RunInThread(() => {
foreach (var d in deltas)
d.Traceback = tracebacks[d.TracebackID];
});
}
yield return Future.RunInThread(() =>
deltas.Sort((lhs, rhs) => {
var lhsBytes = lhs.BytesDelta;
var rhsBytes = rhs.BytesDelta;
return rhsBytes.CompareTo(lhsBytes);
})
);
yield return Result.New(new HeapDiff(
null, moduleNames, functionNames, deltas, tracebacks
));
}
static XmlNameTable CreateNameTable()
{
XmlNameTable nameTable = new NameTable();
nameTable.Add(string.Empty);
nameTable.Add(XNamespace.xmlnsPrefixNamespace);
nameTable.Add(XNamespace.xmlPrefixNamespace);
return nameTable;
}
/// <summary>
/// Initializes the task and verifies parameters.
/// </summary>
/// <param name="TaskNode">Node that contains the XML fragment used to define this task instance.</param>
protected override void InitializeTask(XmlNode TaskNode)
{
XmlElement taskXml = (XmlElement) TaskNode.Clone();
// Expand all properties in the task and its child elements
if (taskXml.ChildNodes != null) {
ExpandPropertiesInNodes(taskXml.ChildNodes);
if (taskXml.Attributes != null) {
foreach (XmlAttribute attr in taskXml.Attributes) {
attr.Value = Properties.ExpandProperties(attr.Value, Location);
}
}
}
// Get the [SchemaValidator(type)] attribute
SchemaValidatorAttribute[] taskValidators =
(SchemaValidatorAttribute[])GetType().GetCustomAttributes(
typeof(SchemaValidatorAttribute), true);
if (taskValidators.Length > 0) {
SchemaValidatorAttribute taskValidator = taskValidators[0];
XmlSerializer taskSerializer = new XmlSerializer(taskValidator.ValidatorType);
// get embedded schema resource stream
Stream schemaStream = Assembly.GetExecutingAssembly().GetManifestResourceStream(
taskValidator.ValidatorType.Namespace);
// ensure schema resource was embedded
if (schemaStream == null) {
throw new BuildException(string.Format(CultureInfo.InvariantCulture,
"Schema resource '{0}' could not be found.",
taskValidator.ValidatorType.Namespace), Location);
}
// load schema resource
XmlTextReader tr = new XmlTextReader(
schemaStream, XmlNodeType.Element, null);
// Add the schema to a schema collection
XmlSchema schema = XmlSchema.Read(tr, null);
XmlSchemaCollection schemas = new XmlSchemaCollection();
schemas.Add(schema);
string xmlNamespace = (taskValidator.XmlNamespace != null ? taskValidator.XmlNamespace : GetType().FullName);
// Create a namespace manager with the schema's namespace
NameTable nt = new NameTable();
XmlNamespaceManager nsmgr = new XmlNamespaceManager(nt);
nsmgr.AddNamespace(string.Empty, xmlNamespace);
// Create a textreader containing just the Task's Node
XmlParserContext ctx = new XmlParserContext(
null, nsmgr, null, XmlSpace.None);
taskXml.SetAttribute("xmlns", xmlNamespace);
XmlTextReader textReader = new XmlTextReader(taskXml.OuterXml,
XmlNodeType.Element, ctx);
// Copy the node from the TextReader and indent it (for error
// reporting, since NAnt does not retain formatting during a load)
StringWriter stringWriter = new StringWriter();
XmlTextWriter textWriter = new XmlTextWriter(stringWriter);
textWriter.Formatting = Formatting.Indented;
textWriter.WriteNode(textReader, true);
//textWriter.Close();
XmlTextReader formattedTextReader = new XmlTextReader(
stringWriter.ToString(), XmlNodeType.Document, ctx);
// Validate the Task's XML against its schema
XmlValidatingReader validatingReader = new XmlValidatingReader(
formattedTextReader);
validatingReader.ValidationType = ValidationType.Schema;
validatingReader.Schemas.Add(schemas);
validatingReader.ValidationEventHandler +=
new ValidationEventHandler(Task_OnSchemaValidate);
while (validatingReader.Read()) {
// Read strictly for validation purposes
}
validatingReader.Close();
if (!_validated) {
// Log any validation errors that have ocurred
for (int i = 0; i < _validationExceptions.Count; i++) {
BuildException ve = (BuildException) _validationExceptions[i];
if (i == _validationExceptions.Count - 1) {
// If this is the last validation error, throw it
throw ve;
}
Log(Level.Info, ve.Message);
}
}
NameTable taskNameTable = new NameTable();
XmlNamespaceManager taskNSMgr = new XmlNamespaceManager(taskNameTable);
taskNSMgr.AddNamespace(string.Empty, xmlNamespace);
XmlParserContext context = new XmlParserContext(
null, taskNSMgr, null, XmlSpace.None);
XmlTextReader taskSchemaReader = new XmlTextReader(
taskXml.OuterXml, XmlNodeType.Element, context);
// Deserialize from the Task's XML to the schema wrapper object
_schemaObject = taskSerializer.Deserialize(taskSchemaReader);
}
}
protected void DiffLoaded(HeapDiff diff, string filename)
{
Modules = diff.Modules;
FunctionNames = diff.FunctionNames;
Deltas = diff.Deltas;
FilteredDeltas = null;
StackGraph = null;
TracebackFilter.AutoCompleteItems = FunctionNames;
Text = "Diff Viewer - " + filename;
Filename = filename;
RefreshModules();
if (PendingRefresh != null)
PendingRefresh.Dispose();
PendingRefresh = Start(RefreshDeltas());
MainMenuStrip.Enabled = true;
LoadingPanel.Visible = false;
MainSplit.Visible = true;
Timeline.Enabled = true;
UseWaitCursor = false;
}
/// <summary>
/// Initializes a new instance of the <see cref="AndroidStudioConverter"/> class.
/// </summary>
public AndroidStudioConverter()
{
_nameTable = new NameTable();
_strings = new AndroidStudioStrings(_nameTable);
}
/// <summary>
/// Generates a random name using the specified name table.
/// </summary>
public static string RandomName(NameTable name = NameTable.FirstGenericMale)
{
return(NWScript.RandomName((int)name));
}
private static XmlNameTable PopulateNameTable (
XmlReaderSettings settings)
{
XmlNameTable nameTable = settings.NameTable;
if (nameTable == null)
nameTable = new NameTable ();
return nameTable;
}
/// <summary>
/// Creates a new instance of the ExcelColumn class.
/// For internal use only!
/// </summary>
/// <param name="Worksheet"></param>
/// <param name="col"></param>
protected internal ExcelColumn(ExcelWorksheet Worksheet, int col)
{
NameTable nt = new NameTable();
_nsManager = new XmlNamespaceManager(nt);
_nsManager.AddNamespace("d", ExcelPackage.schemaMain.NamespaceName);
_xlWorksheet = Worksheet;
var parent = Worksheet.WorksheetXml.XPathSelectElement("//d:cols", _nsManager);
if (parent == null)
{
parent = ExtensonMethods.NewElement("cols");
var refChild = Worksheet.WorksheetXml.XPathSelectElement("//d:sheetData", _nsManager);
refChild.AddBeforeSelf(parent);
}
XAttribute minAttr;
XAttribute maxAttr;
XElement insertBefore = null;
// the column definitions cover a range of columns, so find the one we want
bool insertBeforeFound = false;
foreach (XElement colNode in parent.Nodes())
{
int min = 1;
int max = 1;
minAttr = colNode.Attribute("min");
if (minAttr != null)
{
min = int.Parse(minAttr.Value);
}
maxAttr = colNode.Attribute("max");
if (maxAttr != null)
{
max = int.Parse(maxAttr.Value);
}
if (!insertBeforeFound && (col <= min || col <= max))
{
insertBeforeFound = true;
insertBefore = colNode;
}
if (col >= min && col <= max)
{
_colElement = colNode;
break;
}
}
if (_colElement == null)
{
// create the new column definition
_colElement = ExtensonMethods.NewElement("col");
_colElement.SetAttribute("min", col.ToString());
_colElement.SetAttribute("max", col.ToString());
if (insertBefore != null)
{
insertBefore.AddBeforeSelf(_colElement);
}
else
{
parent.Add(_colElement);
}
}
}
internal NameManager(NameTable nameTable)
{
_names = nameTable;
this.InitKnownNames();
}
public async Task Load(string fileName, ProgressUtility progress)
{
flights.Clear();
// CSV doesn't have realtime clock, so go with the file date instead.
this.startTime = File.GetLastWriteTime(fileName);
// time (us)
long min = long.MaxValue;
long max = long.MinValue;
await Task.Run(() =>
{
timeElementName = null;
using (Stream s = File.OpenRead(fileName))
{
XmlNameTable nametable = new NameTable();
using (XmlCsvReader reader = new XmlCsvReader(s, System.Text.Encoding.UTF8, new Uri(fileName), nametable))
{
progress.ShowProgress(0, s.Length, s.Position);
reader.FirstRowHasColumnNames = true;
data = XDocument.Load(reader);
this.schema = new LogItemSchema()
{
Name = "CsvLog", Type = "Root"
};
var item = new LogItemSchema()
{
Name = System.IO.Path.GetFileName(fileName), Type = "Item"
};
// create the schema
List <LogItemSchema> children = new List <Model.LogItemSchema>();
foreach (String name in reader.ColumnNames)
{
if (timeElementName == null && name.Contains("time"))
{
timeElementName = name;
}
children.Add(new LogItemSchema()
{
Name = name, Parent = this.schema, Type = "Double"
});
}
item.ChildItems = children;
this.schema.ChildItems = new List <Model.LogItemSchema>(new LogItemSchema[] { item });
progress.ShowProgress(0, s.Length, s.Position);
}
}
foreach (var e in data.Root.Elements())
{
long?i = GetTimeMicroseconds(e);
if (i.HasValue)
{
if (i.Value < min)
{
min = i.Value;
}
if (i > max)
{
max = i.Value;
}
}
}
});
// this log has no absolute UTC time, only ticks since board was booted, so we make up a start time.
DateTime end = this.startTime.AddMilliseconds((max - min) / 1000);
var flight = new Flight()
{
Log = this, StartTime = this.startTime, Duration = end - this.startTime
};
this.duration = end - this.startTime;
this.flights.Add(flight);
}
IEnumerator<object> ReloadTracebacks()
{
var keys = from delta in Deltas select delta.TracebackID;
var fTracebacks = Instance.Database.FilteredTracebacks.CascadingSelect(
new[] { Instance.Database.Tracebacks },
keys
);
yield return fTracebacks;
var resolvedTracebacks = new Dictionary<UInt32, TracebackInfo>();
var functionNames = new NameTable();
yield return Instance.ResolveTracebackSymbols(
fTracebacks.Result, resolvedTracebacks, functionNames
);
foreach (var delta in Deltas)
delta.Traceback = resolvedTracebacks[delta.TracebackID];
FunctionNames = functionNames;
DoneReloadingTracebacks();
}
static void Main(string[] args)
{
try {
int curArgIndex = 0;
bool bFragment = false;
// decode options
XmlDiffOptions options = XmlDiffOptions.None;
string optionsString = string.Empty;
while (curArgIndex < args.Length &&
(args[curArgIndex][0] == '/' || args[curArgIndex][0] == '-'))
{
if (args[curArgIndex].Length != 2)
{
System.Console.Write("Invalid option: " + args[curArgIndex] + "\n");
return;
}
switch (args[curArgIndex][1])
{
case '?':
WriteUsage();
return;
case 'o':
options |= XmlDiffOptions.IgnoreChildOrder;
break;
case 'c':
options |= XmlDiffOptions.IgnoreComments;
break;
case 'p':
options |= XmlDiffOptions.IgnorePI;
break;
case 'w':
options |= XmlDiffOptions.IgnoreWhitespace;
break;
case 'n':
options |= XmlDiffOptions.IgnoreNamespaces;
break;
case 'r':
options |= XmlDiffOptions.IgnorePrefixes;
break;
case 'x':
options |= XmlDiffOptions.IgnoreXmlDecl;
break;
case 'd':
options |= XmlDiffOptions.IgnoreDtd;
break;
case 'f':
bFragment = true;
break;
default:
System.Console.Write("Invalid option: " + args[curArgIndex] + "\n");
return;
}
optionsString += args[curArgIndex][1];
curArgIndex++;
}
if (args.Length - curArgIndex < 3)
{
WriteUsage();
return;
}
bool includeIngnore = (args.Length - curArgIndex > 3);
string sourceXmlFile = args[curArgIndex];
string changedXmlFile = args[curArgIndex + 1];
string resultHtmlViewFile = args[curArgIndex + 2];
string diffgramFile = args[curArgIndex + 3];
string ignoreFile = includeIngnore ? args[curArgIndex + 4] : null;
MemoryStream diffgram = new MemoryStream();
XmlTextWriter diffgramWriter = new XmlTextWriter(new StreamWriter(diffgram));
var msg = "Comparing " + sourceXmlFile + " to " + changedXmlFile + " using ignore config " + ignoreFile;
log.Info(msg);
Console.WriteLine(msg);
XmlDiff xmlDiff = new XmlDiff(options);
bool bIdentical = true;
try
{
bIdentical = xmlDiff.Compare(sourceXmlFile, changedXmlFile, bFragment, diffgramWriter, ignoreFile);
}
catch (Exception e)
{
log.Error(e.Message, e);
Console.WriteLine(e.Message);
return;
}
msg = "Files compared " + (bIdentical ? "identical." : "different.");
log.Info(msg);
Console.WriteLine(msg);
msg = "Generating " + resultHtmlViewFile + " view file";
log.Info(msg);
Console.WriteLine(msg);
TextWriter resultHtml = new StreamWriter(new FileStream(resultHtmlViewFile, FileMode.Create, FileAccess.Write));
resultHtml.WriteLine("<html><head>");
resultHtml.WriteLine("<style TYPE='text/css' MEDIA='screen'>");
resultHtml.Write("<!-- td { font-family: Courier New; font-size:14; } " +
"th { font-family: Arial; } " +
"p { font-family: Arial; } -->");
resultHtml.WriteLine("</style></head>");
resultHtml.WriteLine("<body><h3 style='font-family:Arial'>XmlDiff view</h3><table border='0'><tr><td><table border='0'>");
resultHtml.WriteLine("<tr><th>" + sourceXmlFile + "</th><th>" +
changedXmlFile + "</th></tr>" +
"<tr><td colspan=2><hr size=1></td></tr>");
if (bIdentical)
{
resultHtml.WriteLine("<tr><td colspan='2' align='middle'>Files are identical.</td></tr>");
}
else
{
resultHtml.WriteLine("<tr><td colspan='2' align='middle'>Files are different.</td></tr>");
}
diffgram.Seek(0, SeekOrigin.Begin);
Microsoft.XmlDiffPatch.XmlDiffView xmlDiffView = new Microsoft.XmlDiffPatch.XmlDiffView();
XmlTextReader sourceReader;
if (bFragment)
{
NameTable nt = new NameTable();
sourceReader = new XmlTextReader(new FileStream(sourceXmlFile, FileMode.Open, FileAccess.Read),
XmlNodeType.Element,
new XmlParserContext(nt, new XmlNamespaceManager(nt),
string.Empty, XmlSpace.Default));
}
else
{
sourceReader = new XmlTextReader(sourceXmlFile);
}
sourceReader.XmlResolver = null;
xmlDiffView.Load(sourceReader, new XmlTextReader(diffgram));
xmlDiffView.GetHtml(resultHtml);
resultHtml.WriteLine("</table></table></body></html>");
resultHtml.Close();
msg = resultHtmlViewFile + " saved successfully.";
log.Info(msg);
Console.WriteLine(msg);
msg = "saving diffgram file";
log.Info(msg);
Console.WriteLine(msg);
using (FileStream file = new FileStream(diffgramFile, FileMode.Create, FileAccess.Write))
{
diffgram.WriteTo(file);
}
msg = "diffgram file saved to " + diffgramFile;
log.Info(msg);
Console.WriteLine(msg);
}
catch (Exception e) {
log.Error(e.Message, e);
Console.WriteLine("Error: " + e.Message);
}
if (System.Diagnostics.Debugger.IsAttached)
{
Console.Write("\nPress enter...\n");
Console.Read();
}
}
