private async Task ConnectImpl()
        {
            ConnectText.Value = "Connecting...";

            var split = Host.Value.Split(':');
            var host  = split[0];
            var port  = ushort.Parse(split[1]);

            var connectionStringBuilder = new MySqlConnectionStringBuilder
            {
                Server   = host,
                Port     = port,
                Database = Database.Value,
                UserID   = Username.Value,
                Password = Password.Value,
                SslMode  = MySqlSslMode.None
            };

            var serviceProvider = new ServiceCollection()
                                  .AddSingleton <DatabaseService>()
                                  .AddDbContext <GameContext>(x => x.UseMySql(connectionStringBuilder.ConnectionString))
                                  .BuildServiceProvider();
            var databaseService = serviceProvider.GetRequiredService <DatabaseService>();

            try
            {
                await Task.Run(async() =>
                {
                    using (var db = databaseService.Open <GameContext>())
                        await db.ShopVersion.FirstOrDefaultAsync();
                });
            }
            catch (Exception ex)
            {
                await new MessageView("Error", "Unable to connect to database", ex).ShowDialog(Application.Current.MainWindow);
                return;
            }
            finally
            {
                ConnectText.Value = "Connect";
            }

            AvaloniaLocator.CurrentMutable.Bind <DatabaseService>().ToConstant(databaseService);
            AvaloniaLocator.CurrentMutable.Bind <S4Zip>().ToConstant(S4Zip.OpenZip(ResourcePath.Value));
            ResourceService.Instance.Load();
            await ShopService.Instance.LoadFromDatabase();

            var window = Application.Current.MainWindow;

            new MainView().Show();
            window.Close();
        }
        public void Open(string fileName)
        {
            _folders.Clear();
            _files.Clear();
            Zip = S4Zip.OpenZip(fileName);

            foreach (var entry in Zip.Values)
            {
                Add(entry);
            }

            IsOpen = true;
        }
 public ResourceService()
 {
     _zip = AvaloniaLocator.Current.GetService <S4Zip>();
 }
        private static void Main()
        {
            var filesToExtract = new []
            {
                "language/xml/channel_setting_string_table.x7",
                "language/xml/gameinfo_string_table.x7",
                "language/xml/item_effect_string_table.x7",
                "language/xml/iteminfo_string_table.x7",

                "resources/mapinfo/(.*).ini$",

                "xml/_eu_channel_setting.x7",
                "xml/_eu_gameinfo.x7",
                "xml/_eu_task_list.x7",
                "xml/_eu_coin_info.x7",
                "xml/constant_info.x7",
                "xml/default_item.x7",
                "xml/equip_limit.x7",
                "xml/experience.x7",
                "xml/item.x7",
                "xml/item_effect.x7",
                "xml/item_grade.x7",
                "xml/iteminfo.x7",
                "xml/map.x7",
            };
            var path = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "resource.s4hd");

            if (!File.Exists(path))
            {
                Error("You have to place the extractor in the S4 League folder!");
                Exit();
            }

            S4Zip zip = null;

            try
            {
                zip = S4Zip.OpenZip(path);
            }
            catch
            {
                Error("Failed to read resources. Are you using the right S4 League version?");
                Exit();
            }

            var dataPath = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "data");

            if (Directory.Exists(dataPath))
            {
                Directory.Delete(dataPath, true);
            }

            Directory.CreateDirectory(dataPath);

            foreach (var toExtract in filesToExtract)
            {
                var entries = zip.Where(pair => Regex.IsMatch(pair.Key, toExtract)).Select(pair => pair.Value).ToArray();

                if (entries.Length == 0)
                {
                    Warn($"'{toExtract}' not found!");
                    continue;
                }

                foreach (var entry in entries)
                {
                    byte[] data;
                    try
                    {
                        data = entry.GetData();
                    }
                    catch (Exception ex)
                    {
                        Error($"Failed to extract '{entry.FullName}'");
                        Error(ex.ToString());
                        continue;
                    }

                    Info($"Extracting '{entry.FullName}'...");
                    var saveTo = entry.FullName
                                 .Replace('\\', Path.DirectorySeparatorChar)
                                 .Replace('/', Path.DirectorySeparatorChar);
                    saveTo = Path.Combine(dataPath, saveTo);

                    var dir = Path.GetDirectoryName(saveTo);
                    if (!Directory.Exists(dir))
                    {
                        Directory.CreateDirectory(dir);
                    }

                    File.WriteAllBytes(saveTo, data);
                }
            }

            Info("Done.");
            Exit();
        }