/// <summary>
/// Обработчик события изменения элемента списка
/// Считываем данные по файлу из списка.
/// </summary>
private void listBoxDocuments_SelectedIndexChanged(object sender, EventArgs e)
{
var listBox = (ListBox)sender;
//Проверяем, чтобы список был не пустой
if (listBox.Items == null || listBox.Items.Count == 0 || listBox.SelectedItem == null)
{
return;
}
var value = listBox.SelectedItem.ToString();
var path = GetFullPathStoryFileByFileName(value);
//Получаем расширение из имени файла
HelperFileName.ParsePath(path, out var _, out var __, out var ext);
//Получаем нужный объект для считывания документа (зависит от расширения)
IDocumentReader reader = HelperDocumentReader.CreateReader(ext);
if (reader == null)
{
this.TextContainerDocumentContent.TextField.Text = "Не удалось считать данные из документа!";
return;
}
reader.OpenDocument(path);
if (reader.ReadAllTextData(out var data))
{
this.TextContainerDocumentContent.TextField.Text = data;
}
reader.CloseDocument();
}
public override void InternalParse(Container container, IDocumentReader reader, Func <string, bool> predicate, ref List <string> buffer,
ref AttributeList attributes)
{
var match = PatternMatcher.Admonition.Match(reader.Line);
if (!match.Success)
{
throw new ArgumentException("not an admonition");
}
buffer.Add(match.Groups["text"].Value);
reader.ReadLine();
while (reader.Line != null && !PatternMatcher.BlankCharacters.IsMatch(reader.Line))
{
buffer.Add(reader.Line);
reader.ReadLine();
}
var admonition = new Admonition(match.Groups["style"].Value.ToEnum <AdmonitionStyle>());
admonition.Attributes.Add(attributes);
ProcessParagraph(admonition, ref buffer);
container.Add(admonition);
attributes = null;
reader.ReadLine();
}
public void Parse(
Container container,
IDocumentReader reader,
Func <string, bool> predicate,
ref List <string> buffer,
ref AttributeList attributes)
{
var match = PatternMatcher.Anchor.Match(reader.Line);
if (!match.Success)
{
throw new ArgumentException("not an anchor");
}
var id = match.Groups["id"].Value;
var reference = !string.IsNullOrEmpty(match.Groups["reference"].Value)
? match.Groups["reference"].Value
: null;
var anchor = new Anchor(id, reference);
if (attributes != null)
{
attributes.Add(anchor);
}
else
{
attributes = new AttributeList {
anchor
};
}
reader.ReadLine();
}
public static async Task <TView> GetOrNewAsync <TView>(this IDocumentReader <unit, TView> reader)
where TView : new()
{
var entityMaybe = await reader.GetAsync(unit.it).ConfigureAwait(false);
return(entityMaybe.GetValue(new TView()));
}
/* ----------------------------------------------------------------- */
///
/// Save
///
/// <summary>
/// Saves the PDF document to the specified file path.
/// </summary>
///
/// <param name="src">Source reader.</param>
/// <param name="options">Save options.</param>
/// <param name="prev">Action to be invoked before saving.</param>
/// <param name="next">Action to be invoked after saving.</param>
///
/* ----------------------------------------------------------------- */
public void Save(IDocumentReader src, SaveOption options, Action <Entity> prev, Action <Entity> next) => Invoke(() =>
{
Value.Set(Properties.Resources.MessageSaving, options.Destination);
var itext = src ?? Value.Source.GetItext(Value.Query, Value.IO, false);
Value.Set(itext.Metadata, itext.Encryption);
using (var dest = new SaveAction(itext, Value.Images, options)) dest.Invoke(prev, next);
});
private void Parse(Container parent, IDocumentReader reader, Regex delimiterRegex)
{
var buffer = new List <string>(8);
AttributeList attributes = null;
DescendingParse(parent, reader, delimiterRegex.IsMatch, ref buffer, ref attributes);
}
public override void Read(IDocumentReader reader)
{
if (!CanOpenContent)
return;
using (Stream str = m_fileData.BinaryFileData.AsStream())
{
EmailFormatHandler handler = EmailFormatHandler.ReadEmail(str);
if (null == handler)
return;
bool cancel = false;
reader.OnContentData("Subject", handler.Subject, ref cancel);
if (Utils.IsStringHTML(handler.Body))
{
byte[] bytes = Encoding.Unicode.GetBytes(handler.Body);
ReadContent(reader, new HtmlReader(bytes));
}
else
reader.OnContentData("Body", handler.Body, ref cancel);
foreach (string attachment in handler)
{
reader.OnContentData("Attachments", attachment, ref cancel);
}
}
}
public override void InternalParse(Container container, IDocumentReader reader, Func <string, bool> predicate, ref List <string> buffer,
ref AttributeList attributes)
{
var match = PatternMatcher.Title.Match(reader.Line);
if (!match.Success)
{
throw new ArgumentException("not a block title");
}
var title = new Title(match.Groups["title"].Value);
if (attributes != null)
{
attributes.Add(title);
}
else
{
attributes = new AttributeList {
title
}
};
reader.ReadLine();
}
}
public AddQuestionProcessor(IDocumentReader <QuestionDto> reader, IDocumentWriter <QuestionDto> writer)
{
_reader = reader;
_writer = writer;
_dtoParser = new QuestionDtoParser();
_domainValidator = new DomainValidator();
}
public HashSet <string> Process(IDocumentReader reader)
{
var res = new HashSet <string>();
while (!reader.EndOfFile())
{
var line = reader.ReadLine().ToLower();
if (line != string.Empty)
{
//split line into sentences
var sent = textProcessor.GetSentences(line);
foreach (var s in sent)
{
//tokenize
var toks = textProcessor.Tokenize(s);
foreach (var t in toks)
{
//add full word
if (!res.Contains(t) && !stopwords.Exists(t))
{
res.Add(t);
}
//add stemmed word
var st = textProcessor.Stem(t);
if (!res.Contains(st) && !stopwords.Exists(st))
{
res.Add(st);
}
}
}
}
}
return(res);
}
public static bool IsErrorsDocument(this IDocumentReader documentReader)
{
Contract.Requires(documentReader != null);
var documentType = documentReader.GetDocumentType();
return(documentType.IsErrorsDocument());
}
public override void InternalParse(Container container, IDocumentReader reader, Func <string, bool> predicate, ref List <string> buffer,
ref AttributeList attributes)
{
var match = PatternMatcher.Include.Match(reader.Line);
if (!match.Success)
{
throw new ArgumentException("not an include");
}
var include = new Include(match.Groups["path"].Value);
var attributesValue = match.Groups["attributes"].Value;
if (!string.IsNullOrEmpty(attributesValue))
{
var attributeValues = SplitOnCharacterOutsideQuotes(attributesValue);
foreach (var attributeValue in attributeValues)
{
var attributeMatch = PatternMatcher.AttributeNameValue.Match(attributeValue);
if (attributeMatch.Success)
{
switch (attributeMatch.Groups["name"].Value.ToLowerInvariant())
{
case "leveloffset":
if (int.TryParse(attributeMatch.Groups["value"].Value, out var offset))
{
include.LevelOffset = offset;
}
break;
case "lines":
include.Lines = attributeMatch.Groups["value"].Value;
break;
case "tag":
case "tags":
include.Tags = attributeMatch.Groups["value"].Value;
break;
case "indent":
if (int.TryParse(attributeMatch.Groups["value"].Value, out var indent))
{
include.Indent = indent;
}
break;
default:
throw new NotImplementedException("TODO: add attribute to include attribute list");
}
}
}
}
container.Add(include);
attributes = null;
reader.ReadLine();
}
public override void InternalParse(Container container, IDocumentReader reader, Func <string, bool> predicate, ref List <string> buffer,
ref AttributeList attributes)
{
var comment = new Comment(reader.Line.Substring(2));
container.Add(comment);
reader.ReadLine();
}
public static bool IsValidDocument(this IDocumentReader documentReader)
{
Contract.Requires(documentReader != null);
var documentType = documentReader.GetDocumentType();
var documentMeta = documentReader.GetDocumentMeta();
return(documentType.IsValidDocument(documentMeta));
}
public DocumentWriter(DocumentDbConfiguration docDbConfiguration, IDocumentReader <T> documentReader, ICollectionNameResolver collectionNameResolver)
{
_docDbConfiguration = docDbConfiguration;
_documentClient = new DocumentClient(new Uri(_docDbConfiguration.Endpoint), _docDbConfiguration.PrimaryKey);
_documentReader = documentReader;
_collectionNameResolver = collectionNameResolver;
_collectionName = _collectionNameResolver.Resolve(typeof(T));
Init().Wait();
}
public BufferedDocumentWriter(IDocumentReader <TKey, TEntity> reader, IDocumentWriter <TKey, TEntity> writer, IDocumentStrategy strategy)
{
this._reader = reader;
this._writer = writer;
this._strategy = strategy;
this._viewsCache = new ConcurrentDictionary <string, TEntity>();
this._viewsToDelete = new ConcurrentDictionary <string, bool>();
this._keys = new ConcurrentDictionary <string, TKey>();
}
public override void InternalParse(Container container, IDocumentReader reader, Func <string, bool> predicate, ref List <string> buffer,
ref AttributeList attributes)
{
var match = PatternMatcher.ElementAttribute.Match(reader.Line);
if (!match.Success)
{
throw new ArgumentException("not a block attribute");
}
var attributesValue = match.Groups["attributes"].Value.Trim();
if (attributes == null)
{
attributes = new AttributeList();
}
if (attributesValue.IndexOf(",", StringComparison.Ordinal) == -1)
{
switch (attributesValue)
{
case "float":
attributes.IsFloating = true;
reader.ReadLine();
return;
case "discrete":
attributes.IsDiscrete = true;
reader.ReadLine();
return;
default:
attributes.Add(ParseElementAttributesWithPosition(attributesValue, 0));
reader.ReadLine();
return;
}
}
var inputs = SplitOnCharacterOutsideQuotes(attributesValue);
if (inputs[0] == "quote" || inputs[0] == "verse")
{
for (var index = 0; index < inputs.Length; index++)
{
var i = inputs[index];
attributes.Add(new Attribute(i, true));
}
reader.ReadLine();
return;
}
var attributeLists = inputs.Select(ParseElementAttributesWithPosition);
attributes = attributeLists.Aggregate(attributes, (first, second) => first.Add(second));
reader.ReadLine();
}
/// <summary>
/// Parses text from <see cref="IDocumentReader"/> into an <see cref="Document"/>
/// </summary>
/// <param name="reader">The reader.</param>
/// <returns>An new instance of <see cref="Document"/></returns>
public Document Parse(IDocumentReader reader)
{
var document = new Document(reader.Path);
var buffer = new List <string>(8);
AttributeList attributes = null;
Parse(document, reader, null, ref buffer, ref attributes);
return(document);
}
/// <summary>
/// Gets the single CLR resource by resource identifier lookup.
/// </summary>
/// <typeparam name="TResource">Type of CLR resource to find.</typeparam>
/// <typeparam name="TResourceId">Type of CLR resource identifier.</typeparam>
/// <param name="clrResourceId">CLR resource identifier value to lookup the single CLR resource with.</param>
/// <returns>Returns the single CLR resource if found, null otherwise.</returns>
/// <exception cref="DocumentReadException">Is thrown if there are
/// multiple CLR resources with the same resource identifier for the given CLR resource type.</exception>
public static TResource GetResource <TResource, TResourceId>(this IDocumentReader documentReader, TResourceId clrResourceId)
where TResource : class
{
Contract.Requires(documentReader != null);
var clrResourceType = typeof(TResource);
var clrResource = (TResource)documentReader.GetResource(clrResourceType, clrResourceId);
return(clrResource);
}
/// <summary>
/// Gets the multiple CLR resources for the given CLR resource type.
/// </summary>
/// <typeparam name="TResource">Type of CLR resource to get.</typeparam>
/// <returns>Returns the LINQ-to-objects collection of CLR resources if they exist,
/// empty collection otherwise.</returns>
public static IEnumerable <TResource> GetResourceCollection <TResource>(this IDocumentReader documentReader)
where TResource : class
{
Contract.Requires(documentReader != null);
var clrResourceType = typeof(TResource);
var clrResourceCollection = documentReader.GetResourceCollection(clrResourceType).Cast <TResource>();
return(clrResourceCollection);
}
public static Maybe <TEntity> Get <TKey, TEntity>(this IDocumentReader <TKey, TEntity> self, TKey key)
{
TEntity entity;
if (self.TryGet(key, out entity))
{
return(entity);
}
return(Maybe <TEntity> .Empty);
}
public static Maybe <TSingleton> Get <TSingleton>(this IDocumentReader <unit, TSingleton> reader)
{
TSingleton singleton;
if (reader.TryGet(unit.it, out singleton))
{
return(singleton);
}
return(Maybe <TSingleton> .Empty);
}
/// <summary>
/// Gets the single CLR resource identifier for the given CLR resource type.
/// </summary>
/// <remarks>
/// The CLR based resource identifier can come from either a json:api resource object or
/// a resource identifier.
/// </remarks>
/// <typeparam name="TResource">Type of CLR resource to find.</typeparam>
/// <typeparam name="TResourceId">Type of CLR resource identifier.</typeparam>
/// <returns>Returns the single CLR resource identifier if it exists, null otherwise.</returns>
/// <exception cref="DocumentReadException">Is thrown if there are
/// multiple CLR resource identifiers for the given CLR resource type.</exception>
public static TResourceId GetResourceId <TResource, TResourceId>(this IDocumentReader documentReader)
where TResource : class, IResource
{
Contract.Requires(documentReader != null);
var clrResourceType = typeof(TResource);
var clrResourceId = documentReader.GetResourceId <TResourceId>(clrResourceType);
return(clrResourceId);
}
/// <summary>
/// Gets the single resource or resource identifier json:api meta object for the given CLR resource type.
/// </summary>
/// <typeparam name="TResource">Type of CLR resource or resource identifier to get meta for.</typeparam>
/// <returns>Returns the single <c>Meta</c> object if the CLR resource or resource identifier exists, null otherwise.</returns>
/// <exception cref="DocumentReadException">Is thrown if there are
/// multiple CLR resources or resource identifiers for the given CLR resource type.</exception>
public static Meta GetResourceMeta <TResource>(this IDocumentReader documentReader)
where TResource : class, IResource
{
Contract.Requires(documentReader != null);
var clrResourceType = typeof(TResource);
var apiResourceMeta = documentReader.GetResourceMeta(clrResourceType);
return(apiResourceMeta);
}
/// <summary>
/// Gets the single resource json:api links object by resource identifier lookup.
/// </summary>
/// <typeparam name="TResource">Type of CLR resource.</typeparam>
/// <typeparam name="TResourceId">Type of CLR resource identifier.</typeparam>
/// <param name="clrResourceId">CLR resource identifier value to lookup the single json:api links object with.</param>
/// <returns>Returns the single json:api links object if found, null otherwise.</returns>
/// <exception cref="DocumentReadException">Is thrown if there are
/// multiple CLR resources with the same resource identifier for the given CLR resource type.</exception>
public static Links GetResourceLinks <TResource, TResourceId>(this IDocumentReader documentReader, TResourceId clrResourceId)
where TResource : class, IResource
{
Contract.Requires(documentReader != null);
var clrResourceType = typeof(TResource);
var apiResourceLinks = documentReader.GetResourceLinks(clrResourceType, clrResourceId);
return(apiResourceLinks);
}
public CountIt(IDocumentReader documentReader, IDocumentDictionary documentDictionary,
IView userView, IWordEncoder wordEncoder, IWordFilter[] filters, IWordFormatter[] formatters)
{
_documentReader = documentReader;
_documentDictionary = documentDictionary;
_userView = userView;
_wordEncoder = wordEncoder;
_filters = filters;
_formatters = formatters;
}
/// <summary>
/// Gets all resource json:api links objects for the given CLR resource type.
/// </summary>
/// <typeparam name="TResource">Type of CLR resource or resource identifier to get links collection for.</typeparam>
/// <returns>Collection of <c>Links</c> objects in document order.</returns>
public static IEnumerable <Links> GetResourceLinksCollection <TResource>(this IDocumentReader documentReader)
where TResource : class, IResource
{
Contract.Requires(documentReader != null);
var clrResourceType = typeof(TResource);
var apiResourceLinksCollection = documentReader.GetResourceLinksCollection(clrResourceType);
return(apiResourceLinksCollection);
}
/// <summary>
/// Gets the single resource json:api relationships object for the given CLR resource type.
/// </summary>
/// <typeparam name="TResource">Type of CLR resource or resource identifier to get relationships for.</typeparam>
/// <returns>Returns the single <c>Meta</c> object if the CLR resource exists, null otherwise.</returns>
/// <exception cref="DocumentReadException">Is thrown if there are
/// multiple CLR resources for the given CLR resource type.</exception>
public static Relationships GetResourceRelationships <TResource>(this IDocumentReader documentReader)
where TResource : class, IResource
{
Contract.Requires(documentReader != null);
var clrResourceType = typeof(TResource);
var apiResourceRelationships = documentReader.GetResourceRelationships(clrResourceType);
return(apiResourceRelationships);
}
public IEnumerable <FileExtension> Convert(string inputExtension, Stream inputStream, Dictionary <string, Stream> outputStreams)
{
IDocumentReader reader = ReaderCatalog.BestMatch(inputExtension);
if (reader == null)
{
return(Enumerable.Empty <FileExtension>());
}
(IDocumentWriter writer, Stream stream)[] writers = outputStreams.Select(e => (WriterCatalog.BestMatch(e.Key), e.Value)).ToArray();
public DocumentGenerator(string name, IDocumentReader reader, IDataGenerationJobService jobService,
IDocumentMetadataService metadataService, AnmatConfiguration configuration)
{
this.reader = reader;
this.jobService = jobService;
this.metadataService = metadataService;
this.configuration = configuration;
this.Name = name;
this.Metadata = this.GetMetadata();
}
/* ----------------------------------------------------------------- */
///
/// Restruct
///
/// <summary>
/// Restructs some properties with the specified new PDF document.
/// </summary>
///
/// <param name="src">Facade object.</param>
/// <param name="doc">New PDF document.</param>
///
/* ----------------------------------------------------------------- */
public static void Restruct(this MainFacade src, IDocumentReader doc)
{
var items = doc.Pages.Select((v, i) => new { Value = v, Index = i });
foreach (var e in items)
{
src.Bindable.Images[e.Index].RawObject = e.Value;
}
src.Bindable.Source.Value = doc.File;
src.Bindable.History.Clear();
}
public EventStoreToQueueDistributor(
string queueName,
IQueueFactory queueFactory,
IEventStore eventStore,
IDocumentStore projectionStore,
ISerializer serializer)
{
_markerReader = projectionStore.GetReader<string, EventStoreMarker>();
_markerWriter = projectionStore.GetWriter<string, EventStoreMarker>();
_queueName = queueName;
_eventStore = eventStore;
_queueWriter = queueFactory.CreateWriter(queueName);
_serializer = new QueueMessageSerializer(serializer);
}
public override void Read(IDocumentReader reader)
{
if (!CanOpenContent)
return;
foreach (IContainer container in Files)
{
IFile file = container as IFile;
if (null == file)
continue;
file.Read(reader);
}
}
private static void bulkTransfer(IDocumentReader reader, IDocumentWriter writer)
{
using (reader)
{
using (writer)
{
writer.Schema = reader.Schema;
while (reader.Read())
{
var doc = reader.Current;
writer.Write(doc);
}
}
}
}
public override void Read(IDocumentReader reader)
{
return;
// Just return, don't read the children of the folder. Same logic applies as
// with the ExpandContainer argument above.
// If we ever expose a folder type as file type in policy design then this must be revisited
// and the code below may be uncommented again. Laku 19/1/2009.
// PS: folder type removed from designer with this integration as well.
//if (!CanOpenContent)
// return;
//foreach (IContainer container in Files)
//{
// IFile file = container as IFile;
// if (null == file)
// continue;
// file.Read(reader);
//}
}
private static void HiddenSheet(IDocumentReader reader, string typeText, IAbstractTextType textType)
{
List<string> list = _typeList2List(textType);
foreach (string item in list)
{
string builtString = item;
reader.OnContentData(typeText, builtString, ref MetadataProcessor._cancel);
}
}
private static void AutoVersion(IDocumentReader reader, string typeText, IAbstractTextType textType)
{
string builtString = _typeList2String(textType);
reader.OnContentData(typeText, builtString, ref MetadataProcessor._cancel);
}
private static void DocumentStatistics(
IDocumentReader reader, string typeText, IAbstractTextType textType)
{
List<KeyValuePair<string, string>> pairList = _typeList2Pair("Name", "Value", textType);
try
{
for (int i = 0; i < pairList.Count; ++i)
{
KeyValuePair<string, string> pair = pairList[i];
string builtString = @"";
builtString += @"<" + typeText;
builtString += @" Name=""";
builtString += pair.Key;
builtString += @"""";
builtString += @" Value=""";
builtString += pair.Value;
builtString += @"""";
builtString += @" />";
reader.OnContentData(typeText, builtString, ref MetadataProcessor._cancel);
}
}
catch (System.Exception e)
{
Logger.LogError("Exception within MetadataProcessor::DocumentStatistics for " + typeText + ", " + textType);
Logger.LogError(e);
}
}
private static void RedactedText(IDocumentReader reader, string typeText, IAbstractTextType textType)
{
/*
textNode.GetInfo(0)
name: "Content"
type: String
value: "http://www.csub.edu/"
textNode.GetInfo(1)
name: "SheetName"
type: String
value: "Sheet1"
textNode.GetInfo(2)
name: "Row"
type: Long
value: "67"
textNode.GetInfo(3)
name: "Column"
type: Long
value: "1"
*/
for (int i = 0; i < textType.GetChildCount(); ++i)
{
IAbstractTextNode textNode = textType.GetChild(i);
string content = _nodeValueFromName(textNode, "Content");
string sheet = _nodeValueFromName(textNode, "SheetName");
string row = _nodeValueFromName(textNode, "Row");
string column = _nodeValueFromName(textNode, "Column");
StringBuilder builtString = new StringBuilder(@"");
builtString.Append(@"<" + typeText);
builtString.Append(@" Row=""");
builtString.Append(row);
builtString.Append(@"""");
builtString.Append(@" Column=""");
builtString.Append(column);
builtString.Append(@""">");
builtString.Append(@"<Content>");
builtString.Append(content);
builtString.Append(@"</Content>");
builtString.Append(@"<Sheet>");
builtString.Append(sheet);
builtString.Append(@"</Sheet>");
builtString.Append(@"</" + typeText + @">");
reader.OnContentData(typeText, builtString.ToString(), ref MetadataProcessor._cancel);
}
}
/// -----------------------------------------------------------------------------
public static void ProcessType(IDocumentReader reader, string typeText, IAbstractTextType textType)
{
try
{
switch (textType.GetContentType())
{
case ContentType.Paragraph:
MetadataProcessor.Paragraphs(reader, "Paragraph", textType);
break;
case ContentType.Header:
MetadataProcessor.Headers(reader, "Header", textType);
break;
case ContentType.Footer:
MetadataProcessor.Footers(reader, "Footer", textType);
break;
case ContentType.Comment:
MetadataProcessor.Comments(reader, "Comment", textType);
break;
case ContentType.TrackChange:
MetadataProcessor.TrackChanges(reader, "TrackChange", textType);
break;
case ContentType.Reviewer:
MetadataProcessor.Reviewers(reader, "Reviewer", textType);
break;
case ContentType.HiddenText:
MetadataProcessor.HiddenTexts(reader, "HiddenText", textType);
break;
case ContentType.SmallText:
MetadataProcessor.SmallTexts(reader, "SmallText", textType);
break;
case ContentType.WhiteText:
MetadataProcessor.WhiteTexts(reader, "WhiteText", textType);
break;
case ContentType.AttachedTemplate:
MetadataProcessor.AttachedTemplate(reader, "AttachedTemplate", textType);
break;
case ContentType.Version:
MetadataProcessor.Versions(reader, "Version", textType);
break;
case ContentType.AutoVersion:
MetadataProcessor.AutoVersion(reader, "AutoVersion", textType);
break;
case ContentType.Field:
MetadataProcessor.Fields(reader, "Field", textType);
break;
case ContentType.Hyperlink:
MetadataProcessor.HyperLinks(reader, "Hyperlink", textType);
break;
case ContentType.RoutingSlip:
MetadataProcessor.RoutingSlip(reader, "RoutingSlip", textType);
break;
case ContentType.Variable:
MetadataProcessor.Variables(reader, "Variable", textType);
break;
case ContentType.HiddenSlide:
MetadataProcessor.HiddenSlide(reader, "HiddenSlide", textType);
break;
case ContentType.SpeakerNote:
MetadataProcessor.SpeakerNote(reader, "SpeakerNote", textType);
break;
case ContentType.Links:
MetadataProcessor.Links(reader, "Link", textType);
break;
case ContentType.HiddenSheet:
MetadataProcessor.HiddenSheet(reader, "HiddenSheet", textType);
break;
case ContentType.HiddenRow:
MetadataProcessor.HiddenRow(reader, "HiddenRow", textType);
break;
case ContentType.HiddenColumn:
MetadataProcessor.HiddenColumn(reader, "HiddenColumn", textType);
break;
case ContentType.RedactedText:
MetadataProcessor.RedactedText(reader, "RedactedText", textType);
break;
case ContentType.CustomProperty:
MetadataProcessor.CustomProperties(reader, "CustomProperty", textType);
break;
case ContentType.Macro:
MetadataProcessor.Macros(reader, "Macro", textType);
break;
case ContentType.BuiltInProperty:
MetadataProcessor.BuildInProperties(reader, "BuiltInProperty", textType);
break;
case ContentType.DocumentStatistic:
MetadataProcessor.DocumentStatistics(reader, "DocumentStatistic", textType);
break;
case ContentType.Footnote:
case ContentType.Endnote:
MetadataProcessor.Footnotes(reader, "Footnote", textType);
break;
case ContentType.TextBox:
/// ProcessTextType(reader, "TextBox", textType);
break;
case ContentType.CellText:
//ProcessTextType(reader, "CellText", textType);
break;
case ContentType.WorkshareProperty:
/// ProcessTextType(reader, "WorkshareProperty", textType);
break;
case ContentType.SmartTag:
/// ProcessTextType(reader, "SmartTag", textType);
break;
case ContentType.WorkshareStyle:
MetadataProcessor.WhiteTexts(reader, "WorkshareStyle", textType);
break;
default:
/// throw new ApplicationException("Invalid Content Type in DocumentText! Enums out of date.");
break;
}
}
catch (System.Exception e)
{
Logger.LogError("Exception within MetadataProcessor::ProcessType for " + textType.GetContentType());
Logger.LogError(e);
}
}
public static void Paragraphs(IDocumentReader reader, string typeText, IAbstractTextType textType)
{
List<string> list = _typeList2List(textType);
foreach (string item in list)
{
if (!_isCommentOrParagraphMarker(item))
{
string builtString = _putCDataSection(item);
reader.OnContentData(typeText, builtString, ref MetadataProcessor._cancel);
}
}
}
public static void TrackChanges(IDocumentReader reader, string typeText, IAbstractTextType textType)
{
int trackChangeLimit = MetadataProcessor._TrackChangeLimit;
for (int i = 0; i < textType.GetChildCount() && i < trackChangeLimit; ++i)
{
IAbstractTextNode textNode = textType.GetChild(i);
string content = _nodeValueFromName(textNode, "Content");
string author = _nodeValueFromName(textNode, "Author");
string type = _nodeValueFromName(textNode, "Type");
if (!_isCommentOrParagraphMarker(content))
{
string builtString = @"";
builtString += @"<" + typeText;
builtString += @" Author=""";
builtString += author;
builtString += @"""";
builtString += @" Type=""";
builtString += type;
builtString += @""">";
builtString += _putCDataSection(content);
builtString += @"</" + typeText + @">";
reader.OnContentData(typeText, builtString, ref MetadataProcessor._cancel);
}
}
}
public static void WhiteTexts(IDocumentReader reader, string typeText, IAbstractTextType textType)
{
List<string> list = _typeList2List(textType);
try
{
foreach (string item in list)
{
if (!_isCommentOrParagraphMarker(item) && !_isCommentMarker(item))
{
string builtString = @"";
builtString += @"<" + typeText + @">";
builtString += _putCDataSection(item);
builtString += @"</" + typeText + @">";
reader.OnContentData(typeText, builtString, ref MetadataProcessor._cancel);
}
}
}
catch (System.Exception e)
{
Logger.LogError("Exception within MetadataProcessor::WhiteTexts for " + typeText + ", " + textType);
Logger.LogError(e);
}
}
public static void HiddenTexts(IDocumentReader reader, string typeText, IAbstractTextType textType)
{
try
{
for (int loopi = 0; loopi < textType.GetChildCount(); ++loopi)
{
IAbstractTextNode textNode = textType.GetChild(loopi);
string content = _nodeValueFromName(textNode, "Content");
if (!_isCommentOrParagraphMarker(content))
{
string builtString = @"";
builtString += @"<" + typeText;
for (int loopj = 0; loopj < textNode.GetInfoCount(); ++loopj)
{
NodeInfo nodeInfo = textNode.GetInfo(loopj);
string nodeValue = (nodeInfo != null) ? nodeInfo.value : "";
string nodeKey = (nodeInfo != null) ? nodeInfo.name : "";
if (!nodeKey.Equals("Content"))
{
builtString += @" ";
builtString += nodeKey;
builtString += @"=""";
builtString += nodeValue;
builtString += @"""";
}
}
builtString += @">";
builtString += _putCDataSection(content);
builtString += @"</" + typeText + @">";
reader.OnContentData(typeText, builtString, ref MetadataProcessor._cancel);
}
}
}
catch (System.Exception e)
{
Logger.LogError("Exception within MetadataProcessor::HiddenTexts for " + typeText + ", " + textType);
Logger.LogError(e);
}
}
private static void AttachedTemplate(IDocumentReader reader, string typeText, IAbstractTextType textType)
{
if (textType.GetChildCount() > 0)
{
IAbstractTextNode textNode = textType.GetChild(0);
string path = _nodeValueFromName(textNode, "Path");
string name = _nodeValueFromName(textNode, "Name");
string builtString = @"";
builtString += @"<" + typeText;
builtString += @" Name=""";
builtString += name;
builtString += @"""";
builtString += @" Path=""";
builtString += path;
builtString += @"""";
builtString += @" />";
reader.OnContentData(typeText, builtString, ref MetadataProcessor._cancel);
}
}
private static void Fields(IDocumentReader reader, string typeText, IAbstractTextType textType)
{
List<KeyValuePair<string, string>> pairList = _typeList2Pair("Instruction", "Content", textType);
try
{
for (int i = 0; i < pairList.Count; ++i)
{
KeyValuePair<string, string> pair = pairList[i];
// if (!_isCommentOrParagraphMarker(pair.Value))
if (!_isHyperlink(pair.Value)) // hyperlinks added separately
{
string builtString = @"";
builtString += @"<" + typeText;
builtString += @" Instruction=""";
builtString += pair.Key;
builtString += @""">";
builtString += pair.Value;
builtString += @"</" + typeText + @">";
reader.OnContentData(typeText, builtString, ref MetadataProcessor._cancel);
}
}
}
catch (System.Exception e)
{
Logger.LogError("Exception within MetadataProcessor::Fields for " + typeText + ", " + textType);
Logger.LogError(e);
}
}
private static void Macros(IDocumentReader reader, string typeText, IAbstractTextType textType)
{
List<string> list = _typeList2List(textType);
try
{
foreach (string item in list)
{
string builtString = item;
reader.OnContentData(typeText, builtString, ref MetadataProcessor._cancel);
}
}
catch (System.Exception e)
{
Logger.LogError("Exception within MetadataProcessor::Macros for " + typeText + ", " + textType);
Logger.LogError(e);
}
}
private static void HiddenColumn(IDocumentReader reader, string typeText, IAbstractTextType textType)
{
List<KeyValuePair<string, string>> pairList = _typeList2Pair("SheetName", "Column", textType);
for (int i = 0; i < pairList.Count; ++i)
{
KeyValuePair<string, string> pair = pairList[i];
string builtString = @"";
builtString += @"<" + typeText;
builtString += @" Column=""";
builtString += pair.Value;
builtString += @""">";
builtString += pair.Key;
builtString += @"</" + typeText + @">";
reader.OnContentData(typeText, builtString, ref MetadataProcessor._cancel);
}
}
/// <summary>
/// Converts a <see cref="IODocument"/> to a <see cref="CircuitDocument"/>.
/// </summary>
/// <param name="document">The IODocument to convert.</param>
/// <returns>A CircuitDocument constructed from the IODocument.</returns>
public static CircuitDocument ToCircuitDocument(this IODocument document, IDocumentReader reader, out List<IOComponentType> unavailableComponents)
{
CircuitDocument circuitDocument = new CircuitDocument();
circuitDocument.Size = document.Size;
// Set metadata
circuitDocument.Metadata = new CircuitDocumentMetadata(null, null, document.Metadata);
// Add components
unavailableComponents = new List<IOComponentType>();
foreach (IOComponent component in document.Components)
{
ComponentIdentifier identifier = null;
// Find description
if (component.Type.GUID != Guid.Empty && ComponentHelper.IsDescriptionAvailable(component.Type.GUID))
identifier = new ComponentIdentifier(ComponentHelper.FindDescription(component.Type.GUID));
if (identifier == null && reader.IsDescriptionEmbedded(component.Type))
identifier = LoadDescription(reader.GetEmbeddedDescription(component.Type), component.Type);
if (identifier == null && component.Type.IsStandard)
identifier = ComponentHelper.GetStandardComponent(component.Type.Collection, component.Type.Item);
if (identifier != null)
{
// Add full component
Dictionary<string, object> properties = new Dictionary<string,object>();
foreach(var property in component.Properties)
properties.Add(property.Key, property.Value);
Component addComponent = Component.Create(identifier, properties);
addComponent.Layout(component.Location.Value.X, component.Location.Value.Y, (component.Size.HasValue ? component.Size.Value : identifier.Description.MinSize), component.Orientation.Value, component.IsFlipped == true);
addComponent.ImplementMinimumSize(addComponent.Description.MinSize);
FlagOptions flagOptions = ComponentHelper.ApplyFlags(addComponent);
if ((flagOptions & FlagOptions.HorizontalOnly) == FlagOptions.HorizontalOnly && component.Orientation == Orientation.Vertical)
addComponent.Orientation = Orientation.Horizontal;
else if ((flagOptions & FlagOptions.VerticalOnly) == FlagOptions.VerticalOnly && component.Orientation == Orientation.Horizontal)
addComponent.Orientation = Orientation.Vertical;
circuitDocument.Elements.Add(addComponent);
}
else
{
// Add disabled component
if (!unavailableComponents.Contains(component.Type))
unavailableComponents.Add(component.Type);
DisabledComponent addComponent = new DisabledComponent();
Dictionary<string, object> properties = new Dictionary<string,object>();
foreach(var property in component.Properties)
addComponent.Properties.Add(property.Key, property.Value);
addComponent.ImplementationCollection = component.Type.Collection;
addComponent.ImplementationItem = component.Type.Item;
addComponent.Name = component.Type.Name;
addComponent.GUID = component.Type.GUID;
if (component.Location.HasValue)
addComponent.Location = new Vector(component.Location.Value.X, component.Location.Value.Y);
addComponent.Size = component.Size;
addComponent.Orientation = component.Orientation;
circuitDocument.DisabledComponents.Add(addComponent);
}
}
// Add wires
IOComponentType wireType = new IOComponentType("wire");
if (ComponentHelper.WireDescription == null)
{
unavailableComponents.Add(wireType);
}
else
{
foreach (IOWire wire in document.Wires)
{
Dictionary<string, object> properties = new Dictionary<string, object>(4);
properties.Add("@x", wire.Location.X);
properties.Add("@y", wire.Location.Y);
properties.Add("@orientation", wire.Orientation == Orientation.Horizontal);
properties.Add("@size", wire.Size);
Component wireComponent = Component.Create(ComponentHelper.WireDescription, properties);
wireComponent.Layout(wire.Location.X, wire.Location.Y, wire.Size, wire.Orientation, false);
wireComponent.ApplyConnections(circuitDocument);
circuitDocument.Elements.Add(wireComponent);
}
}
// Connections
foreach (Component component in circuitDocument.Components)
component.ApplyConnections(circuitDocument);
return circuitDocument;
}
private static void RoutingSlip(IDocumentReader reader, string typeText, IAbstractTextType textType)
{
for (int i = 0; i < textType.GetChildCount(); ++i)
{
IAbstractTextNode textNode = textType.GetChild(i);
string message = _nodeValueFromName(textNode, "Message");
string subject = _nodeValueFromName(textNode, "Subject");
string builtString = @"";
builtString += @"<" + typeText;
builtString += @" Message=""";
builtString += message;
builtString += @"""";
builtString += @" Subject=""";
builtString += subject;
builtString += @""">";
builtString += @"<Recipients>";
List<NodeInfo> nodeRecipients = textNode.GetInfo("Recipient");
List<string> recipients = new List<string>();
foreach (NodeInfo nodeRecipi in nodeRecipients)
{
builtString += @"<Recipient>";
builtString += nodeRecipi.value;
builtString += @"</Recipient>";
}
builtString += @"</Recipients>";
builtString += @"</" + typeText + @">";
reader.OnContentData(typeText, builtString, ref MetadataProcessor._cancel);
}
}
private static void Footnotes(IDocumentReader reader, string typeText, IAbstractTextType textType)
{
List<string> list = _typeList2List(textType);
foreach (string item in list)
{
if (!_isCommentOrParagraphMarker(item) && !_isCommentMarker(item))
{
string builtString = @"";
builtString += @"<" + typeText + @">";
builtString += _putCDataSection(item);
builtString += @"</" + typeText + @">";
reader.OnContentData(typeText, builtString, ref MetadataProcessor._cancel);
}
}
}
private static void Versions(IDocumentReader reader, string typeText, IAbstractTextType textType)
{
List<KeyValuePair<string, string>> pairList = _typeList2Pair("Saved By", "Comment", textType);
for (int i = 0; i < pairList.Count; ++i)
{
KeyValuePair<string, string> pair = pairList[i];
string builtString = @"";
builtString += @"<" + typeText;
builtString += @" SavedBy=""";
builtString += pair.Key;
builtString += @"""";
builtString += @" Comment=""";
builtString += pair.Value;
builtString += @"""";
builtString += @" />";
reader.OnContentData(typeText, builtString, ref MetadataProcessor._cancel);
}
MetadataProcessor.Authors(pairList);
}
public LoginIndexLookupService(IDocumentStore storeFactory)
{
if (storeFactory == null) throw new ArgumentNullException("storeFactory");
_reader = storeFactory.GetReader<byte, LoginIndexLookup>();
}
private static void HyperLinks(IDocumentReader reader, string typeText, IAbstractTextType textType)
{
/*
DOC
textNode.GetInfo(0)
name: "Content"
type: String
value: "HYPERLINK"
XLS
textNode.GetInfo(0)
name: "Description"
type: String
value: "www.bbc.co.uk/news"
textNode.GetInfo(1)
name: "Path"
type: String
value: "http://www.bbc.co.uk/news"
PPT
textNode.GetInfo(0)
name: "Content"
type: String
value: "HL 1"
textNode.GetInfo(1)
name: "Path"
type: String
value: "http://www.btyahoo.com/welcome2"
*/
/// List<KeyValuePair<string, string>> pairList = _typeList2Pair(textType);
for (int i = 0; i < textType.GetChildCount(); ++i)
{
IAbstractTextNode textNode = textType.GetChild(i);
string keyStr = textNode.GetInfo(0).name;
string valStr = (textNode.GetInfoCount() > 1) ?
textNode.GetInfo(1).value : textNode.GetInfo(0).value;
string builtString = @"";
builtString += @"<" + typeText;
builtString += @" Type=""";
builtString += keyStr;
builtString += @""">";
builtString += _putCDataSection(valStr);
builtString += @"</" + typeText + @">";
reader.OnContentData(typeText, builtString, ref MetadataProcessor._cancel);
}
}
public void Read(IDocumentReader reader)
{
throw new NotImplementedException();
}
private static void Links(IDocumentReader reader, string typeText, IAbstractTextType textType)
{
List<KeyValuePair<string, string>> pairList = _typeList2Pair("Type", "Path", textType);
for (int i = 0; i < pairList.Count; ++i)
{
KeyValuePair<string, string> pair = pairList[i];
string builtString = @"";
builtString += @"<" + typeText;
builtString += @" Type=""";
builtString += pair.Key;
builtString += @""">";
builtString += _putCDataSection(pair.Value);
builtString += @"</" + typeText + @">";
reader.OnContentData(typeText, builtString, ref MetadataProcessor._cancel);
}
}
private static void SpeakerNote(IDocumentReader reader, string typeText, IAbstractTextType textType)
{
List<KeyValuePair<string, string>> pairList = _typeList2Pair("SlideId", "SpeakerNote", textType);
for (int i = 0; i < pairList.Count; ++i)
{
KeyValuePair<string, string> pair = pairList[i];
reader.OnContentData(typeText, pair.Value, ref MetadataProcessor._cancel);
}
}
/// -----------------------------------------------------------------------------
private static void BuildInProperties(IDocumentReader reader, string typeText, IAbstractTextType textType)
{
try
{
List<KeyValuePair<string, string>> pairList = _typeList2Pair("Name", "Value", textType);
for (int i = 0; i < pairList.Count; ++i)
{
KeyValuePair<string, string> pair = pairList[i];
if (!_isCommentOrParagraphMarker(pair.Value))
{
string builtString = @"";
builtString += @"<" + typeText;
builtString += @" Name=""";
builtString += pair.Key;
builtString += @""">";
builtString += _putCDataSection(pair.Value);
builtString += @"</" + typeText + @">";
reader.OnContentData(typeText, builtString, ref MetadataProcessor._cancel);
}
}
}
catch (System.Exception e)
{
Logger.LogError("Exception within MetadataProcessor::BuildInProperties for " + typeText + ", " + textType);
Logger.LogError(e);
}
}
public UserGoalIndex(IDocumentReader<GoalId, UserGoalsView> reader)
{
_reader = reader;
}
private static void HiddenSlide(IDocumentReader reader, string typeText, IAbstractTextType textType)
{
// ppt we get "SlideId" and "Title"
List<KeyValuePair<string, string>> pairList = _typeList2Pair("SlideId", "Title", textType);
// pptx we get "SlideNumber" and "Content"
if (pairList.Count != 0)
CheckForPPTx(ref pairList, "SlideNumber", "Content", textType);
for (int i = 0; i < pairList.Count; ++i)
{
KeyValuePair<string, string> pair = pairList[i];
string builtString = @"";
builtString += @"<" + typeText;
builtString += @" SlideId=""";
builtString += pair.Key;
builtString += @""">";
builtString += _putCDataSection(pair.Value);
builtString += @"</" + typeText + @">";
reader.OnContentData(typeText, builtString, ref MetadataProcessor._cancel);
}
}
