public NonPrefixedCaseInsensitiveKeysFacts()
{
_builder = new ConfiguratorBuilder<INonPrefixed>()
.FromAppSettings();
_value = ConfigurationManager.AppSettings["caseinsensitivevalue"];
}
public static IHostBuilder CreateHostBuilder(string[] args)
{
var configuration = new ReverseProxyConfiguration();
ConfiguratorBuilder.InitializeConfiguration(args, new[] { "logger.yml", "reverse-proxy.yml" }).Bind(configuration);
LogLanguage.Language = configuration.Language;
return(Host.CreateDefaultBuilder(args)
.UseWindowsService()
.UseSystemd()
.ConfigureLogging(
loggingBuilder =>
{
loggingBuilder.ClearProviders();
loggingBuilder.AddSerilog(dispose: true);
}
)
.ConfigureServices((hostContext, services) =>
{
services.AddSingleton(configuration);
services.AddSingleton(typeof(ITcpClientFactory), typeof(TcpClientFactory.TcpClientFactory));
services.AddSingleton(typeof(IProxy), typeof(TcpProxy.TcpProxy));
services.AddHostedService <Worker>();
}));
}
public ConvertTypesFact()
{
_builder = new ConfiguratorBuilder<IPrefixed>()
.WithKeyPrefix("sample")
.FromAppSettings();
_port = Convert.ToInt32(ConfigurationManager.AppSettings["sample:port"]);
_url = new Uri(ConfigurationManager.AppSettings["sample:url"]);
}
private (Type, Type) CreateProxyTypeAndConfiguratorType(Type type)
{
var memberNamesProvider = new MemberNamesProviderCacheProxy(new MemberNamesProviderCore());
var proxyType = new ProxyBuilder(type, memberNamesProvider, moduleBuilder).CreateProxyType();
var configuratorType = new ConfiguratorBuilder(type, proxyType, memberNamesProvider, moduleBuilder).CreateConfiguratorType();
return(proxyType, configuratorType);
}
public NosCoreContext CreateDbContext(string[] args)
{
var databaseConfiguration = new SqlConnectionConfiguration();
ConfiguratorBuilder.InitializeConfiguration(args, new[] { "database.yml" }, databaseConfiguration);
var optionsBuilder = new DbContextOptionsBuilder <NosCoreContext>();
optionsBuilder.UseNpgsql(databaseConfiguration.ConnectionString);
return(new NosCoreContext(optionsBuilder.Options));
}
private static void InitializeConfiguration(string[] args)
{
_logger = Shared.I18N.Logger.GetLoggerConfiguration().CreateLogger();
Shared.I18N.Logger.PrintHeader(ConsoleText);
var optionsBuilder = new DbContextOptionsBuilder <NosCoreContext>();
var loginConfiguration = new LoginConfiguration();
ConfiguratorBuilder.InitializeConfiguration(args, new[] { "logger.yml", "login.yml" }).Bind(loginConfiguration);
optionsBuilder.UseNpgsql(loginConfiguration.Database !.ConnectionString);
}
private static void InitializeConfiguration(string[] args)
{
var conf = new LoginConfiguration();
ConfiguratorBuilder.InitializeConfiguration(args, new[] { "logger.yml", "login.yml" }, conf);
_loginConfiguration = conf;
Shared.I18N.Logger.PrintHeader(ConsoleText);
var optionsBuilder = new DbContextOptionsBuilder <NosCoreContext>();
optionsBuilder.UseNpgsql(_loginConfiguration.Database !.ConnectionString);
_dataAccess = new DataAccessHelper();
_dataAccess.Initialize(optionsBuilder.Options, Logger);
LogLanguage.Language = _loginConfiguration.Language;
}
private static IWebHost BuildWebHost(string[] args)
{
return(WebHost.CreateDefaultBuilder(args)
.ConfigureLogging(logging =>
{
logging.ClearProviders();
logging.AddSerilog();
})
.UseConfiguration(ConfiguratorBuilder.InitializeConfiguration(args, new[] { "logger.yml", "master.yml" }))
.UseStartup <Startup>()
.PreferHostingUrls(true)
.SuppressStatusMessages(true)
.Build());
}
private static IWebHost BuildWebHost(string[] args)
{
var conf = new MasterConfiguration();
ConfiguratorBuilder.InitializeConfiguration(args, new[] { "logger.yml", "master.yml" }, conf);
return(WebHost.CreateDefaultBuilder(args)
.ConfigureLogging(logging =>
{
logging.ClearProviders();
logging.AddSerilog();
})
.ConfigureServices((hostContext, services) => services.AddSingleton(conf))
.UseUrls(conf.WebApi !.ToString())
.UseStartup <Startup>()
.PreferHostingUrls(true)
.SuppressStatusMessages(true)
.Build());
}
public static async Task Main(string[] args)
{
try { Console.Title = Title; } catch (PlatformNotSupportedException) { }
ConfiguratorBuilder.InitializeConfiguration(args, new[] { "pathfinder.yml", "logger.yml" }).Bind(PathfinderGuiConfiguration);
Shared.I18N.Logger.PrintHeader(ConsoleText);
var logger = Shared.I18N.Logger.GetLoggerConfiguration().CreateLogger();
LogLanguage.Language = PathfinderGuiConfiguration.Language;
var optionsBuilder = new DbContextOptionsBuilder <NosCoreContext>();
optionsBuilder.UseNpgsql(PathfinderGuiConfiguration.Database !.ConnectionString);
DbContextBuilder.Initialize(optionsBuilder.Options);
var mapDao = new Dao <Map, MapDto, short>(logger, DbContextBuilder.CreateContext);
while (true)
{
logger.Information(LogLanguage.Instance.GetMessageFromKey(LogLanguageKey.SELECT_MAPID));
var input = Console.ReadLine();
if ((input == null) || !short.TryParse(input, out var askMapId))
{
logger.Error(LogLanguage.Instance.GetMessageFromKey(LogLanguageKey.WRONG_SELECTED_MAPID));
continue;
}
var map = await mapDao.FirstOrDefaultAsync(m => m.MapId == askMapId).ConfigureAwait(false);
if ((!(map?.Width > 0)) || (map.Height <= 0))
{
continue;
}
if (GuiWindows.ContainsKey(map.MapId) && GuiWindows[map.MapId] !.Exists)
{
GuiWindows[map.MapId] !.Close();
}
GuiWindows[map.MapId] = new GuiWindow(map, 1024, 768,
$"NosCore Pathfinder GUI - Map {map.MapId}", DbContextBuilder);
GuiWindows[map.MapId] !.Run(30);
}
}
public static IHostBuilder CreateHostBuilder(string[] args)
{
var configuration = new ParserInputGeneratorConfiguration();
ConfiguratorBuilder.InitializeConfiguration(args, new[] { "logger.yml", "parser-input-generator.yml" }).Bind(configuration);
return(Host.CreateDefaultBuilder(args)
.ConfigureLogging(
loggingBuilder =>
{
loggingBuilder.ClearProviders();
loggingBuilder.AddSerilog(dispose: true);
}
)
.ConfigureServices((hostContext, services) =>
{
services.AddSingleton(configuration);
services.AddTransient <IExtractor, Extractor.Extractor>();
services.AddTransient <IClientDownloader, ClientDownloader>();
services.AddHttpClient();
services.AddHostedService <Worker>();
}));
}
public static IHostBuilder CreateHostBuilder(string[] args)
{
var injectorConfiguration = new InjectorConfiguration();
try { Console.Title = Title; } catch (PlatformNotSupportedException) { }
var configuration = ConfiguratorBuilder.InitializeConfiguration(args, new[] { "injector.yml", "logger.yml" });
LogLanguage.Language = injectorConfiguration.Language;
return(Host.CreateDefaultBuilder(args)
.ConfigureLogging(
loggingBuilder =>
{
loggingBuilder.ClearProviders();
loggingBuilder.AddSerilog(dispose: true);
}
)
.ConfigureServices((hostContext, services) =>
{
services.AddOptions <InjectorConfiguration>().Bind(configuration);
services.AddHostedService <Worker>();
}));
}
public SupportAttributesFacts()
{
_builder = new ConfiguratorBuilder<IPrefixed>()
.WithKeyPrefix("sample")
.FromEnvironment();
}
public static async Task Main(string[] args)
{
if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
{
Console.Title = Title;
}
var parserConfiguration = new ParserConfiguration();
ConfiguratorBuilder.InitializeConfiguration(args, new[] { "logger.yml", "parser.yml" }).Bind(parserConfiguration);
Shared.I18N.Logger.PrintHeader(ConsoleText);
LogLanguage.Language = parserConfiguration.Language;
Logger.Information(LogLanguage.Instance.GetMessageFromKey(LogLanguageKey.SUCCESSFULLY_LOADED));
TypeAdapterConfig.GlobalSettings.Default.IgnoreAttribute(typeof(I18NFromAttribute));
TypeAdapterConfig.GlobalSettings.Default
.IgnoreMember((member, side) => side == MemberSide.Destination && member.Type.GetInterfaces().Contains(typeof(IEntity)) ||
(member.Type.GetGenericArguments().Any() && member.Type.GetGenericArguments()[0].GetInterfaces().Contains(typeof(IEntity))));
try
{
var optionsBuilder = new DbContextOptionsBuilder <NosCoreContext>();
optionsBuilder.UseNpgsql(parserConfiguration.Database !.ConnectionString);
try
{
Logger.Warning(LogLanguage.Instance.GetMessageFromKey(LogLanguageKey.ENTER_PATH));
var folder = string.Empty;
var key = default(ConsoleKeyInfo);
if (args.Length == 0)
{
folder = Console.ReadLine();
Logger.Information(
$"{LogLanguage.Instance.GetMessageFromKey(LogLanguageKey.PARSE_ALL)} [Y/n]");
key = Console.ReadKey(true);
}
else
{
folder = args.Aggregate(folder, (current, str) => current + str + " ");
}
var containerBuilder = new ContainerBuilder();
containerBuilder.Register(c => optionsBuilder.Options).As <DbContextOptions>();
containerBuilder.RegisterType <NosCoreContext>().As <DbContext>()
.OnActivated(c => c.Instance.Database.Migrate());
containerBuilder.RegisterLogger();
containerBuilder.RegisterAssemblyTypes(typeof(CardParser).Assembly)
.Where(t => t.Name.EndsWith("Parser") && !t.IsGenericType)
.AsSelf()
.PropertiesAutowired();
containerBuilder.RegisterType <ImportFactory>().PropertiesAutowired();
var registerDatabaseObject = typeof(Parser).GetMethod(nameof(RegisterDatabaseObject));
var assemblyDto = typeof(IStaticDto).Assembly.GetTypes();
var assemblyDb = typeof(Account).Assembly.GetTypes();
assemblyDto.Where(p =>
typeof(IDto).IsAssignableFrom(p) && !p.Name.Contains("InstanceDto") && p.IsClass)
.ToList()
.ForEach(t =>
{
var type = assemblyDb.First(tgo =>
string.Compare(t.Name, $"{tgo.Name}Dto", StringComparison.OrdinalIgnoreCase) == 0);
var optionsBuilder = new DbContextOptionsBuilder <NosCoreContext>().UseInMemoryDatabase(
Guid.NewGuid().ToString());
var typepk = type.GetProperties()
.Where(s => new NosCoreContext(optionsBuilder.Options).Model.FindEntityType(type)
.FindPrimaryKey().Properties.Select(x => x.Name)
.Contains(s.Name)
).ToArray()[0];
registerDatabaseObject?.MakeGenericMethod(t, type, typepk !.PropertyType).Invoke(null,
new[] { containerBuilder, (object)typeof(IStaticDto).IsAssignableFrom(t) });
});
containerBuilder.RegisterType <Dao <ItemInstance, IItemInstanceDto?, Guid> >().As <IDao <IItemInstanceDto?, Guid> >()
.SingleInstance();
var container = containerBuilder.Build();
var factory = container.Resolve <ImportFactory>();
factory.SetFolder(folder !);
await factory.ImportPacketsAsync().ConfigureAwait(false);
if (key.KeyChar != 'n')
{
await factory.ImportAccountsAsync().ConfigureAwait(false);
await factory.ImportMapsAsync().ConfigureAwait(false);
await factory.ImportRespawnMapTypeAsync().ConfigureAwait(false);
await factory.ImportMapTypeAsync().ConfigureAwait(false);
await factory.ImportMapTypeMapAsync().ConfigureAwait(false);
await factory.ImportPortalsAsync().ConfigureAwait(false);
await factory.ImportI18NAsync().ConfigureAwait(false);
//factory.ImportScriptedInstances();
await factory.ImportItemsAsync().ConfigureAwait(false);
await factory.ImportSkillsAsync().ConfigureAwait(false);
await factory.ImportCardsAsync().ConfigureAwait(false);
await factory.ImportNpcMonstersAsync().ConfigureAwait(false);
await factory.ImportDropsAsync().ConfigureAwait(false);
//factory.ImportNpcMonsterData();
await factory.ImportMapNpcsAsync().ConfigureAwait(false);
await factory.ImportMapMonstersAsync().ConfigureAwait(false);
await factory.ImportShopsAsync().ConfigureAwait(false);
//factory.ImportTeleporters();
await factory.ImportShopItemsAsync().ConfigureAwait(false);
//factory.ImportShopSkills();
//factory.ImportRecipe();
await factory.ImportScriptsAsync().ConfigureAwait(false);
await factory.ImportQuestsAsync().ConfigureAwait(false);
}
else
{
Logger.Information(
$"{LogLanguage.Instance.GetMessageFromKey(LogLanguageKey.PARSE_MAPS)} [Y/n]");
key = Console.ReadKey(true);
if (key.KeyChar != 'n')
{
await factory.ImportMapsAsync().ConfigureAwait(false);
}
Logger.Information(
$"{LogLanguage.Instance.GetMessageFromKey(LogLanguageKey.PARSE_MAPTYPES)} [Y/n]");
key = Console.ReadKey(true);
if (key.KeyChar != 'n')
{
await factory.ImportRespawnMapTypeAsync().ConfigureAwait(false);
await factory.ImportMapTypeAsync().ConfigureAwait(false);
await factory.ImportMapTypeMapAsync().ConfigureAwait(false);
}
Logger.Information(
$"{LogLanguage.Instance.GetMessageFromKey(LogLanguageKey.PARSE_ACCOUNTS)} [Y/n]");
key = Console.ReadKey(true);
if (key.KeyChar != 'n')
{
await factory.ImportAccountsAsync().ConfigureAwait(false);
}
Logger.Information(
$"{LogLanguage.Instance.GetMessageFromKey(LogLanguageKey.PARSE_PORTALS)} [Y/n]");
key = Console.ReadKey(true);
if (key.KeyChar != 'n')
{
await factory.ImportPortalsAsync().ConfigureAwait(false);
}
Logger.Information(
$"{LogLanguage.Instance.GetMessageFromKey(LogLanguageKey.PARSE_I18N)} [Y/n]");
key = Console.ReadKey(true);
if (key.KeyChar != 'n')
{
await factory.ImportI18NAsync().ConfigureAwait(false);
}
Logger.Information(
$"{LogLanguage.Instance.GetMessageFromKey(LogLanguageKey.PARSE_TIMESPACES)} [Y/n]");
key = Console.ReadKey(true);
if (key.KeyChar != 'n')
{
//factory.ImportScriptedInstances();
}
Logger.Information(
$"{LogLanguage.Instance.GetMessageFromKey(LogLanguageKey.PARSE_ITEMS)} [Y/n]");
key = Console.ReadKey(true);
if (key.KeyChar != 'n')
{
await factory.ImportItemsAsync().ConfigureAwait(false);
}
Logger.Information(
$"{LogLanguage.Instance.GetMessageFromKey(LogLanguageKey.PARSE_NPCMONSTERS)} [Y/n]");
key = Console.ReadKey(true);
if (key.KeyChar != 'n')
{
await factory.ImportNpcMonstersAsync().ConfigureAwait(false);
}
Logger.Information(
$"{LogLanguage.Instance.GetMessageFromKey(LogLanguageKey.PARSE_DROPS)} [Y/n]");
key = Console.ReadKey(true);
if (key.KeyChar != 'n')
{
await factory.ImportDropsAsync().ConfigureAwait(false);
}
Logger.Information(
$"{LogLanguage.Instance.GetMessageFromKey(LogLanguageKey.PARSE_NPCMONSTERDATA)} [Y/n]");
key = Console.ReadKey(true);
if (key.KeyChar != 'n')
{
//factory.ImportNpcMonsterData();
}
Logger.Information(
$"{LogLanguage.Instance.GetMessageFromKey(LogLanguageKey.PARSE_CARDS)} [Y/n]");
key = Console.ReadKey(true);
if (key.KeyChar != 'n')
{
await factory.ImportCardsAsync().ConfigureAwait(false);
}
Logger.Information(
$"{LogLanguage.Instance.GetMessageFromKey(LogLanguageKey.PARSE_SKILLS)} [Y/n]");
key = Console.ReadKey(true);
if (key.KeyChar != 'n')
{
await factory.ImportSkillsAsync().ConfigureAwait(false);
}
Logger.Information(
$"{LogLanguage.Instance.GetMessageFromKey(LogLanguageKey.PARSE_MAPNPCS)} [Y/n]");
key = Console.ReadKey(true);
if (key.KeyChar != 'n')
{
await factory.ImportMapNpcsAsync().ConfigureAwait(false);
}
Logger.Information(
$"{LogLanguage.Instance.GetMessageFromKey(LogLanguageKey.PARSE_MONSTERS)} [Y/n]");
key = Console.ReadKey(true);
if (key.KeyChar != 'n')
{
await factory.ImportMapMonstersAsync().ConfigureAwait(false);
}
Logger.Information(
$"{LogLanguage.Instance.GetMessageFromKey(LogLanguageKey.PARSE_SHOPS)} [Y/n]");
key = Console.ReadKey(true);
if (key.KeyChar != 'n')
{
await factory.ImportShopsAsync().ConfigureAwait(false);
}
Logger.Information(
$"{LogLanguage.Instance.GetMessageFromKey(LogLanguageKey.PARSE_TELEPORTERS)} [Y/n]");
key = Console.ReadKey(true);
if (key.KeyChar != 'n')
{
//factory.ImportTeleporters();
}
Logger.Information(
$"{LogLanguage.Instance.GetMessageFromKey(LogLanguageKey.PARSE_SHOPITEMS)} [Y/n]");
key = Console.ReadKey(true);
if (key.KeyChar != 'n')
{
await factory.ImportShopItemsAsync().ConfigureAwait(false);
}
Logger.Information(
$"{LogLanguage.Instance.GetMessageFromKey(LogLanguageKey.PARSE_SHOPSKILLS)} [Y/n]");
key = Console.ReadKey(true);
if (key.KeyChar != 'n')
{
//factory.ImportShopSkills();
}
Logger.Information(
$"{LogLanguage.Instance.GetMessageFromKey(LogLanguageKey.PARSE_RECIPES)} [Y/n]");
key = Console.ReadKey(true);
if (key.KeyChar != 'n')
{
//factory.ImportRecipe();
}
Logger.Information(
$"{LogLanguage.Instance.GetMessageFromKey(LogLanguageKey.PARSE_SCRIPTS)} [Y/n]");
key = Console.ReadKey(true);
if (key.KeyChar != 'n')
{
await factory.ImportScriptsAsync().ConfigureAwait(false);
}
Logger.Information(
$"{LogLanguage.Instance.GetMessageFromKey(LogLanguageKey.PARSE_QUESTS)} [Y/n]");
key = Console.ReadKey(true);
if (key.KeyChar != 'n')
{
await factory.ImportQuestsAsync().ConfigureAwait(false);
}
}
Logger.Information(LogLanguage.Instance.GetMessageFromKey(LogLanguageKey.DONE));
Thread.Sleep(5000);
}
catch (FileNotFoundException)
{
Logger.Error(LogLanguage.Instance.GetMessageFromKey(LogLanguageKey.AT_LEAST_ONE_FILE_MISSING));
Thread.Sleep(5000);
}
}
catch (Exception ex)
{
Logger.Error(ex.Message, ex);
Console.ReadKey();
}
}
public NonPrefixedFacts()
{
_builder = new ConfiguratorBuilder<INonPrefixed>()
.FromAppSettings();
_value = ConfigurationManager.AppSettings["NonPrefixedValue"];
}
public OrderMattersFacts()
{
Environment.SetEnvironmentVariable("SAMPLE:PREFIXEDVALUE", "fromenvironment");
_builder = new ConfiguratorBuilder<IPrefixed>()
.WithKeyPrefix("sample")
.FromAppSettings()
.FromEnvironment();
_value = Environment.GetEnvironmentVariable("SAMPLE:PREFIXEDVALUE");
}
public SourceIsQueryOnBuildFacts()
{
_builder = new ConfiguratorBuilder<IPrefixed>()
.WithKeyPrefix("sample")
.FromEnvironment();
Environment.SetEnvironmentVariable("SAMPLE:PREFIXEDVALUE", "tada!");
_value = Environment.GetEnvironmentVariable("SAMPLE:PREFIXEDVALUE");
}
public PrefixedValueDoesNotExist()
{
_builder = new ConfiguratorBuilder<INonPrefixed>()
.WithKeyPrefix("sample")
.FromAppSettings();
_value = ConfigurationManager.AppSettings["sample:valuedoesnotexist"];
}
public PrefixedFacts()
{
_builder = new ConfiguratorBuilder<IPrefixed>()
.WithKeyPrefix("sample")
.FromAppSettings();
_value = ConfigurationManager.AppSettings["Sample:PrefixedValue"];
}
public PrefixedCaseInsensitiveKeysFacts()
{
_builder = new ConfiguratorBuilder<IPrefixed>()
.WithKeyPrefix("SAMPLE")
.FromAppSettings();
_value = ConfigurationManager.AppSettings["sample:caseinsensitivevalue"];
}
