public async Task <GameDetailsData> GetGameDetails(Season season, BoxScoreLink boxScoreLink)
{
var document = await _documentLoader.LoadDocument(_settings.ToDocumentOptions(season, boxScoreLink));
var lineScore = _lineScoreParser.Parse(document);
var homeBoxScore = _teamBoxScoreParser.Parse(document, lineScore.HomeTeam);
var visitorBoxScore = _teamBoxScoreParser.Parse(document, lineScore.VisitorTeam);
return(new GameDetailsData(lineScore.HomeTeam, lineScore.VisitorTeam, boxScoreLink.GameDate, boxScoreLink.GameId, lineScore, homeBoxScore, visitorBoxScore));
}
public virtual CaptureResponse Capture(XDocument xmlDocument)
{
var startDate = SystemContext.Clock.Now;
_documentValidator.Validate(xmlDocument);
var events = _documentParser.Parse(xmlDocument.Root);
var currentUser = _userProvider.GetCurrentUser();
var request = new EpcisRequest
{
RecordTime = SystemContext.Clock.Now,
DocumentTime = DateTime.Parse(xmlDocument.Root.Attribute("creationDate").Value),
User = currentUser
};
foreach (var @event in events)
{
request.AddEvent(@event);
}
_requestPersister.Persist(request);
return(new CaptureResponse
{
EventCount = request.Events.Count,
CaptureStartDateUtc = startDate,
CaptureEndDateUtc = SystemContext.Clock.Now,
EventIds = request.Events.Select(e => e.Id.ToString()).ToArray()
});
}
//Parse document(option=['document'->.docx, .pdf] or ['txt'->.txt])
//Removes punctuation and returns the words of the document in an array of strings
public string[] GetText(string path, string option)
{
string text = null;
try
{
ParserContext context = new ParserContext(path);
if (option.Equals("txt"))
{
ITextParser parser = ParserFactory.CreateText(context);
text = parser.Parse().ToString().ToLower().Replace('\n', ' ').Replace('\r', ' ')
.Replace('\t', ' ');
}
else if (option.Equals("document"))
{
IDocumentParser parser = ParserFactory.CreateDocument(context);
text = parser.Parse().ToString().ToLower().Replace('\n', ' ').Replace('\r', ' ')
.Replace('\t', ' ');
}
}
catch (Exception e)
{
Console.WriteLine("Exception found");
Console.WriteLine(e.Message);
}
text = RemovePunctuation(text);
string[] words = text.Split(default(Char[]), StringSplitOptions.RemoveEmptyEntries);
return(words);
}
private void FillData(Dictionary <string, object> dict, TextAsset[] texts, CultureInfo cultureInfo)
{
try
{
if (texts == null || texts.Length <= 0)
{
return;
}
foreach (TextAsset text in texts)
{
try
{
using (MemoryStream stream = new MemoryStream(text.bytes))
{
var data = parser.Parse(stream, cultureInfo);
foreach (KeyValuePair <string, object> kv in data)
{
dict[kv.Key] = kv.Value;
}
}
}
catch (Exception e)
{
if (log.IsWarnEnabled)
{
log.WarnFormat("An error occurred when loading localized data from \"{0}\".Error:{1}", text.name, e);
}
}
}
}
catch (Exception) { }
}
private void FillData(Dictionary <string, object> dict, TextAsset[] texts)
{
try
{
if (texts == null || texts.Length <= 0)
{
return;
}
foreach (TextAsset text in texts)
{
try
{
using (MemoryStream stream = new MemoryStream(text.bytes))
{
var data = parser.Parse(stream);
foreach (KeyValuePair <string, object> kv in data)
{
dict[kv.Key] = kv.Value;
}
}
}
catch (Exception e)
{
if (log.IsWarnEnabled)
{
log.WarnFormat("{0}", e);
}
}
}
}
catch (Exception) { }
}
private void FillData(Dictionary <string, object> dict, AssetBundle bundle, List <string> paths, CultureInfo cultureInfo)
{
try
{
if (paths == null || paths.Count <= 0)
{
return;
}
foreach (string path in paths)
{
try
{
TextAsset text = bundle.LoadAsset <TextAsset>(path);
using (MemoryStream stream = new MemoryStream(text.bytes))
{
var data = parser.Parse(stream, cultureInfo);
foreach (KeyValuePair <string, object> kv in data)
{
dict[kv.Key] = kv.Value;
}
}
}
catch (Exception e)
{
if (log.IsWarnEnabled)
{
log.WarnFormat("{0}", e);
}
}
}
}
catch (Exception) { }
}
private void FillData(Dictionary <string, object> dict, AssetBundle bundle, List <string> paths)
{
try
{
if (paths == null || paths.Count <= 0)
{
return;
}
foreach (string path in paths)
{
try
{
TextAsset text = bundle.LoadAsset <TextAsset>(path);
using (MemoryStream stream = new MemoryStream(text.bytes))
{
var data = parser.Parse(stream);
foreach (KeyValuePair <string, object> kv in data)
{
dict[kv.Key] = kv.Value;
}
}
}
catch (Exception e)
{
if (log.IsWarnEnabled)
{
log.WarnFormat("An error occurred when loading localized data from \"{0}\".Error:{1}", path, e);
}
}
}
}
catch (Exception) { }
}
public void Load(CultureInfo cultureInfo, Action <Dictionary <string, object> > onCompleted)
{
Dictionary <string, object> dict = new Dictionary <string, object> ();
TextAsset[] defaultTexts = Resources.LoadAll <TextAsset> (GetDefaultPath());
TextAsset[] texts = Resources.LoadAll <TextAsset> (GetPath(cultureInfo.Name)); //eg:zh-CN en-US
if (texts == null || texts.Length == 0)
{
texts = Resources.LoadAll <TextAsset> (GetPath(cultureInfo.TwoLetterISOLanguageName)); //eg:zh en
}
if ((defaultTexts == null || defaultTexts.Length <= 0) && (texts == null || texts.Length <= 0))
{
if (onCompleted != null)
{
onCompleted(dict);
}
return;
}
foreach (TextAsset text in defaultTexts)
{
using (MemoryStream stream = new MemoryStream(text.bytes)) {
var data = parser.Parse(stream);
foreach (KeyValuePair <string, object> kv in data)
{
dict [kv.Key] = kv.Value;
}
}
}
foreach (TextAsset text in texts)
{
using (MemoryStream stream = new MemoryStream(text.bytes)) {
var data = parser.Parse(stream);
foreach (KeyValuePair <string, object> kv in data)
{
dict [kv.Key] = kv.Value;
}
}
}
if (onCompleted != null)
{
onCompleted(dict);
}
}
public async Task <MonthlyGameResultsData> GetSchedule(Season season, Month month)
{
var document = await _documentLoader.LoadDocument(_settings.ToDocumentOptions(season, month));
var gameResults = _gameResultsParser.Parse(document);
return(new MonthlyGameResultsData(gameResults));
}
public void Parse(IDocumentParser parser, string file)
{
Parser = parser.GetType().Name;
parser.Parse(file, this);
if (!DocumentDate.HasValue)
{
DocumentDate = DateTime.Now;
}
}
public async Task <TeamData> GetTeamData(Team team, Season season)
{
var document = await _documentLoader.LoadDocument(_settings.ToDocumentOptions(team, season));
var rooster = _teamRoosterParser.Parse(document);
var playerSeasonStatistics = _playerSeasonStatisticsParser.Parse(document);
var playByPlay = _playByPlayParser.Parse(document);
var teamMisc = _teamMiscParser.Parse(document);
return(new TeamData(teamMisc, rooster, playerSeasonStatistics, playByPlay));
}
public async Task <ActionResult <Document[]> > Process([FromBody] FileRequest request)
{
if (request.FileData.Data.Length <= 0)
{
return(StatusCode(500, "No file data"));
}
var parsingResult = await documentParser.Parse(request.FileData.Name, request.FileData.Data, CancellationToken.None).ConfigureAwait(false);
var documents = await extractor.Extract(request.Header.Domain, parsingResult.Document).ConfigureAwait(false);
return(Ok(documents));
}
public void TestParseSimpleDocumentFromWord()
{
ParserContext context = new ParserContext(TestDataSample.GetWordPath("SampleDoc.docx"));
IDocumentParser parser = ParserFactory.CreateDocument(context);
ToxyDocument doc = parser.Parse();
Assert.AreEqual(7, doc.Paragraphs.Count);
Assert.AreEqual("I am a test document", doc.Paragraphs[0].Text);
Assert.AreEqual("This is page 1", doc.Paragraphs[1].Text);
Assert.AreEqual("I am Calibri (Body) in font size 11", doc.Paragraphs[2].Text);
Assert.AreEqual("\n", doc.Paragraphs[3].Text);
Assert.AreEqual("This is page two", doc.Paragraphs[4].Text);
Assert.AreEqual("It’s Arial Black in 16 point", doc.Paragraphs[5].Text);
Assert.AreEqual("It’s also in blue", doc.Paragraphs[6].Text);
}
public void TestParseDocumentWithTable()
{
ParserContext context = new ParserContext(TestDataSample.GetWordPath("simple-table.docx"));
IDocumentParser parser = ParserFactory.CreateDocument(context);
ToxyDocument doc = parser.Parse();
Assert.AreEqual(8, doc.Paragraphs.Count);
Assert.AreEqual("This is a Word document that was created using Word 97 – SR2. It contains a paragraph, a table consisting of 2 rows and 3 columns and a final paragraph.",
doc.Paragraphs[0].Text);
Assert.AreEqual("This text is below the table.", doc.Paragraphs[1].Text);
Assert.AreEqual("Cell 1,1", doc.Paragraphs[2].Text);
Assert.AreEqual("Cell 1,2", doc.Paragraphs[3].Text);
Assert.AreEqual("Cell 1,3", doc.Paragraphs[4].Text);
Assert.AreEqual("Cell 2,1", doc.Paragraphs[5].Text);
Assert.AreEqual("Cell 2,2", doc.Paragraphs[6].Text);
Assert.AreEqual("Cell 2,3", doc.Paragraphs[7].Text);
}
public async Task <ActionResult <AnomalyResult> > Process([FromBody] FileRequest request)
{
if (request.FileData.Data.Length <= 0)
{
return(StatusCode(500, "No file data"));
}
var parsingResult = await documentParser.Parse(request.FileData.Name, request.FileData.Data, CancellationToken.None).ConfigureAwait(false);
var documents = await extractor.Extract(request.Header.Domain, parsingResult.Document).ConfigureAwait(false);
var result = await anomalyDetection.RemoveAnomaly(request.Header, documents).ConfigureAwait(false);
var rating = RatingData.Accumulate(result.Sentences.Select(item => item.CalculateSentiment()));
return(Ok(new AnomalyResult {
Document = result, Sentiment = rating.RawRating
}));
}
public ServiceResult <DocumentUploadResponseDto> AnalyzeDocument(string fileFullPath)
{
var result = new DocumentUploadResponseDto();
result.FilePath = fileFullPath;
var serviceResult = new ServiceResult <DocumentUploadResponseDto>();
try
{
result.FilePath = fileFullPath;
if (fileFullPath.IsDocumentExtension())
{
IDocumentParser parser = GetDocumentParser(fileFullPath);
var parsedDoc = parser.Parse();
var stringParser = new StringParser(parsedDoc.ToString());
result.PageCount = parsedDoc.TotalPageNumber;
result.CharCountWithSpaces = stringParser.GenerateCharacterCount();
result.CharCount = stringParser.GenerateCharacterCount(withoutWhitespaces: true);
}
else
{
ITextParser parser = GetTextParser(fileFullPath);
var parsedDoc = parser.Parse();
var stringParser = new StringParser(parsedDoc);
result.PageCount = 1;
result.CharCountWithSpaces = stringParser.GenerateCharacterCount();
result.CharCount = stringParser.GenerateCharacterCount(withoutWhitespaces: true);
}
serviceResult.ServiceResultType = ServiceResultType.Success;
serviceResult.Data = result;
} catch (Exception exc) {
serviceResult.Exception = exc;
serviceResult.ServiceResultType = ServiceResultType.Fail;
_logger.Error($"Error occured in {MethodBase.GetCurrentMethod().Name} with exception message {exc.Message} and inner exception {exc.InnerException?.Message}");
}
return(serviceResult);
}
private void TimerTick(object sender, EventArgs e)
{
if (MarkpadDocument == null)
{
return;
}
timer.Stop();
Task.Factory.StartNew(text => documentParser.Parse(text.ToString()), Document.Text)
.ContinueWith(s =>
{
if (s.IsFaulted)
{
Log.Error(s.Exception);
return;
}
var result = MarkpadDocument.ConvertToAbsolutePaths(s.Result);
Render = result;
UpdateWordCount();
}, TaskScheduler.FromCurrentSynchronizationContext());
}
public string ExtractText(string filePath, string extension)
{
ParserContext c = new ParserContext(filePath);
try
{
IDocumentParser parser = ParserFactory.CreateDocument(c);
ToxyDocument result = parser.Parse();
return(result.ToString());
}
catch (InvalidDataException)
{
Console.Error.WriteLine($"'{filePath}' is supported but don't have the required extension.");
var newFilePath = $"{filePath}.{extension}";
Console.Error.WriteLine($"Creating a copy in '{newFilePath}' and using that to read.");
File.Copy(filePath, newFilePath);
return(ExtractText(newFilePath, extension));
}
catch (Exception e)
{
Console.Error.WriteLine("{0} Exception caught error with {1}.", e, filePath);
return(null);
}
}
public virtual IEnumerable <string> Capture(XDocument xmlDocument)
{
_documentValidator.Validate(xmlDocument);
var events = _documentParser.Parse(xmlDocument.Root);
var currentUser = _userProvider.GetCurrentUser();
var request = new EpcisRequest
{
RecordTime = SystemContext.Clock.Now,
DocumentTime = DateTime.Parse(xmlDocument.Root.Attribute("creationDate").Value),
SubscriptionId = TryExtractSubscriptionId(xmlDocument),
User = currentUser
};
foreach (var @event in events)
{
request.AddEvent(@event);
}
_requestPersister.Persist(request);
return(request.Events.Select(e => e.Id.ToString()));
}
protected virtual async Task FillData(Dictionary <string, object> dict, IList <IResourceLocation> paths, CultureInfo cultureInfo)
{
try
{
if (paths == null || paths.Count <= 0)
{
return;
}
var result = Addressables.LoadAssetsAsync <TextAsset>(paths, null);
IList <TextAsset> texts = await result;
foreach (TextAsset text in texts)
{
try
{
using (MemoryStream stream = new MemoryStream(text.bytes))
{
var data = parser.Parse(stream, cultureInfo);
foreach (KeyValuePair <string, object> kv in data)
{
dict[kv.Key] = kv.Value;
}
}
}
catch (Exception e)
{
if (log.IsWarnEnabled)
{
log.WarnFormat("An error occurred when loading localized data from \"{0}\".Error:{1}", text.name, e);
}
}
}
Addressables.Release(result);
}
catch (Exception) { }
}
IEnumerator DoLoad(CultureInfo cultureInfo, Action <Dictionary <string, object> > onCompleted)
{
Dictionary <string, object> dict = new Dictionary <string, object> ();
using (WWW www = new WWW(this.assetBundleUrl)) {
while (!www.isDone)
{
yield return(null);
}
AssetBundle bundle = www.assetBundle;
List <string> assetNames = new List <string> (bundle.GetAllAssetNames());
List <string> defaultPaths = assetNames.FindAll(p => p.Contains("/default/"));
List <string> paths = assetNames.FindAll(p => p.Contains(string.Format("/{0}/", cultureInfo.Name)));
if (paths == null || paths.Count <= 0)
{
paths = assetNames.FindAll(p => p.Contains(string.Format("/{0}/", cultureInfo.TwoLetterISOLanguageName)));
}
if ((defaultPaths == null || defaultPaths.Count <= 0) && (paths == null || paths.Count <= 0))
{
if (onCompleted != null)
{
onCompleted(dict);
}
yield break;
}
foreach (string path in defaultPaths)
{
TextAsset text = bundle.LoadAsset <TextAsset> (path);
using (MemoryStream stream = new MemoryStream(text.bytes)) {
var data = parser.Parse(stream);
foreach (KeyValuePair <string, object> kv in data)
{
dict [kv.Key] = kv.Value;
}
}
}
foreach (string path in paths)
{
TextAsset text = bundle.LoadAsset <TextAsset> (path);
using (MemoryStream stream = new MemoryStream(text.bytes)) {
var data = parser.Parse(stream);
foreach (KeyValuePair <string, object> kv in data)
{
dict [kv.Key] = kv.Value;
}
}
}
bundle.Unload(true);
if (onCompleted != null)
{
onCompleted(dict);
}
}
}
