/// <summary>
/// Decode an AMF packet into an AMFX format.
/// </summary>
/// <exception cref="FormatException">Error during decoding.</exception>
public void Decode(Stream stream, XmlWriter output)
{
if (stream == null) throw new ArgumentNullException("stream");
if (!stream.CanRead) throw new ArgumentException(Errors.AmfPacketReader_Read_StreamClosed, "stream");
if (output == null) throw new ArgumentNullException("output");
try
{
var amfStreamReader = new AmfStreamReader(stream);
var version = ReadPacketVersion(amfStreamReader);
var decoder = CreateDecoder(version, _options);
output.WriteStartDocument();
output.WriteStartElement(AmfxContent.AmfxDocument, AmfxContent.Namespace);
output.WriteAttributeString(AmfxContent.VersionAttribute, version.ToAmfxName());
output.Flush();
//Read headers
var headerCount = ReadDataCount(amfStreamReader);
for (var i = 0; i < headerCount; i++)
{
var header = decoder.ReadPacketHeader(stream);
output.WriteStartElement(AmfxContent.PacketHeader);
output.WriteAttributeString(AmfxContent.PacketHeaderName, header.Name);
output.WriteAttributeString(AmfxContent.PacketHeaderMustUnderstand, header.MustUnderstand.ToString());
decoder.Decode(stream, output);
output.WriteEndElement();
output.Flush();
}
//Read messages
var messageCount = ReadDataCount(amfStreamReader);
for (var i = 0; i < messageCount; i++)
{
var body = decoder.ReadPacketBody(stream);
output.WriteStartElement(AmfxContent.PacketBody);
output.WriteAttributeString(AmfxContent.PacketBodyTarget, body.Target);
output.WriteAttributeString(AmfxContent.PacketBodyResponse, body.Response);
decoder.Decode(stream, output);
output.WriteEndElement();
output.Flush();
}
output.WriteEndElement();
output.WriteEndDocument();
output.Flush();
}
catch (Exception e)
{
output.Flush();
throw new FormatException(Errors.AmfPacketReader_DecodingError, e);
}
}
public void WriteToXML(XmlWriter writer)
{
writer.WriteStartElement("NeuronLayer");
writer.WriteAttributeString("ID", Convert.ToString(mID));
writer.WriteAttributeString("NumNeurons", Convert.ToString(mNumNeurons));
writer.WriteAttributeString("NumInputsPerNeuron", Convert.ToString(mNumInputsPerNeuron));
writer.Flush();
foreach (Neuron n in mNeurons)
n.WriteToXML(writer);
writer.WriteEndElement();
writer.Flush();
}
public override void ExecuteResult(ControllerContext context)
{
var response = context.HttpContext.Response;
response.ClearContent();
response.ContentType = "text/xml";
response.AddHeader("Content-Disposition", string.Format("attachment; filename={0}.xml", _exportName));
var settings = new XmlWriterSettings
{
Indent = true,
Encoding = Encoding.UTF8,
ConformanceLevel = ConformanceLevel.Document,
CheckCharacters = true,
NamespaceHandling = NamespaceHandling.OmitDuplicates
};
_writer = XmlWriter.Create(response.OutputStream, settings);
_writer.WriteStartDocument(true);
AddItem(_blob, _rootName, true);
_writer.WriteEndDocument();
_writer.Flush();
_writer = null;
}
// ***************************************************************************
// Beendet an zu schreiben
public static void EndXML(XmlWriter writer)
{
writer.WriteEndElement();
writer.WriteEndDocument();
writer.Flush();
writer.Close();
}
public void Serialize(DbDatabaseMapping databaseMapping, XmlWriter xmlWriter)
{
DebugCheck.NotNull(xmlWriter);
DebugCheck.NotNull(databaseMapping);
Debug.Assert(databaseMapping.Model != null);
Debug.Assert(databaseMapping.Database != null);
_xmlWriter = xmlWriter;
_databaseMapping = databaseMapping;
_version = databaseMapping.Model.SchemaVersion;
_namespace = Equals(_version, XmlConstants.EdmVersionForV3)
? EdmXmlNamespaceV3
: (Equals(_version, XmlConstants.EdmVersionForV2) ? EdmXmlNamespaceV2 : EdmXmlNamespaceV1);
_xmlWriter.WriteStartDocument();
using (Element("Edmx", "Version", string.Format(CultureInfo.InvariantCulture, "{0:F1}", _version)))
{
WriteEdmxRuntime();
WriteEdmxDesigner();
}
_xmlWriter.WriteEndDocument();
_xmlWriter.Flush();
}
public void Serialize(DbDatabaseMapping databaseMapping, DbProviderInfo providerInfo, XmlWriter xmlWriter)
{
//Contract.Requires(xmlWriter != null);
//Contract.Requires(databaseMapping != null);
//Contract.Requires(providerInfo != null);
Contract.Assert(databaseMapping.Model != null);
Contract.Assert(databaseMapping.Database != null);
_xmlWriter = xmlWriter;
_databaseMapping = databaseMapping;
_version = databaseMapping.Model.Version;
_providerInfo = providerInfo;
_namespace = _version == DataModelVersions.Version3 ? EdmXmlNamespaceV3 : EdmXmlNamespaceV2;
_xmlWriter.WriteStartDocument();
using (Element("Edmx", "Version", string.Format(CultureInfo.InvariantCulture, "{0:F1}", _version)))
{
WriteEdmxRuntime();
WriteEdmxDesigner();
}
_xmlWriter.WriteEndDocument();
_xmlWriter.Flush();
}
public void Write(Resource rsrc)
{
var settings = new XmlWriterSettings();
settings.Indent = PrettyPrint;
settings.IndentChars = "\t";
using (this.writer = XmlWriter.Create(stream, settings))
{
writer.WriteStartElement("save");
writer.WriteStartElement("header");
writer.WriteAttributeString("version", LSXReader.CurrentVersion);
writer.WriteAttributeString("time", rsrc.Metadata.timestamp.ToString());
writer.WriteEndElement();
writer.WriteStartElement("version");
writer.WriteAttributeString("major", rsrc.Metadata.majorVersion.ToString());
writer.WriteAttributeString("minor", rsrc.Metadata.minorVersion.ToString());
writer.WriteAttributeString("revision", rsrc.Metadata.revision.ToString());
writer.WriteAttributeString("build", rsrc.Metadata.buildNumber.ToString());
writer.WriteEndElement();
WriteRegions(rsrc);
writer.WriteEndElement();
writer.Flush();
}
}
private void ProcessTag(IEnumerable<tag_group> h2Tags, string folder, BinaryReader reader, XmlWriter writer, tag_group tag)
{
const int @null = -1;
List<tag_field> fields = null;
if (tag.parent_group_tag != @null)
{
fields = new List<tag_field>();
var parent = h2Tags.Where(x => x.group_tag == tag.parent_group_tag).Single();
if (parent.parent_group_tag != @null)
{
var @base = h2Tags.Where(x => x.group_tag == parent.parent_group_tag).Single();
fields.AddRange(ExtractFields(h2Tags, reader, @base));
}
fields.AddRange(ExtractFields(h2Tags, reader, parent));
fields.AddRange(ExtractFields(h2Tags, reader, tag));
}
// Process the tag_group definition.
var fieldOffset = 0;
ProcessTagBlockDefinition(tag.Definition, writer, tag.definition_address, ref fieldOffset, tag.Class.ToString(), "", root, false, fields);
root = root ? false : false;
writer.Flush();
//File.WriteAllText(string.Format("{0}\\{1}.cs", folder, readTag.Name), writer.ToString());
return;
}
public static void Write(XmlWriter writer, Ticket pt)
{
var declarations = NamespaceDeclarations(pt);
writer.WriteStartDocument();
var prefix = declarations.LookupPrefix(Psf.PrintTicket.NamespaceName);
writer.WriteStartElement(prefix, Psf.PrintTicket.LocalName, Psf.PrintTicket.NamespaceName);
writer.WriteAttributeString("version", "1");
foreach (var decl in declarations)
{
writer.WriteAttributeString("xmlns", decl.Prefix, null, decl.Uri.NamespaceName);
}
foreach (var f in pt.Features())
{
Write(writer, f);
}
foreach (var p in pt.Properties())
{
Write(writer, p);
}
foreach (var p in pt.Parameters())
{
Write(writer, p);
}
writer.WriteEndElement();
writer.Flush();
}
public void DbmlToFile(Database db, string filename, Encoding encoding)
{
var settings = new XmlWriterSettings {Indent = true, Encoding = encoding};
writer = XmlWriter.Create(filename, settings);
VisitDatabase(db);
writer.Flush();
writer.Close();
}
/// <summary>
/// Serialize the expression into Xml format
/// </summary>
/// <param name="exp">The Expression</param>
/// <returns>The serialized Xml in String Format</returns>
public static String Serialize(Expression exp)
{
outputText = new StringBuilder();
writer = XmlTextWriter.Create(outputText);
new ExpressionTreeToXmlSerializer().Visit(exp);
writer.Flush();
return outputText.ToString();
}
public override void Generate(XmlWriter writer)
{
writer.WriteStartElement(@"roamingData", @"http://schemas.microsoft.com/2006/09/sip/roaming-self");
this.categories.Generate(writer);
writer.WriteEndElement();
writer.Flush();
}
private static int GetNumberOfExistingTasks(XmlWriter data, TaskDocumentWriter isoTaskData)
{
data.Flush();
var xml = Encoding.UTF8.GetString(isoTaskData.XmlStream.ToArray());
if(!xml.EndsWith(">"))
xml += ">";
xml += "</ISO11783_TaskData>";
var xDocument = XDocument.Parse(xml);
return xDocument.Root.Descendants("TSK").Count();
}
public void WriteXml(XmlWriter writer)
{
writer.WriteStartElement("Rule");
writer.WriteAttributeString("Answer", this._answer);
writer.WriteAttributeString("AnswerId", this._answerId);
writer.WriteString(this._jumpToPage);
writer.WriteEndElement();
writer.Flush();
}
public static void startLocal() {
local = true;
if (Xmlw == null) {
byte[] b = Encoding.UTF8.GetBytes(DateTime.Now.ToString());
log = Convert.ToBase64String(b) + ".gh";
Xmlw = XmlWriter.Create(log);
Xmlw.WriteStartElement("doc");
Xmlw.WriteComment(DateTime.Now.ToString());
Xmlw.Flush();
}
}
/// <summary>
/// Helper method for default serialization
/// </summary>
internal static void Serialize(this IBatch batch, XmlWriter xmlWriter)
{
xmlWriter.WriteStartElement(BatchNodeName);
batch.SerializeData(xmlWriter);
foreach (var log in batch.Logs)
{
xmlWriter.WriteStartElement(LogNodeName);
log.SerializeData(xmlWriter);
xmlWriter.WriteEndElement();
}
xmlWriter.WriteEndElement();
xmlWriter.Flush();
}
public void Generate(XmlWriter writer)
{
writer.WriteStartElement(@"state", @"http://schemas.microsoft.com/2006/09/sip/state");
writer.WriteAttributeString(@"xsi", @"type", @"http://www.w3.org/2001/XMLSchema-instance", @"aggregateState");
writer.WriteStartElement(@"availability");
writer.WriteValue(this.Availability);
writer.WriteEndElement();
writer.WriteEndElement();
writer.Flush();
}
// Constructor
public Hxt(string filePath, Encoding encoding)
{
Disposed = false;
XmlWriterSettings settings = new XmlWriterSettings { Indent = true, NewLineChars = Environment.NewLine, Encoding = encoding, };
writer = XmlWriter.Create(filePath, settings);
// Write header
writer.WriteStartDocument();
writer.WriteDocType("HelpTOC", null, "MS-Help://Hx/Resources/HelpTOC.DTD", null);
writer.WriteStartElement("HelpTOC");
writer.WriteAttributeString("DTDVersion", "1.0");
writer.Flush();
}
public void SaveXml(CompilationUnit cu)
{
try
{
this.cu = cu;
is_assembly = cu.SyntaxTree is SyntaxTree.program_module || Compiler.is_dll(cu.SyntaxTree);
XmlWriterSettings settings = new XmlWriterSettings();
settings.Encoding = Encoding.UTF8;
settings.Indent = true;
xtw = XmlTextWriter.Create(Path.ChangeExtension(cu.UnitName, ".xml"), settings);
unit_name = Path.GetFileNameWithoutExtension(cu.UnitName);
xtw.WriteStartDocument();
xtw.WriteStartElement("doc");
if (is_assembly)
{
xtw.WriteStartElement("assembly");
xtw.WriteStartElement("name");
xtw.WriteString(Path.GetFileNameWithoutExtension(cu.UnitName));
xtw.WriteEndElement();
xtw.WriteEndElement();
}
else
{
xtw.WriteStartElement("unit");
xtw.WriteStartAttribute("name");
//xtw.WriteString((cu.SemanticTree as common_unit_node).unit_name);
xtw.WriteString(Path.GetFileNameWithoutExtension(cu.UnitName));
xtw.WriteEndAttribute();
xtw.WriteString(cu.SemanticTree.documentation);
xtw.WriteEndElement();
}
SaveMembers();
xtw.WriteEndElement();
xtw.Flush();
}
catch (Exception e)
{
}
try
{
if (xtw != null)
xtw.Close();
}
catch
{
}
}
public void WriteXml(XmlWriter writer)
{
writer.WriteStartElement("Option");
writer.WriteAttributeString("value", this._value);
if (this._selected)
writer.WriteAttributeString("selected", "true");
if (!this._enabled)
writer.WriteAttributeString("enabled", "false");
writer.WriteString(this._text);
writer.WriteEndElement();
writer.Flush();
}
public void Translate(ValueStack stack, System.IO.Stream input, System.IO.Stream output)
{
XmlDocument doc = new XmlDocument();
doc.Load(input);
using (System.Xml.XmlWriter w = System.Xml.XmlWriter.Create(output, new XmlWriterSettings()
{
NewLineHandling = NewLineHandling.Entitize, Indent = false, NewLineOnAttributes = false
}))
{
ProcessNode(stack, doc.DocumentElement.FirstChild, w);
w.Flush();
}
}
// start logging adding rows
int StartAddingRows(object sender)
{
updating = true;
// uncheck other radio buttons
foreach (Control ctl in groupBox1.Controls)
{
if (ctl is RadioButton && !ctl.Equals(sender))
{
((RadioButton)ctl).Checked = false;
}
}
foreach (Control ctl in groupBox2.Controls)
{
if (ctl is RadioButton && !ctl.Equals(sender))
{
((RadioButton)ctl).Checked = false;
}
}
// save current view
stream = new MemoryStream();
using (System.Xml.XmlWriter xw = System.Xml.XmlWriter.Create(stream))
{
_c1FlexPivotPage.FlexPivotEngine.WriteXml(xw);
xw.Flush();
stream.Position = 0;
}
// check selected button
sel = ((RadioButton)sender);
sel.Checked = true;
// disconnect from data
var fPanel = _c1FlexPivotPage.FlexPivotPanel;
fPanel.DataSource = null;
fPanel.ConnectDataEngine(null);
// start log
int count = int.Parse(sel.Tag.ToString());
addTime = DateTime.Now;
listBox1.Items.Add(string.Format("Creating {0} rows...", count.ToString("n0")));
listBox1.TopIndex = listBox1.Items.Count - 1;
Application.DoEvents();
return(count);
}
private static void RewriteLinks(XmlReader reader, XmlWriter writer)
{
if (IsAtSelfLink(reader))
{
reader.Skip();
}
else if (IsAtViaLink(reader))
{
string href = reader.GetAttribute("href");
reader.Skip();
writer.WriteStartElement("link", "http://www.w3.org/2005/Atom");
writer.WriteAttributeString("rel", "self");
writer.WriteAttributeString("href", href);
writer.WriteEndElement();
writer.Flush();
}
}
public void Execute(object defaultDocument, XmlResolver dataSources, XsltArgumentList argumentList, XmlWriter writer)
{
try
{
XmlWellFormedWriter writer2 = writer as XmlWellFormedWriter;
if (((writer2 != null) && (writer2.RawWriter != null)) && ((writer2.WriteState == WriteState.Start) && (writer2.Settings.ConformanceLevel != ConformanceLevel.Document)))
{
this.Execute(defaultDocument, dataSources, argumentList, new XmlMergeSequenceWriter(writer2.RawWriter));
}
else
{
this.Execute(defaultDocument, dataSources, argumentList, new XmlMergeSequenceWriter(new XmlRawWriterWrapper(writer)));
}
}
finally
{
writer.Flush();
}
}
public string DbmlToString(Database db, Encoding encoding)
{
string str;
using (var stream = new MemoryStream())
using (var streamWriter = new StreamWriter(stream, encoding))
{
var settings = new XmlWriterSettings {Indent = true, Encoding = encoding};
writer = XmlWriter.Create(streamWriter, settings);
VisitDatabase(db);
writer.Flush();
writer.Close();
using (var reader = new StreamReader(stream, encoding))
{
stream.Position = 0L;
str = reader.ReadToEnd();
}
}
return str;
}
private void Serialize <T>(T obj, string sConfigFilePath)
{
try
{
System.Xml.Serialization.XmlSerializer XmlBuddy = new System.Xml.Serialization.XmlSerializer(typeof(T));
System.Xml.XmlWriterSettings MySettings = new System.Xml.XmlWriterSettings();
MySettings.Indent = true;
MySettings.CloseOutput = true;
MySettings.OmitXmlDeclaration = true;
System.Xml.XmlWriter MyWriter = System.Xml.XmlWriter.Create(sConfigFilePath, MySettings);
XmlBuddy.Serialize(MyWriter, obj);
MyWriter.Flush();
MyWriter.Close();
}
catch (Exception ex)
{
account.Log(new ErrorTextInformation(ex.Message + ex.StackTrace), 0);
}
}
// This method creates Xml with a point and returns it in a string form
public string ToXml()
{
//Initiate XML stuff
KeyValuePair <string, string> point = GetNewPoint();
string lon = point.Key;
string lat = point.Value;
StringBuilder sb = new StringBuilder();
XmlWriterSettings settings = new XmlWriterSettings();
System.Xml.XmlWriter writer = System.Xml.XmlWriter.Create(sb, settings);
writer.WriteStartDocument();
writer.WriteStartElement("Point");
writer.WriteElementString("lon", lon);
writer.WriteElementString("lat", lat);
writer.WriteEndElement();
writer.WriteEndDocument();
writer.Flush();
return(sb.ToString());
}
public virtual string ToDescriptionDocument()
{
if (String.IsNullOrEmpty(this.Uuid))
{
throw new InvalidOperationException("Must provide a UUID value.");
}
//This would have been so much nicer with Xml.Linq, but that's
//not available until .NET 4.03 at the earliest, and I want to
//target 4.0 :(
using (System.IO.MemoryStream ms = new System.IO.MemoryStream())
{
System.Xml.XmlWriter writer = System.Xml.XmlWriter.Create(ms, new XmlWriterSettings()
{
Encoding = System.Text.UTF8Encoding.UTF8, Indent = true, NamespaceHandling = NamespaceHandling.OmitDuplicates
});
writer.WriteStartDocument();
writer.WriteStartElement("root", SsdpConstants.SsdpDeviceDescriptionXmlNamespace);
writer.WriteStartElement("specVersion");
writer.WriteElementString("major", "1");
writer.WriteElementString("minor", "0");
writer.WriteEndElement();
if (this.UrlBase != null && this.UrlBase != this.Location)
{
writer.WriteElementString("URLBase", this.UrlBase.ToString());
}
WriteDeviceDescriptionXml(writer, this);
writer.WriteEndElement();
writer.Flush();
ms.Seek(0, System.IO.SeekOrigin.Begin);
using (var reader = new System.IO.StreamReader(ms))
{
return(reader.ReadToEnd());
}
}
}
private System.IO.Stream MessageToStream(HttpContextServiceHost ctx, Message message)
{
System.IO.Stream ms = new System.IO.MemoryStream();
using (System.IO.Stream tempms = new System.IO.MemoryStream())
{
using (System.Xml.XmlWriter writer = System.Xml.XmlWriter.Create(tempms))
{
message.WriteMessage(writer);
writer.Flush();
}
ctx.OriginalContentLength = (int)tempms.Length;
tempms.Position = 0;
using (System.IO.Compression.GZipStream gzip = new System.IO.Compression.GZipStream(ms, System.IO.Compression.CompressionMode.Compress, true))
{
tempms.CopyTo(gzip);
}
}
ms.Position = 0;
return(ms);
}
private string CreateEmptyXml()
{
var settings = new XmlWriterSettings
{
OmitXmlDeclaration = false,
Encoding = Encoding.UTF8
};
var stream = new MemoryStream();
using (System.Xml.XmlWriter writer = XmlWriter.Create(stream, settings))
{
writer.WriteStartDocument();
writer.WriteStartElement("feed");
writer.WriteEndElement();
writer.Flush();
writer.Close();
}
stream.Position = 0;
var streamReader = new StreamReader(stream);
return(streamReader.ReadToEnd());
}
private bool SignForm(XmlReader reader, XmlWriter writer)
{
if (!reader.IsStartElement("model"))
{
return false;
}
var doc = XDocument.Load(reader.ReadSubtree());
var formContents = GetFormContents(doc);
var submission = GetSubmission(doc);
if (submission != null)
{
submission.Element.SetAttributeValue("resource", submission.TargetUri.Replace(signaturePlaceholder, signature.GenerateSignature(formContents)));
}
reader.ReadEndElement();
writer.WriteNode(doc.CreateReader(), false);
writer.Flush();
return true;
}
void IXmlSerializable.WriteXml(System.Xml.XmlWriter writer)
{
// This is the chunking code.
// ASP.NET buffering must be turned off for this to work.
int bufferSize = 4096;
char[] songBytes = new char[bufferSize];
FileStream inFile = File.Open(this.filePath, FileMode.Open, FileAccess.Read);
long length = inFile.Length;
// Write the file name.
writer.WriteElementString("fileName", ns, Path.GetFileNameWithoutExtension(this.filePath));
// Write the size.
writer.WriteElementString("size", ns, length.ToString());
// Write the song bytes.
writer.WriteStartElement("song", ns);
StreamReader sr = new StreamReader(inFile, true);
int readLen = sr.Read(songBytes, 0, bufferSize);
while (readLen > 0)
{
writer.WriteStartElement("chunk", ns);
writer.WriteChars(songBytes, 0, readLen);
writer.WriteEndElement();
writer.Flush();
readLen = sr.Read(songBytes, 0, bufferSize);
}
writer.WriteEndElement();
inFile.Close();
}
public override string Index(string folderPath)
{
FolderInfo folderInfo = GetFolderInfo(folderPath);
folderInfo.Update();
XmlWriterSettings xmlWriterSettings = new XmlWriterSettings();
xmlWriterSettings.Encoding = new UTF8Encoding(false);
xmlWriterSettings.ConformanceLevel = ConformanceLevel.Document;
xmlWriterSettings.Indent = true;
using (MemoryStream ms = new MemoryStream())
{
using (xmlWriter = XmlWriter.Create(ms, xmlWriterSettings))
{
xmlWriter.WriteStartDocument();
IndexFolder(folderInfo);
xmlWriter.WriteEndDocument();
xmlWriter.Flush();
}
return Encoding.UTF8.GetString(ms.ToArray());
}
}
/// <summary>Builds an Xml file combining the reflected metadata with the /doc comments.</summary>
private void BuildXml(XmlWriter writer)
{
int start = Environment.TickCount;
Debug.WriteLine("Memory making xml: " + GC.GetTotalMemory(false).ToString());
try
{
assemblyLoader = SetupAssemblyLoader();
string DocLangCode = Enum.GetName(typeof(SdkLanguage), this.rep.SdkDocLanguage).Replace("_", "-");
externalSummaryCache = new ExternalXmlSummaryCache(DocLangCode);
notEmptyNamespaces = new Hashtable();
namespaceHierarchies = new NamespaceHierarchyCollection();
baseInterfaces = new TypeHierarchy();
derivedTypes = new TypeHierarchy();
interfaceImplementingTypes = new TypeHierarchy();
attributeFilter = new AttributeUsageDisplayFilter(this.rep.DocumentedAttributes);
documentedTypes = new Hashtable();
PreReflectionProcess();
string currentAssemblyFilename = "";
try
{
// Start the document with the XML declaration tag
writer.WriteStartDocument();
// Start the root element
writer.WriteStartElement("ndoc");
writer.WriteAttributeString("SchemaVersion", "1.4");
if (this.rep.FeedbackEmailAddress.Length > 0)
WriteFeedBackEmailAddress(writer);
if (this.rep.CopyrightText.Length > 0)
WriteCopyright(writer);
if (this.rep.IncludeDefaultThreadSafety)
WriteDefaultThreadSafety(writer);
if (this.rep.Preliminary)
writer.WriteElementString("preliminary", "");
WriteNamespaceHierarchies(writer);
foreach (string AssemblyFileName in this.rep.AssemblyFileNames)
{
currentAssemblyFilename = AssemblyFileName;
Assembly assembly = assemblyLoader.LoadAssembly(currentAssemblyFilename);
int starta = Environment.TickCount;
WriteAssembly(writer, assembly);
Trace.WriteLine("Completed " + assembly.FullName);
Trace.WriteLine(((Environment.TickCount - starta) / 1000.0).ToString() + " sec.");
}
writer.WriteEndElement();
writer.WriteEndDocument();
writer.Flush();
Trace.WriteLine("MakeXML : " + ((Environment.TickCount - start) / 1000.0).ToString() + " sec.");
// if you want to see NDoc's intermediate XML file, use the XML documenter.
}
finally
{
if (assemblyLoader != null)
{
assemblyLoader.Deinstall();
}
}
}
catch (ReflectionTypeLoadException rtle)
{
StringBuilder sb = new StringBuilder();
if (assemblyLoader.UnresolvedAssemblies.Count > 0)
{
sb.Append("One or more required assemblies could not be located : \n");
foreach (string ass in assemblyLoader.UnresolvedAssemblies)
{
sb.AppendFormat(" {0}\n", ass);
}
sb.Append("\nThe following directories were searched, \n");
foreach (string dir in assemblyLoader.SearchedDirectories)
{
sb.AppendFormat(" {0}\n", dir);
}
}
else
{
Hashtable fileLoadExceptions = new Hashtable();
foreach (Exception loaderEx in rtle.LoaderExceptions)
{
System.IO.FileLoadException fileLoadEx = loaderEx as System.IO.FileLoadException;
if (fileLoadEx != null)
{
if (!fileLoadExceptions.ContainsKey(fileLoadEx.FileName))
{
fileLoadExceptions.Add(fileLoadEx.FileName, null);
sb.Append("Unable to load: " + fileLoadEx.FileName + "\r\n");
}
}
sb.Append(loaderEx.Message + Environment.NewLine);
sb.Append(loaderEx.StackTrace + Environment.NewLine);
sb.Append("--------------------" + Environment.NewLine + Environment.NewLine);
}
}
throw new DocumenterException(sb.ToString());
}
}
/// <summary>
/// Replay all cached events to an XmlWriter.
/// </summary>
public void EventsToWriter(XmlWriter writer) {
XmlEvent[] page;
int idxPage, idxEvent;
byte[] bytes;
char[] chars;
XmlRawWriter rawWriter;
// Special-case single text node at the top-level
if (this.singleText.Count != 0) {
writer.WriteString(this.singleText.GetResult());
return;
}
rawWriter = writer as XmlRawWriter;
// Loop over set of pages
for (idxPage = 0; idxPage < this.pages.Count; idxPage++) {
page = this.pages[idxPage];
// Loop over events in each page
for (idxEvent = 0; idxEvent < page.Length; idxEvent++) {
switch (page[idxEvent].EventType) {
case XmlEventType.Unknown:
// No more events
Debug.Assert(idxPage + 1 == this.pages.Count);
return;
case XmlEventType.DocType:
writer.WriteDocType(page[idxEvent].String1, page[idxEvent].String2, page[idxEvent].String3, (string) page[idxEvent].Object);
break;
case XmlEventType.StartElem:
writer.WriteStartElement(page[idxEvent].String1, page[idxEvent].String2, page[idxEvent].String3);
break;
case XmlEventType.StartAttr:
writer.WriteStartAttribute(page[idxEvent].String1, page[idxEvent].String2, page[idxEvent].String3);
break;
case XmlEventType.EndAttr:
writer.WriteEndAttribute();
break;
case XmlEventType.CData:
writer.WriteCData(page[idxEvent].String1);
break;
case XmlEventType.Comment:
writer.WriteComment(page[idxEvent].String1);
break;
case XmlEventType.PI:
writer.WriteProcessingInstruction(page[idxEvent].String1, page[idxEvent].String2);
break;
case XmlEventType.Whitespace:
writer.WriteWhitespace(page[idxEvent].String1);
break;
case XmlEventType.String:
writer.WriteString(page[idxEvent].String1);
break;
case XmlEventType.Raw:
writer.WriteRaw(page[idxEvent].String1);
break;
case XmlEventType.EntRef:
writer.WriteEntityRef(page[idxEvent].String1);
break;
case XmlEventType.CharEnt:
writer.WriteCharEntity((char) page[idxEvent].Object);
break;
case XmlEventType.SurrCharEnt:
chars = (char[]) page[idxEvent].Object;
writer.WriteSurrogateCharEntity(chars[0], chars[1]);
break;
case XmlEventType.Base64:
bytes = (byte[]) page[idxEvent].Object;
writer.WriteBase64(bytes, 0, bytes.Length);
break;
case XmlEventType.BinHex:
bytes = (byte[]) page[idxEvent].Object;
writer.WriteBinHex(bytes, 0, bytes.Length);
break;
case XmlEventType.XmlDecl1:
if (rawWriter != null)
rawWriter.WriteXmlDeclaration((XmlStandalone) page[idxEvent].Object);
break;
case XmlEventType.XmlDecl2:
if (rawWriter != null)
rawWriter.WriteXmlDeclaration(page[idxEvent].String1);
break;
case XmlEventType.StartContent:
if (rawWriter != null)
rawWriter.StartElementContent();
break;
case XmlEventType.EndElem:
if (rawWriter != null)
rawWriter.WriteEndElement(page[idxEvent].String1, page[idxEvent].String2, page[idxEvent].String3);
else
writer.WriteEndElement();
break;
case XmlEventType.FullEndElem:
if (rawWriter != null)
rawWriter.WriteFullEndElement(page[idxEvent].String1, page[idxEvent].String2, page[idxEvent].String3);
else
writer.WriteFullEndElement();
break;
case XmlEventType.Nmsp:
if (rawWriter != null)
rawWriter.WriteNamespaceDeclaration(page[idxEvent].String1, page[idxEvent].String2);
else
writer.WriteAttributeString("xmlns", page[idxEvent].String1, XmlReservedNs.NsXmlNs, page[idxEvent].String2);
break;
case XmlEventType.EndBase64:
if (rawWriter != null)
rawWriter.WriteEndBase64();
break;
case XmlEventType.Close:
writer.Close();
break;
case XmlEventType.Flush:
writer.Flush();
break;
case XmlEventType.Dispose:
((IDisposable)writer).Dispose();
break;
default:
Debug.Assert(false, "Unknown event: " + page[idxEvent].EventType);
break;
}
}
}
Debug.Assert(false, "Unknown event should be added to end of event sequence.");
}
private static void SaveDocument(XmlDocument doc, XmlWriter xmlWriter)
{
doc.Save(xmlWriter);
xmlWriter.Flush();
}
public override void Flush()
{
w.Flush();
}
public Validation.SchematronOutput.schematronoutput Validate(Stream xmlstream, Stream schematronstream)
{
///////////////////////////////
// Transform original Schemtron
///////////////////////////////
string path = AppDomain.CurrentDomain.BaseDirectory;
Uri schematronxsl = new Uri(@"file:\\" + path + @"\xsl_2.0\iso_svrl_for_xslt2.xsl");
Stream schematrontransform = new Validation.XSLTransform().Transform(schematronstream, schematronxsl);
///////////////////////////////
// Apply Schemtron xslt
///////////////////////////////
Stream results = new Validation.XSLTransform().Transform(xmlstream, schematrontransform);
results.Position = 0;
System.Xml.XmlDocument doc = new System.Xml.XmlDocument();
doc.Load(results);
var nodes = doc.ChildNodes[1].ChildNodes;
System.Xml.XmlNode activepattern = null;
System.Xml.XmlNode firedrule = null;
System.Xml.XmlNode failedassert = null;
List <System.Xml.XmlNode> nodesclone = new List <System.Xml.XmlNode>();
foreach (System.Xml.XmlNode node in nodes)
{
nodesclone.Add(node);
}
foreach (System.Xml.XmlNode node in nodesclone)
{
if (node.Name == "svrl:active-pattern")
{
activepattern = node;
}
if (node.Name == "svrl:fired-rule")
{
firedrule = node;
activepattern.AppendChild(firedrule);
}
if (node.Name == "svrl:failed-assert")
{
failedassert = node;
firedrule.AppendChild(failedassert);
}
}
//System.IO.StreamReader rd2 = new System.IO.StreamReader(results);
//string xsltSchematronResult = rd2.ReadToEnd();
//xsltSchematronResult = xsltSchematronResult.Replace("schematron-output", "schematronoutput");
MemoryStream ms = new MemoryStream();
System.Xml.XmlWriter w = System.Xml.XmlWriter.Create(ms);
ms.Position = 0;
doc.WriteTo(w);
w.Flush();
return(Serialization.DerializeXML <Validation.SchematronOutput.schematronoutput>(ms));
}
public void EventsToWriter(XmlWriter writer)
{
if (this.singleText.Count != 0)
{
writer.WriteString(this.singleText.GetResult());
}
else
{
XmlRawWriter writer2 = writer as XmlRawWriter;
for (int i = 0; i < this.pages.Count; i++)
{
XmlEvent[] eventArray = this.pages[i];
for (int j = 0; j < eventArray.Length; j++)
{
byte[] buffer;
switch (eventArray[j].EventType)
{
case XmlEventType.Unknown:
return;
case XmlEventType.DocType:
{
writer.WriteDocType(eventArray[j].String1, eventArray[j].String2, eventArray[j].String3, (string)eventArray[j].Object);
continue;
}
case XmlEventType.StartElem:
{
writer.WriteStartElement(eventArray[j].String1, eventArray[j].String2, eventArray[j].String3);
continue;
}
case XmlEventType.StartAttr:
{
writer.WriteStartAttribute(eventArray[j].String1, eventArray[j].String2, eventArray[j].String3);
continue;
}
case XmlEventType.EndAttr:
{
writer.WriteEndAttribute();
continue;
}
case XmlEventType.CData:
{
writer.WriteCData(eventArray[j].String1);
continue;
}
case XmlEventType.Comment:
{
writer.WriteComment(eventArray[j].String1);
continue;
}
case XmlEventType.PI:
{
writer.WriteProcessingInstruction(eventArray[j].String1, eventArray[j].String2);
continue;
}
case XmlEventType.Whitespace:
{
writer.WriteWhitespace(eventArray[j].String1);
continue;
}
case XmlEventType.String:
{
writer.WriteString(eventArray[j].String1);
continue;
}
case XmlEventType.Raw:
{
writer.WriteRaw(eventArray[j].String1);
continue;
}
case XmlEventType.EntRef:
{
writer.WriteEntityRef(eventArray[j].String1);
continue;
}
case XmlEventType.CharEnt:
{
writer.WriteCharEntity((char)eventArray[j].Object);
continue;
}
case XmlEventType.SurrCharEnt:
{
char[] chArray = (char[])eventArray[j].Object;
writer.WriteSurrogateCharEntity(chArray[0], chArray[1]);
continue;
}
case XmlEventType.Base64:
{
buffer = (byte[])eventArray[j].Object;
writer.WriteBase64(buffer, 0, buffer.Length);
continue;
}
case XmlEventType.BinHex:
{
buffer = (byte[])eventArray[j].Object;
writer.WriteBinHex(buffer, 0, buffer.Length);
continue;
}
case XmlEventType.XmlDecl1:
{
if (writer2 != null)
{
writer2.WriteXmlDeclaration((XmlStandalone)eventArray[j].Object);
}
continue;
}
case XmlEventType.XmlDecl2:
{
if (writer2 != null)
{
writer2.WriteXmlDeclaration(eventArray[j].String1);
}
continue;
}
case XmlEventType.StartContent:
{
if (writer2 != null)
{
writer2.StartElementContent();
}
continue;
}
case XmlEventType.EndElem:
{
if (writer2 == null)
{
break;
}
writer2.WriteEndElement(eventArray[j].String1, eventArray[j].String2, eventArray[j].String3);
continue;
}
case XmlEventType.FullEndElem:
{
if (writer2 == null)
{
goto Label_0367;
}
writer2.WriteFullEndElement(eventArray[j].String1, eventArray[j].String2, eventArray[j].String3);
continue;
}
case XmlEventType.Nmsp:
{
if (writer2 == null)
{
goto Label_0394;
}
writer2.WriteNamespaceDeclaration(eventArray[j].String1, eventArray[j].String2);
continue;
}
case XmlEventType.EndBase64:
{
if (writer2 != null)
{
writer2.WriteEndBase64();
}
continue;
}
case XmlEventType.Close:
{
writer.Close();
continue;
}
case XmlEventType.Flush:
{
writer.Flush();
continue;
}
case XmlEventType.Dispose:
{
writer.Dispose();
continue;
}
default:
{
continue;
}
}
writer.WriteEndElement();
continue;
Label_0367:
writer.WriteFullEndElement();
continue;
Label_0394:
writer.WriteAttributeString("xmlns", eventArray[j].String1, "http://www.w3.org/2000/xmlns/", eventArray[j].String2);
}
}
}
}
/// <summary>
/// Replay all cached events to an XmlWriter.
/// </summary>
public void EventsToWriter(XmlWriter writer)
{
XmlEvent[] page;
int idxPage, idxEvent;
byte[] bytes;
char[] chars;
XmlRawWriter?rawWriter;
// Special-case single text node at the top-level
if (_singleText.Count != 0)
{
writer.WriteString(_singleText.GetResult());
return;
}
rawWriter = writer as XmlRawWriter;
// Loop over set of pages
for (idxPage = 0; idxPage < _pages !.Count; idxPage++)
{
page = _pages[idxPage];
// Loop over events in each page
for (idxEvent = 0; idxEvent < page.Length; idxEvent++)
{
switch (page[idxEvent].EventType)
{
case XmlEventType.Unknown:
// No more events
Debug.Assert(idxPage + 1 == _pages.Count);
return;
case XmlEventType.DocType:
writer.WriteDocType(page[idxEvent].String1 !, page[idxEvent].String2, page[idxEvent].String3, (string?)page[idxEvent].Object);
break;
case XmlEventType.StartElem:
writer.WriteStartElement(page[idxEvent].String1, page[idxEvent].String2 !, page[idxEvent].String3);
break;
case XmlEventType.StartAttr:
writer.WriteStartAttribute(page[idxEvent].String1, page[idxEvent].String2 !, page[idxEvent].String3);
break;
case XmlEventType.EndAttr:
writer.WriteEndAttribute();
break;
case XmlEventType.CData:
writer.WriteCData(page[idxEvent].String1);
break;
case XmlEventType.Comment:
writer.WriteComment(page[idxEvent].String1);
break;
case XmlEventType.PI:
writer.WriteProcessingInstruction(page[idxEvent].String1 !, page[idxEvent].String2);
break;
case XmlEventType.Whitespace:
writer.WriteWhitespace(page[idxEvent].String1);
break;
case XmlEventType.String:
writer.WriteString(page[idxEvent].String1);
break;
case XmlEventType.Raw:
writer.WriteRaw(page[idxEvent].String1 !);
break;
case XmlEventType.EntRef:
writer.WriteEntityRef(page[idxEvent].String1 !);
break;
case XmlEventType.CharEnt:
writer.WriteCharEntity((char)page[idxEvent].Object !);
break;
case XmlEventType.SurrCharEnt:
chars = (char[])page[idxEvent].Object !;
writer.WriteSurrogateCharEntity(chars[0], chars[1]);
break;
case XmlEventType.Base64:
bytes = (byte[])page[idxEvent].Object !;
writer.WriteBase64(bytes, 0, bytes.Length);
break;
case XmlEventType.BinHex:
bytes = (byte[])page[idxEvent].Object !;
writer.WriteBinHex(bytes, 0, bytes.Length);
break;
case XmlEventType.XmlDecl1:
if (rawWriter != null)
{
rawWriter.WriteXmlDeclaration((XmlStandalone)page[idxEvent].Object !);
}
break;
case XmlEventType.XmlDecl2:
if (rawWriter != null)
{
rawWriter.WriteXmlDeclaration(page[idxEvent].String1 !);
}
break;
case XmlEventType.StartContent:
if (rawWriter != null)
{
rawWriter.StartElementContent();
}
break;
case XmlEventType.EndElem:
if (rawWriter != null)
{
rawWriter.WriteEndElement(page[idxEvent].String1 !, page[idxEvent].String2 !, page[idxEvent].String3 !);
}
else
{
writer.WriteEndElement();
}
break;
case XmlEventType.FullEndElem:
if (rawWriter != null)
{
rawWriter.WriteFullEndElement(page[idxEvent].String1 !, page[idxEvent].String2 !, page[idxEvent].String3 !);
}
else
{
writer.WriteFullEndElement();
}
break;
case XmlEventType.Nmsp:
if (rawWriter != null)
{
rawWriter.WriteNamespaceDeclaration(page[idxEvent].String1 !, page[idxEvent].String2 !);
}
else
{
writer.WriteAttributeString("xmlns", page[idxEvent].String1 !, XmlReservedNs.NsXmlNs, page[idxEvent].String2);
}
break;
case XmlEventType.EndBase64:
if (rawWriter != null)
{
rawWriter.WriteEndBase64();
}
break;
case XmlEventType.Close:
writer.Close();
break;
case XmlEventType.Flush:
writer.Flush();
break;
case XmlEventType.Dispose:
((IDisposable)writer).Dispose();
break;
default:
Debug.Fail($"Unknown event: {page[idxEvent].EventType}");
break;
}
}
}
Debug.Fail("Unknown event should be added to end of event sequence.");
}
public override void Flush()
{
_writer.Flush();
}
public void Write(System.Xml.XmlWriter writer, System.Xml.XmlNamespaceManager namespaceManager)
{
XmlSerializerNamespaces nss = new XmlSerializerNamespaces();
if (namespaceManager != null)
{
foreach (string name in namespaceManager)
{
//xml and xmlns namespaces are added by default in namespaceManager.
//So we should ignore them
if (name != "xml" && name != "xmlns")
{
nss.Add(name, namespaceManager.LookupNamespace(name));
}
}
}
if (Namespaces != null && Namespaces.Count > 0)
{
XmlQualifiedName [] qnames = Namespaces.ToArray();
foreach (XmlQualifiedName qn in qnames)
{
nss.Add(qn.Name, qn.Namespace);
}
string p = String.Empty;
bool loop = true;
for (int idx = 1; loop; idx++)
{
loop = false;
foreach (XmlQualifiedName qn in qnames)
{
if (qn.Name == p)
{
p = "q" + idx;
loop = true;
break;
}
}
}
nss.Add(p, XmlSchema.Namespace);
}
if (nss.Count == 0)
{
// Add the xml schema namespace. (It is done
// only when no entry exists in Namespaces).
nss.Add("xs", XmlSchema.Namespace);
if (TargetNamespace != null && TargetNamespace.Length != 0)
{
nss.Add("tns", TargetNamespace);
}
}
XmlSchemaSerializer xser = new XmlSchemaSerializer();
XmlSerializerNamespaces backup = Namespaces;
try {
Namespaces = null;
xser.Serialize(writer, this, nss);
} finally {
Namespaces = backup;
}
writer.Flush();
}
public override void Flush()
{
_wrapped.Flush();
}
public override void Finished()
{
output.WriteEndElement(); // results
output.WriteEndElement(); // sparql
output.Flush();
}
public System.ServiceModel.Channels.Message ProcessInboundMessage(System.ServiceModel.Channels.Message m)
{
#if DEBUG
Trace.TraceInformation("Received message on transport...");
#endif
if (ListenConnector == null && OperationContext.Current.Host is WcfServiceHost)
{
ListenConnector = (OperationContext.Current.Host as WcfServiceHost).ConnectorHost;
}
if (ListenConnector != null) // In process
{
// Is this channel one way or two way?
if (!(OperationContext.Current.Channel is IOutputChannel)) // Input only
{
return(null);
}
#if DEBUG
Trace.TraceInformation("Message handoff to WcfServerConnector completed");
#endif
WcfSendResult processResult = ListenConnector.ProcessMessage(m);
Message retVal = null;
// There is an error, so the return value must be a fault!
if (processResult == null || processResult.Code != ResultCode.Accepted && processResult.Code != ResultCode.AcceptedNonConformant)
{
// Web based context?
if (WebOperationContext.Current != null)
{
WebOperationContext.Current.OutgoingResponse.StatusCode = System.Net.HttpStatusCode.InternalServerError;
WebOperationContext.Current.OutgoingResponse.StatusDescription = "Internal Server Error";
}
List <String> details = new List <string>();
if (processResult != null)
{
details = new List <String>();
foreach (var dtl in processResult.Details)
{
details.Add(dtl.Message); // Append details
}
}
if (processResult == null)
{
retVal = Message.CreateMessage(m.Version, MessageFault.CreateFault(FaultCode.CreateReceiverFaultCode(processResult.Code.ToString(), "http://marc.mohawkcollege.ca/hi"), new FaultReason("The receiver has constructed an invalid response that cannot be sent to the sender"), details), m.Headers.Action);
}
else
{
retVal = Message.CreateMessage(m.Version, MessageFault.CreateFault(FaultCode.CreateSenderFaultCode("EPIC", "http://marc.mohawkcollege.ca/hi"), new FaultReason("Catastrophic failure occurred in the WcfServer send pipeline. This usually occurs when the connector does not receive a message in the allocated amount of time"), details), m.Headers.Action);
}
}
else
{
retVal = processResult.Message;
if (processResult.Headers != null)
{
retVal.Headers.Clear();
retVal.Headers.CopyHeadersFrom(processResult.Headers);
}
}
#if DEBUG
Trace.TraceInformation("Message sent to client");
#endif
return(retVal);
}
else
{
// Get settings
if (settings == null)
{
settings = System.Web.Configuration.WebConfigurationManager.GetSection("marc.everest.connectors.wcf") as MARC.Everest.Connectors.WCF.Configuration.ConfigurationSection;
}
// Now format the message and pass it on ...
MemoryStream ms = new MemoryStream();
System.Xml.XmlWriter xw = System.Xml.XmlWriter.Create(ms); // Write to message memory stream for classification matching
m.WriteMessage(xw);
xw.Flush(); // Flush the Xml Writer
ms.Seek(0, SeekOrigin.Begin); // Seek to start
XPathDocument xpd = new XPathDocument(ms); // load xpath document
XPathNavigator xpn = xpd.CreateNavigator();
IMessageReceiver receiver = null; // The receiver to use
// Determine the receiver
foreach (KeyValuePair <String, IMessageReceiver> kv in settings.Receiver)
{
if (xpn.SelectSingleNode(kv.Key) != null)
{
receiver = kv.Value;
break;
}
}
// Was a receiver found?
if (receiver == null)
{
// Create a not implemented exception
if (WebOperationContext.Current != null)
{
WebOperationContext.Current.OutgoingResponse.StatusCode = System.Net.HttpStatusCode.NotImplemented;
}
return(Message.CreateMessage(m.Version, MessageFault.CreateFault(FaultCode.CreateSenderFaultCode(
"NotImplemented", "http://marc.mohawkcollege.ca/hi"), new FaultReason("No receiver understands the request message.")),
m.Headers.Action));
}
// Create a streams for deserialization
ms = new MemoryStream();
XmlWriterSettings xws = new XmlWriterSettings();
xws.Indent = true;
xw = XmlWriter.Create(ms, xws);
// Deserialize body
WcfReceiveResult rcv = new WcfReceiveResult();
try
{
// Because of classification, we need to process this in a wierd way,
// Basically the formatter will classify the message based on the root element name
// it receives. Because a SOAP message's root isn't what we really want to process,
// the first child node under the 'body' must be passed to the xml writer
xpn.SelectSingleNode("//*[local-name() = 'Body']/child::node()").WriteSubtree(xw);
xw.Flush();
ms.Seek(0, SeekOrigin.Begin);
var serResult = settings.Formatter.Parse(ms);
rcv.Structure = serResult.Structure;
rcv.Details = serResult.Details;
if (rcv.Details.Count() == 0)
{
rcv.Code = ResultCode.Accepted;
}
else
{
rcv.Code = ResultCode.AcceptedNonConformant;
}
}
catch (Exception e)
{
rcv.Code = ResultCode.Error;
rcv.Details = new IResultDetail[] { new ResultDetail(ResultDetailType.Error, e.Message, e) };
}
// Process on the receiver
IGraphable obj = receiver.MessageReceived(rcv.Structure, rcv.Code, rcv.Details);
// Graph this back
XmlSerializerSurrogate surrogate = new XmlSerializerSurrogate((IXmlStructureFormatter)settings.Formatter);
// Serialize the response
Message result = Message.CreateMessage(m.Version, m.Headers.Action, obj, surrogate);
// Validate
surrogate.WriteObject(new MemoryStream(), obj);
// Surrogate result code is acceptable?
if (surrogate.ResultCode != ResultCode.Accepted && surrogate.ResultCode != ResultCode.AcceptedNonConformant)
{
if (WebOperationContext.Current != null)
{
WebOperationContext.Current.OutgoingResponse.StatusCode = System.Net.HttpStatusCode.InternalServerError;
WebOperationContext.Current.OutgoingResponse.StatusDescription = "Internal Server Error";
}
List <string> details = new List <String>();
foreach (var itm in surrogate.Details)
{
details.Add(itm.Message); // Append details
}
return(Message.CreateMessage(m.Version, MessageFault.CreateFault(FaultCode.CreateReceiverFaultCode(surrogate.ResultCode.ToString(), "http://marc.mohawkcollege.ca/hi"), new FaultReason("The receiver has constructed an invalid response that cannot be returned to the sender"), details), m.Headers.Action));
}
else
{
return(result);
}
}
}
private void click_Move(object sender, RoutedEventArgs e)
{
pp.IsOpen = false;
List <DB.Halls> Halls = (List <DB.Halls>)lv.ItemsSource;
if (((System.Windows.Controls.Button)sender).Tag + "" == "0")
{
FolderBrowserDialog fbd = new FolderBrowserDialog();
string Path = "";
fbd.Description = "Выберите папку для записи файла.";
if (fbd.ShowDialog() == System.Windows.Forms.DialogResult.OK)
{
Path = fbd.SelectedPath;
}
else
{
pp.IsOpen = true;
return;
}
switch (cbxFormat.SelectedIndex)
{
case 0:
{
List <string> strList = new List <string>();
foreach (var i in Halls)
{
strList.Add(i.ID + "" + ';' + i.Square + "" + ';' + i.Windows + ';' + i.Heating + ';' + i.Target + ';' + i.DepartmentID + ';' + i.BuildingID + ';' + i.ChiefID);
}
File.WriteAllLines(Path + @"\Exsport.csv", strList);
break;
}
case 1:
{
System.Xml.XmlWriter writer = System.Xml.XmlWriter.Create(Path + @"\Exsport.xml");
writer.WriteStartDocument();
writer.WriteStartElement("Halls");
foreach (var i in Halls)
{
writer.WriteStartElement("Hall");
writer.WriteElementString("ID", i.ID + "");
writer.WriteElementString("Square", i.Square + "");
writer.WriteElementString("Windows", i.Windows + "");
writer.WriteElementString("Heating", i.Heating + "");
writer.WriteElementString("Target", i.Target);
writer.WriteElementString("Department", i.DepartmentID + "");
writer.WriteElementString("Building", i.BuildingID + "");
writer.WriteElementString("Chief", i.ChiefID + "");
writer.WriteEndElement();
writer.Flush();
}
writer.WriteEndElement();
writer.WriteEndDocument();
writer.Close();
break;
}
case 2:
{
string connectionString = "Provider=Microsoft.Jet.OLEDB.4.0;Extended properties=Excel 8.0; User ID=;Password=;Data Source = " + Path + @"\Exsport.xls";
OleDbConnection conn = new OleDbConnection(connectionString);
conn.Open();
OleDbCommand cmd = new OleDbCommand();
cmd.Connection = conn;
cmd.CommandText = "CREATE TABLE [Halls] (ID VARCHAR, Square VARCHAR, Windows VARCHAR, Heating VARCHAR, Target VARCHAR, DepartmentID VARCHAR, BuildingID VARCHAR, ChiefID VARCHAR);";
cmd.ExecuteNonQuery();
foreach (var i in Halls)
{
cmd.CommandText = "INSERT INTO [Halls] (ID,Square,Windows,Heating,Target,DepartmentID,BuildingID,ChiefID) values ('" + i.ID + "', '" + i.Square + "', '" + i.Windows + "', '" + i.Heating + "', '" + i.Target + "', '" + i.DepartmentID + "', '" + i.BuildingID + "', '" + i.ChiefID + "')";
cmd.ExecuteNonQuery();
}
conn.Close();
break;
}
case 3:
{
string connectionString = "Provider=Microsoft.Jet.OLEDB.4.0;Extended properties=Excel 8.0; User ID=;Password=;Data Source = " + Path + @"\Exsport.xlsx";
OleDbConnection conn = new OleDbConnection(connectionString);
conn.Open();
OleDbCommand cmd = new OleDbCommand();
cmd.Connection = conn;
cmd.CommandText = "CREATE TABLE [Halls] (ID VARCHAR, Square VARCHAR, Windows VARCHAR, Heating VARCHAR, Target VARCHAR, DepartmentID VARCHAR, BuildingID VARCHAR, ChiefID VARCHAR);";
cmd.ExecuteNonQuery();
foreach (var i in Halls)
{
cmd.CommandText = "INSERT INTO [Halls] (ID,Square,Windows,Heating,Target,DepartmentID,BuildingID,ChiefID) values ('" + i.ID + "', '" + i.Square + "', '" + i.Windows + "', '" + i.Heating + "', '" + i.Target + "', '" + i.DepartmentID + "', '" + i.BuildingID + "', '" + i.ChiefID + "';";
cmd.ExecuteNonQuery();
}
conn.Close();
break;
}
}
System.Windows.MessageBox.Show("Экспорт совершён!", "Perfect", MessageBoxButton.OK, MessageBoxImage.Information);
}
else
{
switch (cbxFormat.SelectedIndex)
{
case 0:
{
if (System.Windows.MessageBox.Show("Для удачной записи файл должен быть следующего формата: |Square|Windows|Heating|Target|DepartmentID|BuildingID|ChiefID|. Продолжить? ", "Caution", MessageBoxButton.YesNo, MessageBoxImage.Warning) == MessageBoxResult.No)
{
pp.IsOpen = true;
return;
}
OpenFileDialog ofd = new OpenFileDialog();
ofd.Filter = "CSV|*.csv;";
if (ofd.ShowDialog() == System.Windows.Forms.DialogResult.Cancel)
{
pp.IsOpen = true;
return;
}
var csv = File.ReadAllLines(ofd.FileName);
int GoodCount = 0;
int BadCount = 0;
try
{
foreach (var i in csv)
{
var str = i.Split(';');
db.Halls.Add(new DB.Halls {
Square = double.Parse(str[0]),
Windows = int.Parse(str[1]),
Heating = int.Parse(str[2]),
Target = str[3],
DepartmentID = int.Parse(str[4]),
BuildingID = int.Parse(str[5]),
ChiefID = int.Parse(str[6])
});
}
db.SaveChanges();
GoodCount++;
}
catch
{
BadCount++;
}
string Message = "";
if (BadCount == 0)
{
Message = "Импорт прошёл успешно!";
}
else if (GoodCount != 0)
{
Message = "Импорт прошёл с некоторыми ошибками!";
}
else
{
Message = "Импорт не прошёл из-за появившихся ошибок!";
}
System.Windows.MessageBox.Show(Message, "Message", MessageBoxButton.OK, MessageBoxImage.Information);
break;
}
case 1:
{
if (System.Windows.MessageBox.Show("Для удачной записи в файле не должно быть поле 'ID'. Продолжить? ", "Caution", MessageBoxButton.YesNo, MessageBoxImage.Warning) == MessageBoxResult.No)
{
pp.IsOpen = true;
return;
}
OpenFileDialog ofd = new OpenFileDialog();
ofd.Filter = "XML|*.xml;";
if (ofd.ShowDialog() == System.Windows.Forms.DialogResult.Cancel)
{
pp.IsOpen = true;
return;
}
int GoodCount = 0;
int BadCount = 0;
XmlDocument doc = new XmlDocument();
doc.Load(ofd.FileName);
foreach (XmlNode i in doc.DocumentElement)
{
try
{
DB.Halls hall = new DB.Halls();
hall.ID = int.Parse(i["ID"].InnerText);
hall.Square = double.Parse(i["Square"].InnerText);
hall.Windows = int.Parse(i["Windows"].InnerText);
hall.Heating = int.Parse(i["Heating"].InnerText);
hall.Target = i["Target"].InnerText;
hall.DepartmentID = int.Parse(i["Department"].InnerText);
hall.BuildingID = HelpClasses.StaticClass.SelectBuilding.Kadastr;
hall.ChiefID = int.Parse(i["Chief"].InnerText);
db.Halls.Add(hall);
db.SaveChanges();
GoodCount++;
}
catch
{
BadCount++;
}
}
string Message = "";
if (BadCount == 0)
{
Message = "Импорт прошёл успешно!";
}
else if (GoodCount != 0)
{
Message = "Импорт прошёл с некоторыми ошибками!";
}
else
{
Message = "Импорт не прошёл из-за появившихся ошибок!";
}
System.Windows.MessageBox.Show(Message, "Message", MessageBoxButton.OK, MessageBoxImage.Information);
break;
}
case 2:
{
OpenFileDialog ofd = new OpenFileDialog();
ofd.Filter = "XLS|*.xls;";
if (ofd.ShowDialog() == System.Windows.Forms.DialogResult.Cancel)
{
pp.IsOpen = true;
return;
}
DataSet ds = new DataSet();
string connectionString = "Provider=Microsoft.Jet.OLEDB.4.0;Extended properties=Excel 8.0; User ID=;Password=;Data Source = " + ofd.FileName;
OleDbConnection conn = new OleDbConnection(connectionString);
conn.Open();
OleDbCommand cmd = new OleDbCommand();
cmd.Connection = conn;
DataTable dtHalls = conn.GetOleDbSchemaTable(OleDbSchemaGuid.Tables, null);
foreach (DataRow dr in dtHalls.Rows)
{
string hallName = dr["TABLE_NAME"].ToString();
if (!hallName.EndsWith("$"))
{
continue;
}
cmd.CommandText = "SELECT * FROM [" + hallName + "]";
DataTable dt = new DataTable();
dt.TableName = hallName;
OleDbDataAdapter da = new OleDbDataAdapter();
da.Fill(dt);
ds.Tables.Add(dt);
}
cmd = null;
conn.Close();
break;
}
}
click_Sort(null, null);
}
}
public override void Flush()
{
CheckAsync();
_coreWriter.Flush();
}
protected override void WriteTokenCore( XmlWriter writer, System.IdentityModel.Tokens.SecurityToken token )
{
if ( writer == null )
throw new ArgumentNullException( "writer" );
if ( token == null )
throw new ArgumentNullException( "token" );
var c = token as SecurityToken;
if ( c != null )
{
writer.WriteStartElement( Constants.UsernameTokenPrefix, Constants.UsernameTokenName, Constants.UsernameTokenNamespace );
writer.WriteAttributeString( Constants.WsUtilityPrefix, Constants.IdAttributeName, Constants.WsUtilityNamespace, token.Id );
writer.WriteElementString( Constants.UsernameElementName, Constants.UsernameTokenNamespace, c.Info.Username );
writer.WriteStartElement( Constants.UsernameTokenPrefix, Constants.PasswordElementName, Constants.UsernameTokenNamespace );
writer.WriteAttributeString( Constants.TypeAttributeName, Constants.PasswordDigestType );
writer.WriteValue( c.GetPasswordDigestAsBase64() );
writer.WriteEndElement();
writer.WriteElementString( Constants.NonceElementName, Constants.UsernameTokenNamespace, c.GetNonceAsBase64() );
writer.WriteElementString( Constants.CreatedElementName, Constants.WsUtilityNamespace, c.GetCreatedAsString() );
writer.WriteEndElement();
writer.Flush();
}
else
base.WriteTokenCore( writer, token );
}
/// <summary>
/// Saves the HTML document to the specified XmlWriter.
/// </summary>
/// <param name="writer">The XmlWriter to which you want to save.</param>
public void Save(XmlWriter writer)
{
DocumentNode.WriteTo(writer);
writer.Flush();
}
protected override void DoWriteComplete()
{
writer.Flush();
}
