protected override void OnCreate(Bundle bundle)
{
base.OnCreate(bundle);
RequestWindowFeature(WindowFeatures.NoTitle);
SetContentView(Resource.Layout.Main);
Button buttonConnect = FindViewById <Button>(Resource.Id.ButtonConnect);
buttonConnect.Click += ClickConnect;
Button buttonFriends = FindViewById <Button>(Resource.Id.ButtonFriends);
buttonFriends.Click += ClickFriends;
SteamAlerts.Initialize(this);
if (!SteamService.IsRunning())
{
Intent steamService = new Intent(this, typeof(SteamService));
StartService(steamService);
}
UpdateButtons();
SteamService.GetClient().AddHandler(this);
}
//private readonly Logger _log;
public GameListBZCCService(/*IBotCredentials creds, DbService db,*/ DiscordSocketClient client, SteamService steam)
{
//_creds = creds;
//_db = db;
_client = client;
//_log = LogManager.GetCurrentClassLogger();
//_log.Info("GameListBZCCService");
/*var sw = Stopwatch.StartNew();
* using (var uow = _db.UnitOfWork)
* {
* var items = uow.BZCCGameProperties.GetAll();
* BZCCGameProperties = new ConcurrentDictionary<string, ConcurrentDictionary<string, BZCCGameProperty>>();
* items.ForEach(BZCCProperty =>
* {
* lock (BZCCGameProperties)
* {
* if (!BZCCGameProperties.ContainsKey(BZCCProperty.TermType))
* BZCCGameProperties[BZCCProperty.TermType] = new ConcurrentDictionary<string, BZCCGameProperty>();
*
* BZCCGameProperties[BZCCProperty.TermType][BZCCProperty.Term] = BZCCProperty;
* }
* });
* }
* sw.Stop();
* _log.Debug($"Loaded in {sw.Elapsed.TotalSeconds:F2}s");*/
_steam = steam;
}
public void GetSteamProfile()
{
Assert.IsNotNull(SteamService.GetSteamProfileAsync("criticalflaw").Result);
Assert.IsNotNull(SteamService.GetSteamSummaryAsync("criticalflaw").Result);
Assert.IsNull(SteamService.GetSteamProfileAsync("99999999999999999").Result);
Assert.IsNull(SteamService.GetSteamSummaryAsync("99999999999999999").Result);
}
public SettingsWindow(IServiceProvider serviceProvider)
{
InitializeComponent();
_steamService = serviceProvider.GetService <SteamService>();
AppsCachedNumber.Content = $"({_steamService.Cache.SourceGames.Count} apps cached)";
}
/// <summary>
/// The main.
/// </summary>
/// <param name="args">
/// The args.
/// </param>
/// <returns>
/// The <see cref="int"/>.
/// </returns>
static int Main(string[] args)
{
try
{
configService = new ConfigurationService();
userService = new UserService(configService);
steamService = new SteamService(configService, userService);
return(Parser.Default.ParseArguments <AddParams, RunParams, ListParams, DeleteParams, ConfigParams>(args).MapResult(
(AddParams opts) => ExecutAddParams(opts),
(RunParams opts) => ExecuteRunParams(opts),
(ListParams opts) => ExecuteListParams(opts),
(DeleteParams opts) => ExecuteDeleteParams(opts),
(ConfigParams opts) => ExecuteConfigParams(opts),
errs => ExitCodes.GeneralError));
}
catch (ApplicationException exception)
{
Console.WriteLine(exception.Message);
ExitWithWait(ExitCodes.ApplicationError);
}
catch (FileNotFoundException exception)
{
Console.WriteLine(exception.Message);
ExitWithWait(ExitCodes.ConfigurationError);
}
return(0);
}
public void GetSteamProfile()
{
Assert.IsNotNull(SteamService.GetSteamProfileAsync(TestSetup.Tokens.SteamToken, "criticalflaw")
.Result);
Assert.IsNull(SteamService.GetSteamProfileAsync(TestSetup.Tokens.SteamToken, "99999999999999999")
.Result);
}
public void Setup()
{
_steamRepositoryMock = new Mock <ISteamRepository>();
var steamClientMock = new Mock <ISteamClient>();
steamClientMock.Setup(x => x.GetUserAchievementsForGame(It.IsAny <string>(), It.IsAny <string>()))
.Returns(new PlayerStatsForGame
{
Achievements = new List <PlayerAchievement>
{
new PlayerAchievement
{
Achieved = 1,
Name = _achievementName1,
AchievedTimestamp = "1483002574"
},
new PlayerAchievement
{
Achieved = 1,
Name = _achievementName2,
AchievedTimestamp = "1483002574"
}
},
GameInfo = new GameInfo
{
Name = "Witcher 3"
}
});
var subject = new SteamService(steamClientMock.Object, _steamRepositoryMock.Object);
var result = subject.UpdateSteamAchievementsFor("211420", "flave_229");
}
public async Task ProfileAsync()
{
var id = Context.User.Id;
var color = Color.Red;
var description = "You are not registered!";
var embed = new LocalEmbedBuilder()
.WithTitle("User profile");
var player = ContrackerService.Contracker
.GetPlayer(discordId: id.ToString());
if (player != null)
{
description = "You are gamer.";
color = Color.Green;
var steamname = SteamService.GetSteamName(player.Steam);
embed.AddField("Discord", Discord.MentionUser(Context.User))
.AddField("Steam", $"[{steamname}](https://steamcommunity.com/profiles/{player.Steam})")
.AddField("Total CP", player.Cp)
.AddField("Stars", player.Stars);
}
await ReplyAsync(embed : embed
.WithDescription(description)
.WithColor(color)
.Build()).ConfigureAwait(true);
}
public async Task SteamGame(CommandContext ctx,
[Description("Game to find on Steam")][RemainingText] string query = "Team Fortress 2")
{
try
{
var app = SteamService.GetSteamAppAsync(query).Result;
var output = new DiscordEmbedBuilder()
.WithTitle(app.Name)
.WithDescription((Regex.Replace(app.DetailedDescription.Length <= 500 ? app.DetailedDescription : app.DetailedDescription.Substring(0, 250) + "...", "<[^>]*>", "")) ?? "Unknown")
.AddField("Release Date", app.ReleaseDate.Date ?? "Unknown", true)
.AddField("Developers", app.Developers[0] ?? "Unknown", true)
.AddField("Publisher", app.Publishers[0] ?? "Unknown", true)
.AddField("Price", (app.IsFree ? "Free" : (app.PriceOverview.FinalFormatted ?? "Unknown")), true)
.AddField("Metacritic", app.Metacritic.Score.ToString() ?? "Unknown", true)
.WithThumbnailUrl(app.HeaderImage)
.WithUrl("http://store.steampowered.com/app/" + app.SteamAppId.ToString())
.WithFooter("App ID: " + app.SteamAppId.ToString())
.WithColor(new DiscordColor("#1B2838"));
var genres = new StringBuilder();
foreach (var genre in app.Genres.Take(3))
{
genres.Append(genre.Description).Append(!genre.Equals(app.Genres.Last()) ? ", " : string.Empty);
}
output.AddField("Genres", genres.ToString() ?? "Unknown", true);
await ctx.RespondAsync(embed : output.Build()).ConfigureAwait(false);
}
catch
{
await ctx.RespondAsync("Unable to retrieve game information from the Steam API.").ConfigureAwait(false);
}
}
public FriendsAdapter(Context context)
{
this.context = context;
friends = new List <Friend>();
inflater = LayoutInflater.FromContext(context);
SteamService.GetClient().AddHandler(this);
}
protected override void OnListItemClick(ListView l, View v, int position, long id)
{
base.OnListItemClick(l, v, position, id);
EPersonaState state = stateAdapter.GetItem(position);
SteamService.GetClient().Friends.SetPersonaState(state);
}
public SteamServiceTests()
{
services = new ServicesBuilder();
_mocker = new AutoMocker();
services.Build(_mocker);
_steamService = _mocker.CreateInstance <SteamService>();
_mapsService = _mocker.CreateInstance <MapsService>();
}
public APIController(
DdbService dbdService,
SteamService steamService
)
{
_dbdService = dbdService;
_steamService = steamService;
}
public override bool OnPrepareOptionsMenu(IMenu menu)
{
bool connected = (SteamService.GetClient() != null && SteamService.GetClient().LoggedIn);
menu.GetItem(0).SetEnabled(connected);
menu.GetItem(1).SetEnabled(connected);
return(base.OnPrepareOptionsMenu(menu));
}
//private readonly Logger _log;
public GameListBZ98Service(IBotCredentials creds, /*DbService db,*/ DiscordSocketClient client, SteamService steam)
{
//_log = LogManager.GetCurrentClassLogger();
//_log.Info("GameListBZ98Service");
_creds = creds;
//_db = db;
_client = client;
_steam = steam;
}
public Friend(SteamID steamId)
{
this.steamId = steamId;
this.name = Unknown;
this.avatar = Unknown;
adapter = new ChatAdapter(this, SteamAlerts.GetContext());
SteamService.GetClient().AddHandler(this);
}
/// <summary>
/// Sends the message.
/// </summary>
/// <param name='message'>
/// Message.
/// </param>
public virtual void SendMessage(String message)
{
ChatMessage chatMessage = new ChatMessage(Friend.Me, message);
adapter.Add(chatMessage);
SteamService.GetClient().Friends.SendChatMessage(steamId, EChatEntryType.ChatMsg, message);
adapter.NotifyDataSetChanged();
}
private async Task RunAsync()
{
socketClient = new DiscordSocketClient(new DiscordSocketConfig
{
LogLevel = LogSeverity.Verbose,
AlwaysDownloadUsers = true
});
socketClient.Log += Log;
restClient = new DiscordRestClient(new DiscordRestConfig
{
LogLevel = LogSeverity.Verbose
});
restClient.Log += Log;
if (File.Exists("./update"))
{
var temp = File.ReadAllText("./update");
ulong.TryParse(temp, out updateChannel);
File.Delete("./update");
Console.WriteLine($"Found an update file! It contained [{temp}] and we got [{updateChannel}] from it!");
}
config = await Config.Load();
steam = new SteamService();
map = new ServiceCollection().AddSingleton(socketClient).AddSingleton(config).AddSingleton(steam).BuildServiceProvider();
await socketClient.LoginAsync(TokenType.Bot, config.Token);
await socketClient.StartAsync();
await restClient.LoginAsync(TokenType.Bot, config.Token);
if (File.Exists("./deadlock"))
{
Console.WriteLine("We're recovering from a deadlock.");
File.Delete("./deadlock");
(await restClient.GetUserAsync(config.OwnerId))?.SendMessageAsync($"I recovered from a deadlock.\n`{DateTime.Now.ToShortDateString()}` `{DateTime.Now.ToLongTimeString()}`");
}
socketClient.GuildAvailable += Client_GuildAvailable;
socketClient.Disconnected += SocketClient_Disconnected;
await steam.Install(map);
handler = new CommandHandler();
await handler.Install(map);
Console.WriteLine("test");
await Task.Delay(-1);
}
private void UpdateButtons()
{
bool connected = SteamService.GetClient() != null && SteamService.GetClient().LoggedIn;
Button buttonConnect = FindViewById <Button>(Resource.Id.ButtonConnect);
buttonConnect.Enabled = !connected;
Button buttonFriends = FindViewById <Button>(Resource.Id.ButtonFriends);
buttonFriends.Enabled = connected;
}
public async Task <RuntimeResult> SetSteamAsync([Remainder] string username)
{
ulong id = await SteamService.GetIdFromVanityAsync(username).ConfigureAwait(false);
var record = await UserRepository.GetOrCreateGameAsync(Context.User).ConfigureAwait(false);
record.SteamId = id;
await UserRepository.SaveRepositoryAsync().ConfigureAwait(false);
return(CommandRuntimeResult.FromSuccess(
$"Successfully set steam to {Format.Bold((await SteamService.GetProfileAsync(id).ConfigureAwait(false))?.CustomURL ?? id.ToString())}"));
}
public async Task Update(CommandContext ctx)
{
var message = await ctx.RespondAsync("Starting update...").ConfigureAwait(false);
await SteamService.UpdateSteamListAsync().ConfigureAwait(false);
await TeamFortressService.UpdateTF2SchemaAsync().ConfigureAwait(false);
await PokemonService.UpdatePokemonListAsync().ConfigureAwait(false);
await message.ModifyAsync("Starting update...done!").ConfigureAwait(false);
}
public override void Init()
{
Log.Info("Initializing Torch Client");
base.Init();
if (!File.Exists("steam_appid.txt"))
{
Directory.SetCurrentDirectory(Path.GetDirectoryName(typeof(VRage.FastResourceLock).Assembly.Location) + "\\..");
}
SpaceEngineersGame.SetupBasicGameInfo();
_startup = new MyCommonProgramStartup(RunArgs);
if (_startup.PerformReporting())
{
return;
}
_startup.PerformAutoconnect();
if (!_startup.CheckSingleInstance())
{
return;
}
var appDataPath = _startup.GetAppDataPath();
MyInitializer.InvokeBeforeRun(APP_ID, MyPerGameSettings.BasicGameInfo.ApplicationName, appDataPath);
MyInitializer.InitCheckSum();
if (!_startup.Check64Bit())
{
return;
}
_startup.DetectSharpDxLeaksBeforeRun();
using (var mySteamService = new SteamService(Game.IsDedicated, APP_ID))
{
_renderer = null;
SpaceEngineersGame.SetupPerGameSettings();
OverrideMenus();
InitializeRender();
_services = new VRageGameServices(mySteamService);
if (!Game.IsDedicated)
{
MyFileSystem.InitUserSpecific(mySteamService.UserId.ToString());
}
}
_startup.DetectSharpDxLeaksAfterRun();
MyInitializer.InvokeAfterRun();
}
public WorkspaceSettingsWindow(IServiceProvider serviceProvider, PoshConsole shellHost, Workspace workspace)
{
_shellHost = shellHost;
_workspace = workspace;
workspace.UnappliedChanges = false;
_perforce = serviceProvider.GetService <PerforceService>();
_steam = serviceProvider.GetService <SteamService>();
InitializeComponent();
MainGrid.DataContext = workspace;
BranchSelector.ItemsSource = _steam.Cache.SourceGames;
}
public override void Init()
{
Directory.SetCurrentDirectory(Program.SpaceEngineersInstallAlias);
MyFileSystem.ExePath = Path.Combine(Program.SpaceEngineersInstallAlias, Program.SpaceEngineersBinaries);
Log.Info("Initializing Torch Client");
base.Init();
SpaceEngineersGame.SetupBasicGameInfo();
_startup = new MyCommonProgramStartup(RunArgs);
if (_startup.PerformReporting())
{
throw new InvalidOperationException("Torch client won't launch when started in error reporting mode");
}
_startup.PerformAutoconnect();
if (!_startup.CheckSingleInstance())
{
throw new InvalidOperationException("Only one instance of Space Engineers can be running at a time.");
}
var appDataPath = _startup.GetAppDataPath();
MyInitializer.InvokeBeforeRun(APP_ID, MyPerGameSettings.BasicGameInfo.ApplicationName, appDataPath);
MyInitializer.InitCheckSum();
_startup.InitSplashScreen();
if (!_startup.Check64Bit())
{
throw new InvalidOperationException("Torch requires a 64bit operating system");
}
_startup.DetectSharpDxLeaksBeforeRun();
var steamService = new SteamService(Game.IsDedicated, APP_ID);
MyServiceManager.Instance.AddService <IMyGameService>(steamService);
_renderer = null;
SpaceEngineersGame.SetupPerGameSettings();
// I'm sorry, but it's what Keen does in SpaceEngineers.MyProgram
#pragma warning disable 612
SpaceEngineersGame.SetupRender();
#pragma warning restore 612
InitializeRender();
if (!_startup.CheckSteamRunning())
{
throw new InvalidOperationException("Space Engineers requires steam to be running");
}
if (!Game.IsDedicated)
{
MyFileSystem.InitUserSpecific(MyGameService.UserId.ToString());
}
}
public async Task SteamUser(CommandContext ctx,
[Description("User to find on Steam")][RemainingText] string query)
{
if (!BotServices.CheckUserInput(query))
{
return;
}
var profile = SteamService.GetSteamProfileAsync(query).Result;
var summary = SteamService.GetSteamSummaryAsync(query).Result;
if (profile is null && summary is null)
{
await BotServices.SendEmbedAsync(ctx, Resources.NOT_FOUND_GENERIC, EmbedType.Missing).ConfigureAwait(false);
}
protected override void OnPostExecute(CallbackMsg result)
{
base.OnPostExecute(result);
SteamClient client = SteamService.GetClient().Client;
if (result != null)
{
client.FreeLastCallback();
SteamService.GetClient().ProcessCallback(result);
}
new SteamCallback().Execute();
}
public async Task Install(IServiceProvider _services)
{
// Create Command Service, inject it into Dependency Map
client = _services.GetService <DiscordSocketClient>();
commands = new CommandService();
//_map.Add(commands);
services = _services;
config = _services.GetService <Config>();
steam = _services.GetService <SteamService>();
await commands.AddModulesAsync(Assembly.GetEntryAssembly(), services);
//await HelpModule.Install(commands);
client.MessageReceived += HandleCommand;
}
public SteamServiceTests()
{
_registryProviderMock = new Mock <IRegistryProvider>();
_registryProviderMock.Setup(registryProvider => registryProvider.GetValueFromKey <string>(Constants.Steam.Win32RegistryKey, Constants.Steam.InstallPathValue))
.Returns(() => _win32KeyContents);
_registryProviderMock.Setup(registryProvider => registryProvider.GetValueFromKey <string>(Constants.Steam.Win64RegistryKey, Constants.Steam.InstallPathValue))
.Returns(() => _win64KeyContents);
_fileSystemProviderMock = new Mock <IFileSystemProvider>();
_libraryFoldersParserMock = new Mock <ILibraryFoldersParser>();
_steamService = new SteamService(_registryProviderMock.Object, _fileSystemProviderMock.Object, _libraryFoldersParserMock.Object);
}
private void Connect(String authCode)
{
ISharedPreferences pref = PreferenceManager.GetDefaultSharedPreferences(this);
String username = pref.GetString("prefUsername", "");
String password = pref.GetString("prefPassword", "");
if (username.Length > 0 && password.Length > 0)
{
SteamService.GetClient().Connect(username, password, authCode);
SteamAlerts.ShowProgressDialog("Connecting", "Connecting to the Steam servers...", this);
}
else
{
SteamAlerts.ShowAlertDialog("Warning", "No valid username or password entered", this);
}
}
public MainWindow()
{
InitializeComponent();
IServiceCollection services = new ServiceCollection();
ILoggerFactory loggerFactory = new LoggerFactory();
//loggerFactory.AddEventLog();
loggerFactory.AddDebug();
// Init IPC server
var ipcServer = new IpcServer();
ipcServer.Start(App.IpcPort);
// Register the services to the container
services.AddSingleton(loggerFactory);
services.AddSingleton(ipcServer);
services.AddSingleton(typeof(SteamService));
services.AddSingleton(typeof(PerforceService));
_serviceProvider = services.BuildServiceProvider();
// Prepare services for use by the main window
_steamService = _serviceProvider.GetService <SteamService>();
_perforceService = _serviceProvider.GetService <PerforceService>();
var ipcServerTmp = _serviceProvider.GetService <IpcServer>();
// Register event handlers
ipcServerTmp.ReceivedRequest += IpcServer_ReceivedRequest;
FileSelector.FileOpened += FileSelector_FileOpened;
if (_perforceService.P4Exists)
{
P4V.IsEnabled = true;
P4Merge.IsEnabled = true;
P4Admin.IsEnabled = true;
}
// Handle command line arguments
HandleArguments(Environment.GetCommandLineArgs().Skip(1));
}
