public HomeController()
{
_parsingService = new ParsingService();
_configurationService = new ConfigurationService();
_summaryService = new SummaryService();
_deleteRecordService = new DeleteRecordService();
}
public void parsing_should_return_true()
{
var p = new ParsingService();
var s = p.ParseCsv("Id,Name\r\n1,Art\r\n2,Language\r\n3,Math\r\n4,Gym\r\n5,Science\r\n", true);
Assert.IsFalse(s == null);
}
private void buttonForceUpdate_Click(object sender, EventArgs e)
{
_databaseItemDao.Clean();
var mod = GetFirst(listViewMods);
var entry = GetFirst(listViewInstalls);
if (mod != null)
{
// Load selected mod icons
ThreadPool.QueueUserWorkItem((m) => ArzParser.LoadSelectedModIcons(mod.Path));
}
ForceDatabaseUpdate(entry.Path, mod?.Path);
_settingsService.GetLocal().CurrentGrimdawnLocation = entry.Path;
// Store the loaded GD path, so we can poll it for updates later.
//_settingsService.GetLocal().GrimDawnLocation = new List<string> { entry.Path }; // TODO: Wtf is this? Why overwrite any existing?
_settingsService.GetLocal().GrimDawnLocationLastModified = ParsingService.GetHighestTimestamp(entry.Path);
_settingsService.GetLocal().HasWarnedGrimDawnUpdate = false;
var isGdParsed = _databaseItemDao.GetRowCount() > 0;
_settingsService.GetLocal().IsGrimDawnParsed = isGdParsed;
_helpService.SetIsGrimParsed(isGdParsed);
}
internal static async Task <IMessage> ConvertGenericMessagesAsync(IGenericMessage genericMessage)
{
Ensure.ArgumentNotNull(nameof(genericMessage), genericMessage);
var concreteMessage = await MessageFactory.Instance.CreateAsync(genericMessage);
if (concreteMessage == null)
{
return(null);
}
var segmentArray = genericMessage.Children.ToArray();
for (var i = 1; i < segmentArray.Length; i++)
{
var concreteSegment = await SegmentFactory.Instance.CreateAsync(segmentArray[0]);
concreteSegment.MessageHeader = concreteMessage.MessageHeader;
}
foreach (var genericSegment in genericMessage.Children.ToList())
{
var segment = await SegmentFactory.Instance.CreateAsync(genericSegment);
segment.MessageHeader = concreteMessage.MessageHeader;
ParsingService.UpdateReferences(segment, genericSegment);
concreteMessage.Segments.Add(segment);
}
return(concreteMessage);
}
public void parsing_empty_should_return_false()
{
var p = new ParsingService();
var s = p.ParseCsv("", false);
Assert.IsFalse(s == null);
}
public void ShouldExtractHtmlTags()
{
//throw new NotImplementedException();
// Arrange
string testInputString = "https://gameofthrones.fandom.com/wiki/Jon_Snow";
string[] testStartPageHost = new string[2];
int dotComPos = testInputString.IndexOf(".com");
testStartPageHost[0] = testInputString.Substring(0, dotComPos + 4); // https://gameofthrones.fandom.com
testStartPageHost[1] = "/wiki/"; // /wiki/
string testLink1 = "/wiki/Night%27s_Watch";
ILinkTableRepository linkTableRepository = Substitute.For <ILinkTableRepository>();
ParsingService parsingService = new ParsingService(linkTableRepository, this.testFileManager);
// Act
List <string> links = parsingService.ExtractLinksFromHtmlString(ref testStartPageHost, "testFilePath");
// Assert
if (links.Count != 1)
{
throw new ArgumentException("Expected one link in list");
}
if (links[0] != testLink1)
{
throw new ArgumentException("Wrong link string in list");
}
}
private void Test(string input, string output, int maxExpand = 0xFFFF, bool suppressWarnings = false)
{
_sink.MinSeverity = suppressWarnings ? Severity.DebugDetail : Severity.ErrorDetail;
using (LNode.SetPrinter(EcsLanguageService.Value))
using (ParsingService.SetDefault(Les2LanguageService.Value))
TestCompiler.Test(input, output, _sink, maxExpand, "LeMP.Prelude.Les");
}
public SettingsWindow(
CefBrowserHandler cefBrowserHandler,
IItemTagDao itemTagDao,
TooltipHelper tooltipHelper,
Action itemViewUpdateTrigger,
IDatabaseSettingDao settingsDao,
IPlayerItemDao playerItemDao,
ArzParser parser,
GDTransferFile[] modFilter,
StashManager stashManager, ParsingService parsingService)
{
InitializeComponent();
this._cefBrowserHandler = cefBrowserHandler;
this._tooltipHelper = tooltipHelper;
this._itemViewUpdateTrigger = itemViewUpdateTrigger;
this._settingsDao = settingsDao;
this._playerItemDao = playerItemDao;
this._parser = parser;
this._modFilter = modFilter;
this._stashManager = stashManager;
_parsingService = parsingService;
_itemTagDao = itemTagDao;
_controller.BindCheckbox(cbMinimizeToTray);
_controller.BindCheckbox(cbMergeDuplicates);
_controller.BindCheckbox(cbTransferAnyMod);
_controller.BindCheckbox(cbSecureTransfers);
_controller.BindCheckbox(cbShowRecipesAsItems);
_controller.BindCheckbox(cbAutoUpdateModSettings);
_controller.BindCheckbox(cbAutoSearch);
_controller.BindCheckbox(cbDisplaySkills);
_controller.LoadDefaults();
}
public DataPointsController()
{
_context = new ApplicationDbContext();
_parsingService = new ParsingService();
_scatterPlotService = new ScatterPlotService();
_summaryService = new SummaryService();
}
private static void Test()
{
return;
using (ThreadExecuter threadExecuter = new ThreadExecuter())
{
var factory = new SessionFactory();
string _grimdawnLocation = new DatabaseSettingRepo(threadExecuter, factory).GetCurrentDatabasePath();
IItemTagDao _itemTagDao = new ItemTagRepo(threadExecuter, factory);
IDatabaseItemDao _databaseItemDao = new DatabaseItemRepo(threadExecuter, factory);
IDatabaseItemStatDao _databaseItemStatDao = new DatabaseItemStatRepo(threadExecuter, factory);
IItemSkillDao _itemSkillDao = new ItemSkillRepo(threadExecuter, factory);
ParsingService parsingService = new ParsingService(
_itemTagDao,
_grimdawnLocation,
_databaseItemDao,
_databaseItemStatDao,
_itemSkillDao,
Properties.Settings.Default.LocalizationFile
);
parsingService.Execute();
int x = 9;
}
}
protected void Test(string input, string expected, IMessageSink sink = null, IParsingService parser = null)
{
using (ParsingService.PushCurrent(parser ?? LesLanguageService.Value))
using (LNode.PushPrinter(Ecs.EcsNodePrinter.PrintPlainCSharp)) {
var c = new TestCompiler(sink ?? _sink, new UString(input));
c.Run();
Assert.AreEqual(StripExtraWhitespace(expected), StripExtraWhitespace(c.Output.ToString()));
}
}
void TestStage1(string text, LNode expected, bool tryECSharp = true)
{
TestStage1Core(text, expected);
if (tryECSharp)
{
using (ParsingService.PushCurrent(Ecs.EcsLanguageService.Value))
TestStage1Core(text, expected);
}
}
protected void Test(string input, string expected, IMessageSink sink = null, IParsingService parser = null)
{
using (ParsingService.SetDefault(parser ?? Les2LanguageService.Value))
using (LNode.SetPrinter(EcsLanguageService.WithPlainCSharpPrinter)) {
var c = new TestCompiler(sink ?? _sink, new UString(input), "LeMP.les2.to.ecs");
c.Run();
Assert.AreEqual(StripExtraWhitespace(expected), StripExtraWhitespace(c.Output.ToString()));
}
}
public async Task <ISegment> GetElementWithReferencesAsync(ISegment segment, IGenericSegment genericSegment)
{
Ensure.ArgumentNotNull(nameof(segment), segment);
Ensure.ArgumentNotNull(nameof(genericSegment), genericSegment);
ParsingService.UpdateReferences(segment, genericSegment);
return(await Task.FromResult(segment));
}
public void ThrowsWhenProcessIdIsNotDefined()
{
string unknownProcessId = _fixture.Create <string>();
Mesh mesh = new Mesh();
ParsingService service = new ParsingService();
Assert.That(() => service.ProcessLine(unknownProcessId, mesh), Throws.InvalidOperationException);
}
public void CompleteInputOutputOptions(InputOutput file)
{
if (file.InputLang == null)
{
var inLang = InLang ?? ParsingService.Default;
if (!ForceInLang || InLang == null)
{
inLang = ParsingService.GetServiceForFileName(file.FileName) ?? inLang;
}
file.InputLang = inLang;
}
if (file.OutFileName == null)
{
string inputFN = file.FileName;
if (OutExt == null)
{
file.OutFileName = inputFN;
}
else
{
int dot = IndexOfExtension(inputFN);
file.OutFileName = inputFN.Left(dot) + OutExt;
}
if (file.OutFileName == inputFN)
{
// e.g. input.cs => input.out.cs
int dot = IndexOfExtension(inputFN);
file.OutFileName = file.OutFileName.Insert(dot, ".out");
}
}
if (file.OutPrinter == null)
{
var outLang = OutLang;
if (outLang == null && OutExt != null)
{
var lang = ParsingService.GetServiceForFileName(OutExt);
if (lang != null)
{
outLang = lang as ILNodePrinter;
}
}
file.OutPrinter = outLang ?? LNode.Printer;
}
if (file.OutOptions == null)
{
file.OutOptions = OutOptions;
}
if (file.PreserveComments == null)
{
file.PreserveComments = PreserveComments;
}
if (file.ParsingMode == null)
{
file.ParsingMode = ParsingMode;
}
}
public void CanInitializeProcessDictionary()
{
ParsingService service = new ParsingService();
foreach (KeyValuePair <string, Action <string, Mesh> > pair in service.ProcessDictionary)
{
Assert.That(_processIds.Contains(pair.Key), Is.True);
Assert.That(pair.Value, Is.Not.Null);
}
}
public ModsDatabaseConfig(Action itemViewUpdateTrigger, IDatabaseSettingDao databaseSettingDao, ArzParser arzParser, IPlayerItemDao playerItemDao, ParsingService parsingService)
{
InitializeComponent();
this._itemViewUpdateTrigger = itemViewUpdateTrigger;
this._databaseSettingDao = databaseSettingDao;
this._arzParser = arzParser;
this._playerItemDao = playerItemDao;
_parsingService = parsingService;
_databaseModSelectionService = new DatabaseModSelectionService();
}
//int _alternator;
public void Test(string input, string output, int maxExpand = 0xFFFF, ILNodePrinter printer = null)
{
using (LNode.SetPrinter(printer ?? EcsLanguageService.Value))
using (ParsingService.SetDefault(Les3LanguageService.Value))
TestCompiler.Test(input, output, _sink, maxExpand, "LeMP.les3.to.ecs");
// LeMP.Prelude.Les3 is set up as an alias; both namespaces should work,
// but we're not using this logic as of 2021/01 because we don't have a
// way to turn off annoying deprecation warnings
//(++_alternator & 1) != 0 ? "LeMP.les3.to.ecs" : "LeMP.Prelude.Les3");
}
public Task Execute(IJobExecutionContext context)
{
return(Task.Run(() =>
{
using (var model = new ApplicationDbContext(new DbContextOptions <ApplicationDbContext>()))
{
ParsingService.UpdateData(model);
}
}));
}
public ModsDatabaseConfig(
Action itemViewUpdateTrigger,
IPlayerItemDao playerItemDao,
ParsingService parsingService)
{
InitializeComponent();
_itemViewUpdateTrigger = itemViewUpdateTrigger;
_playerItemDao = playerItemDao;
_parsingService = parsingService;
_databaseModSelectionService = new DatabaseModSelectionService();
}
public ParsingServiceTests()
{
mockParcelFactory = new Mock <IParcelFactory>();
mockWeighingService = new Mock <IWeighingService>();
mockPricingService = new Mock <IPricingService>();
parsingService = new ParsingService(
mockParcelFactory.Object,
mockWeighingService.Object,
mockPricingService.Object
);
}
public App(DownloadService downloadService, ParsingService parsingService)
{
this.downloadService = downloadService;
this.parsingService = parsingService;
Directory.CreateDirectory("Pages");
if (!Mutex.TryOpenExisting("MultithreadAppMutex", out mutexObj))
{
mutexObj = new Mutex(false, "MultithreadAppMutex");
}
}
public Compiler(IMessageSink sink, Type prelude = null, bool registerEcsAndLes = true)
{
MacroProcessor = new MacroProcessor(prelude, sink);
if (registerEcsAndLes)
{
ParsingService.Register(Loyc.Syntax.Les.LesLanguageService.Value);
ParsingService.Register(Loyc.Ecs.EcsLanguageService.WithPlainCSharpPrinter, new[] { "cs" });
ParsingService.Register(Loyc.Ecs.EcsLanguageService.Value);
}
}
public void ParseRow()
{
var line = @"Value1,""Value, 2!"",Value 3";
var parsingService = new ParsingService();
var row = parsingService.ParseRow_v1(line);
Assert.AreEqual("Value1", row.Columns[0].Value);
Assert.AreEqual("Value, 2!", row.Columns[1].Value);
Assert.AreEqual("Value 3", row.Columns[2].Value);
}
public object Convert(object value, Type targetType, object parameter, string language)
{
if (_parsingService == null)
{
_parsingService = new ParsingService();
}
string bodyText = (string)value;
return(_parsingService.FormatBody(bodyText));
}
protected internal override IEnumerable <RentParseOrder> ProcessSearch(IDocument document)
{
var nodes = SearchService.SearchBlock(document, _template);
var result = new List <RentParseOrder>();
foreach (var node in nodes)
{
result.Add(ParsingService <RentParseOrder> .Parse(node));
}
return(result);
}
public LanguagePackPicker(
IItemTagDao itemTagDao,
IPlayerItemDao playerItemDao,
ParsingService parsingService
)
{
InitializeComponent();
_parsingService = parsingService;
_itemTagDao = itemTagDao;
_playerItemDao = playerItemDao;
}
public void ShouldExtractHtmlTags()
{
//Arrange
ParsingService parsingService = new ParsingService();
var pathToHtml = "TestHTMLPage.html";
string url = "https://en.m.wikipedia.org/wiki/Medicine";
//Act
List <string> links = parsingService.GetLinksFromHtml(pathToHtml, url);
//Assert
Assert.AreEqual(4, links.Count);
}
static void Main(string[] args)
{
DownloadService downloadService = new DownloadService();
ParsingService parserService = new ParsingService();
App app = new App(downloadService, parserService);
int depth = 2;
Task task = app.Run("https://en.m.wikipedia.org/wiki/Batman", depth);
task.Wait();
}
