public override async Task OnCommand(CommandArguments command)
{
if (string.IsNullOrWhiteSpace(command.Message))
{
command.Reply("Usage:{0} app <appid or partial game name>", Colors.OLIVE);
return;
}
string name;
if (!uint.TryParse(command.Message, out var appID))
{
appID = await TrySearchAppId(command);
if (appID == 0)
{
return;
}
}
var tokenTask = Steam.Instance.Apps.PICSGetAccessTokens(appID, null);
tokenTask.Timeout = TimeSpan.FromSeconds(10);
var tokenCallback = await tokenTask;
SteamApps.PICSRequest request;
if (tokenCallback.AppTokens.ContainsKey(appID))
{
request = PICSTokens.NewAppRequest(appID, tokenCallback.AppTokens[appID]);
}
else
{
request = PICSTokens.NewAppRequest(appID);
}
var infoTask = Steam.Instance.Apps.PICSGetProductInfo(new List <SteamApps.PICSRequest> {
request
}, Enumerable.Empty <SteamApps.PICSRequest>());
infoTask.Timeout = TimeSpan.FromSeconds(10);
var job = await infoTask;
var callback = job.Results.FirstOrDefault(x => x.Apps.ContainsKey(appID));
if (callback == null)
{
command.Reply("Unknown AppID: {0}{1}{2}", Colors.BLUE, appID, LicenseList.OwnedApps.ContainsKey(appID) ? SteamDB.StringCheckmark : string.Empty);
return;
}
var info = callback.Apps[appID];
if (info.KeyValues["common"]["name"].Value != null)
{
name = Utils.LimitStringLength(Utils.RemoveControlCharacters(info.KeyValues["common"]["name"].AsString()));
}
else
{
name = Steam.GetAppName(info.ID);
}
info.KeyValues.SaveToFile(Path.Combine(Application.Path, "app", string.Format("{0}.vdf", info.ID)), false);
command.Reply("{0}{1}{2} -{3} {4}{5} - Dump:{6} {7}{8}{9}{10}",
Colors.BLUE, name, Colors.NORMAL,
Colors.DARKBLUE, SteamDB.GetAppUrl(info.ID), Colors.NORMAL,
Colors.DARKBLUE, SteamDB.GetRawAppUrl(info.ID), Colors.NORMAL,
info.MissingToken ? SteamDB.StringNeedToken : string.Empty,
LicenseList.OwnedApps.ContainsKey(info.ID) ? SteamDB.StringCheckmark : string.Empty
);
if (command.IsUserAdmin && !LicenseList.OwnedApps.ContainsKey(info.ID))
{
JobManager.AddJob(() => Steam.Instance.Apps.RequestFreeLicense(info.ID));
}
}
protected override async Task ProcessData()
{
ChangeNumber = ProductInfo.ChangeNumber;
if (Settings.IsFullRun)
{
await DbConnection.ExecuteAsync("INSERT INTO `Changelists` (`ChangeID`) VALUES (@ChangeNumber) ON DUPLICATE KEY UPDATE `Date` = `Date`", new { ProductInfo.ChangeNumber });
await DbConnection.ExecuteAsync("INSERT INTO `ChangelistsApps` (`ChangeID`, `AppID`) VALUES (@ChangeNumber, @AppID) ON DUPLICATE KEY UPDATE `AppID` = `AppID`", new { AppID, ProductInfo.ChangeNumber });
}
await ProcessKey("root_changenumber", "changenumber", ChangeNumber.ToString());
var app = (await DbConnection.QueryAsync <App>("SELECT `Name`, `AppType` FROM `Apps` WHERE `AppID` = @AppID LIMIT 1", new { AppID })).SingleOrDefault();
var newAppName = ProductInfo.KeyValues["common"]["name"].AsString();
if (newAppName != null)
{
var currentType = ProductInfo.KeyValues["common"]["type"].AsString().ToLowerInvariant();
var newAppType = await DbConnection.ExecuteScalarAsync <int?>("SELECT `AppType` FROM `AppsTypes` WHERE `Name` = @Type LIMIT 1", new { Type = currentType }) ?? -1;
var modifiedNameOrType = false;
if (newAppType == -1)
{
await DbConnection.ExecuteAsync("INSERT INTO `AppsTypes` (`Name`, `DisplayName`) VALUES(@Name, @DisplayName)",
new { Name = currentType, DisplayName = ProductInfo.KeyValues["common"]["type"].AsString() }); // We don't need to lower display name
Log.WriteInfo(nameof(AppProcessor), $"Creating new apptype \"{currentType}\" (AppID {AppID})");
IRC.Instance.SendOps($"New app type: {Colors.BLUE}{currentType}{Colors.NORMAL} - {SteamDB.GetAppUrl(AppID, "history")}");
newAppType = await DbConnection.ExecuteScalarAsync <int>("SELECT `AppType` FROM `AppsTypes` WHERE `Name` = @Type LIMIT 1", new { Type = currentType });
}
if (string.IsNullOrEmpty(app.Name) || app.Name.StartsWith(SteamDB.UnknownAppName, StringComparison.Ordinal))
{
await DbConnection.ExecuteAsync("INSERT INTO `Apps` (`AppID`, `AppType`, `Name`, `LastKnownName`) VALUES (@AppID, @Type, @AppName, @AppName) ON DUPLICATE KEY UPDATE `Name` = VALUES(`Name`), `LastKnownName` = VALUES(`LastKnownName`), `AppType` = VALUES(`AppType`)",
new { AppID, Type = newAppType, AppName = newAppName }
);
await MakeHistory("created_app");
await MakeHistory("created_info", SteamDB.DatabaseNameType, string.Empty, newAppName);
modifiedNameOrType = true;
}
else if (app.Name != newAppName)
{
await DbConnection.ExecuteAsync("UPDATE `Apps` SET `Name` = @AppName, `LastKnownName` = @AppName WHERE `AppID` = @AppID", new { AppID, AppName = newAppName });
await MakeHistory("modified_info", SteamDB.DatabaseNameType, app.Name, newAppName);
modifiedNameOrType = true;
}
if (app.AppType == 0 || app.AppType != newAppType)
{
await DbConnection.ExecuteAsync("UPDATE `Apps` SET `AppType` = @Type WHERE `AppID` = @AppID", new { AppID, Type = newAppType });
if (app.AppType == 0)
{
await MakeHistory("created_info", SteamDB.DatabaseAppType, string.Empty, newAppType.ToString());
}
else
{
await MakeHistory("modified_info", SteamDB.DatabaseAppType, app.AppType.ToString(), newAppType.ToString());
}
modifiedNameOrType = true;
}
if (modifiedNameOrType)
{
if ((newAppType > 9 && newAppType != 13 && newAppType != 15 && newAppType != 17) || Triggers.Any(newAppName.Contains))
{
IRC.Instance.SendOps($"New {currentType}: {Colors.BLUE}{Utils.LimitStringLength(newAppName)}{Colors.NORMAL} -{Colors.DARKBLUE} {SteamDB.GetAppUrl(AppID, "history")}");
}
}
}
foreach (var section in ProductInfo.KeyValues.Children)
{
var sectionName = section.Name.ToLowerInvariant();
if (sectionName == "appid" || sectionName == "public_only" || sectionName == "change_number")
{
continue;
}
if (sectionName == "common" || sectionName == "extended")
{
foreach (var keyvalue in section.Children)
{
var keyName = $"{sectionName}_{keyvalue.Name}";
if (keyName == "common_type" || keyName == "common_gameid" || keyName == "common_name" || keyName == "extended_order")
{
// Ignore common keys that are either duplicated or serve no real purpose
continue;
}
if (keyvalue.Children.Count > 0)
{
await ProcessKey(keyName, keyvalue.Name, Utils.JsonifyKeyValue(keyvalue), keyvalue);
}
else if (!string.IsNullOrEmpty(keyvalue.Value))
{
await ProcessKey(keyName, keyvalue.Name, keyvalue.Value);
}
}
}
else
{
sectionName = $"root_{sectionName}";
if (await ProcessKey(sectionName, sectionName, Utils.JsonifyKeyValue(section), section) && sectionName == "root_depots")
{
await DbConnection.ExecuteAsync("UPDATE `Apps` SET `LastDepotUpdate` = CURRENT_TIMESTAMP() WHERE `AppID` = @AppID", new { AppID });
}
}
}
// If app gets hidden but we already have data, do not delete the already existing app info
if (newAppName != null)
{
foreach (var data in CurrentData.Values.Where(data => !data.Processed && !data.KeyName.StartsWith("website", StringComparison.Ordinal)))
{
await DbConnection.ExecuteAsync("DELETE FROM `AppsInfo` WHERE `AppID` = @AppID AND `Key` = @Key", new { AppID, data.Key });
await MakeHistory("removed_key", data.Key, data.Value);
}
}
else
{
if (string.IsNullOrEmpty(app.Name)) // We don't have the app in our database yet
{
await DbConnection.ExecuteAsync("INSERT INTO `Apps` (`AppID`, `Name`) VALUES (@AppID, @AppName) ON DUPLICATE KEY UPDATE `AppType` = `AppType`", new {
AppID,
AppName = $"{SteamDB.UnknownAppName} {AppID}"
});
}
else if (!app.Name.StartsWith(SteamDB.UnknownAppName, StringComparison.Ordinal)) // We do have the app, replace it with default name
{
await DbConnection.ExecuteAsync("UPDATE `Apps` SET `Name` = @AppName, `AppType` = 0 WHERE `AppID` = @AppID", new {
AppID,
AppName = $"{SteamDB.UnknownAppName} {AppID}"
});
await MakeHistory("deleted_app", 0, app.Name);
}
}
// Close the connection as it's no longer needed going into depot processor
DbConnection.Close();
if (ProductInfo.KeyValues["depots"].Children.Any())
{
await Steam.Instance.DepotProcessor.Process(AppID, ChangeNumber, ProductInfo.KeyValues["depots"]);
}
if (ProductInfo.MissingToken && PICSTokens.HasAppToken(AppID))
{
Log.WriteError(nameof(PICSTokens), $"Overridden token for appid {AppID} is invalid?");
IRC.Instance.SendOps($"[Tokens] Looks like the overridden token for appid {AppID} ({newAppName}) is invalid");
}
}
public override async Task OnCommand(CommandArguments command)
{
await Task.Yield();
if (command.CommandType != ECommandType.IRC || !IRC.IsRecipientChannel(command.Recipient))
{
command.Reply("This command is only available in channels.");
return;
}
var channel = command.Recipient;
var s = command.Message.Split(' ');
var count = s.Length;
if (count > 0)
{
uint id;
switch (s[0])
{
case "reload":
Application.ReloadImportant(command);
PICSTokens.Reload(command);
FileDownloader.ReloadFileList();
return;
case "add":
if (count < 3)
{
break;
}
if (!uint.TryParse(s[2], out id))
{
break;
}
switch (s[1])
{
case "app":
List <string> channels;
var exists = Application.ImportantApps.TryGetValue(id, out channels);
if (exists && channels.Contains(channel))
{
command.Reply("App {0}{1}{2} ({3}) is already important in {4}{5}{6}.", Colors.BLUE, id, Colors.NORMAL, Steam.GetAppName(id), Colors.BLUE, channel, Colors.NORMAL);
}
else
{
if (exists)
{
Application.ImportantApps[id].Add(channel);
}
else
{
Application.ImportantApps.Add(id, new List <string> {
channel
});
}
using (var db = Database.GetConnection())
{
db.Execute("INSERT INTO `ImportantApps` (`AppID`, `Channel`) VALUES (@AppID, @Channel)", new { AppID = id, Channel = channel });
}
command.Reply("Marked app {0}{1}{2} ({3}) as important in {4}{5}{6}.", Colors.BLUE, id, Colors.NORMAL, Steam.GetAppName(id), Colors.BLUE, channel, Colors.NORMAL);
}
return;
case "sub":
if (Application.ImportantSubs.ContainsKey(id))
{
command.Reply("Package {0}{1}{2} ({3}) is already important.", Colors.BLUE, id, Colors.NORMAL, Steam.GetPackageName(id));
}
else
{
Application.ImportantSubs.Add(id, 1);
using (var db = Database.GetConnection())
{
db.Execute("INSERT INTO `ImportantSubs` (`SubID`) VALUES (@SubID)", new { SubID = id });
}
command.Reply("Marked package {0}{1}{2} ({3}) as important.", Colors.BLUE, id, Colors.NORMAL, Steam.GetPackageName(id));
}
return;
}
break;
case "remove":
if (count < 3)
{
break;
}
if (!uint.TryParse(s[2], out id))
{
break;
}
switch (s[1])
{
case "app":
List <string> channels;
if (!Application.ImportantApps.TryGetValue(id, out channels) || !channels.Contains(channel))
{
command.Reply("App {0}{1}{2} ({3}) is not important in {4}{5}{6}.", Colors.BLUE, id, Colors.NORMAL, Steam.GetAppName(id), Colors.BLUE, channel, Colors.NORMAL);
}
else
{
if (channels.Count > 1)
{
Application.ImportantApps[id].Remove(channel);
}
else
{
Application.ImportantApps.Remove(id);
}
using (var db = Database.GetConnection())
{
db.Execute("DELETE FROM `ImportantApps` WHERE `AppID` = @AppID AND `Channel` = @Channel", new { AppID = id, Channel = channel });
}
command.Reply("Removed app {0}{1}{2} ({3}) from the important list in {4}{5}{6}.", Colors.BLUE, id, Colors.NORMAL, Steam.GetAppName(id), Colors.BLUE, channel, Colors.NORMAL);
}
return;
case "sub":
if (!Application.ImportantSubs.ContainsKey(id))
{
command.Reply("Package {0}{1}{2} ({3}) is not important.", Colors.BLUE, id, Colors.NORMAL, Steam.GetPackageName(id));
}
else
{
Application.ImportantSubs.Remove(id);
using (var db = Database.GetConnection())
{
db.Execute("DELETE FROM `ImportantSubs` WHERE `SubID` = @SubID", new { SubID = id });
}
command.Reply("Removed package {0}{1}{2} ({3}) from the important list.", Colors.BLUE, id, Colors.NORMAL, Steam.GetPackageName(id));
}
return;
}
break;
}
}
command.Reply("Usage:{0} important reload {1}or{2} important <add/remove> <app/sub> <id>", Colors.OLIVE, Colors.NORMAL, Colors.OLIVE);
}
protected override async Task ProcessData()
{
await LoadData();
ChangeNumber = ProductInfo.ChangeNumber;
if (Settings.IsFullRun)
{
await DbConnection.ExecuteAsync("INSERT INTO `Changelists` (`ChangeID`) VALUES (@ChangeNumber) ON DUPLICATE KEY UPDATE `Date` = `Date`", new { ProductInfo.ChangeNumber });
await DbConnection.ExecuteAsync("INSERT INTO `ChangelistsSubs` (`ChangeID`, `SubID`) VALUES (@ChangeNumber, @SubID) ON DUPLICATE KEY UPDATE `SubID` = `SubID`", new { SubID, ProductInfo.ChangeNumber });
}
await ProcessKey("root_changenumber", "changenumber", ChangeNumber.ToString());
var appAddedToThisPackage = false;
var packageOwned = LicenseList.OwnedSubs.ContainsKey(SubID);
var newPackageName = ProductInfo.KeyValues["name"].AsString();
var apps = (await DbConnection.QueryAsync <PackageApp>("SELECT `AppID`, `Type` FROM `SubsApps` WHERE `SubID` = @SubID", new { SubID })).ToDictionary(x => x.AppID, x => x.Type);
var alreadySeenAppIds = new HashSet <uint>();
// TODO: Ideally this should be SteamDB Unknown Package and proper checks like app processor does
if (newPackageName == null)
{
newPackageName = string.Concat("Steam Sub ", SubID);
}
if (string.IsNullOrEmpty(PackageName))
{
await DbConnection.ExecuteAsync("INSERT INTO `Subs` (`SubID`, `Name`, `LastKnownName`) VALUES (@SubID, @Name, @Name)", new { SubID, Name = newPackageName });
await MakeHistory("created_sub");
await MakeHistory("created_info", SteamDB.DATABASE_NAME_TYPE, string.Empty, newPackageName);
}
else if (PackageName != newPackageName)
{
if (newPackageName.StartsWith("Steam Sub ", StringComparison.Ordinal))
{
await DbConnection.ExecuteAsync("UPDATE `Subs` SET `Name` = @Name WHERE `SubID` = @SubID", new { SubID, Name = newPackageName });
}
else
{
await DbConnection.ExecuteAsync("UPDATE `Subs` SET `Name` = @Name, `LastKnownName` = @Name WHERE `SubID` = @SubID", new { SubID, Name = newPackageName });
}
await MakeHistory("modified_info", SteamDB.DATABASE_NAME_TYPE, PackageName, newPackageName);
}
foreach (var section in ProductInfo.KeyValues.Children)
{
var sectionName = section.Name.ToLowerInvariant();
if (string.IsNullOrEmpty(sectionName) || sectionName == "packageid" || sectionName == "changenumber" || sectionName == "name")
{
// Ignore common keys
continue;
}
if (sectionName == "appids" || sectionName == "depotids")
{
// Remove "ids", so we get "app" from appids and "depot" from depotids
var type = sectionName.Replace("ids", string.Empty);
var isAppSection = type == "app";
var typeID = (uint)(isAppSection ? 0 : 1); // 0 = app, 1 = depot; can't store as string because it's in the `key` field
foreach (var childrenApp in section.Children)
{
if (!uint.TryParse(childrenApp.Value, out var appID))
{
Log.WriteWarn("Sub Processor", $"Package {SubID} has an invalid uint: {childrenApp.Value}");
continue;
}
if (alreadySeenAppIds.Contains(appID))
{
Log.WriteWarn("Sub Processor", $"Package {SubID} has a duplicate app: {appID}");
continue;
}
alreadySeenAppIds.Add(appID);
// Is this appid already in this package?
if (apps.ContainsKey(appID))
{
// Is this appid's type the same?
if (apps[appID] != type)
{
await DbConnection.ExecuteAsync("UPDATE `SubsApps` SET `Type` = @Type WHERE `SubID` = @SubID AND `AppID` = @AppID", new { SubID, AppID = appID, Type = type });
await MakeHistory("added_to_sub", typeID, apps[appID] == "app"? "0" : "1", childrenApp.Value);
appAddedToThisPackage = true;
// Log relevant add/remove history events for depot and app
var appHistory = new PICSHistory
{
ID = appID,
ChangeID = ChangeNumber,
};
if (isAppSection)
{
appHistory.NewValue = SubID.ToString();
appHistory.Action = "added_to_sub";
}
else
{
appHistory.OldValue = SubID.ToString();
appHistory.Action = "removed_from_sub";
}
await DbConnection.ExecuteAsync(AppProcessor.HistoryQuery, appHistory);
var depotHistory = new DepotHistory
{
DepotID = appID,
ManifestID = 0,
ChangeID = ChangeNumber,
OldValue = SubID,
Action = isAppSection ? "removed_from_sub" : "added_to_sub"
};
if (isAppSection)
{
depotHistory.OldValue = SubID;
depotHistory.Action = "removed_from_sub";
}
else
{
depotHistory.NewValue = SubID;
depotHistory.Action = "added_to_sub";
}
await DbConnection.ExecuteAsync(DepotProcessor.HistoryQuery, depotHistory);
}
apps.Remove(appID);
}
else
{
await DbConnection.ExecuteAsync("INSERT INTO `SubsApps` (`SubID`, `AppID`, `Type`) VALUES(@SubID, @AppID, @Type)", new { SubID, AppID = appID, Type = type });
await MakeHistory("added_to_sub", typeID, string.Empty, childrenApp.Value);
if (isAppSection)
{
await DbConnection.ExecuteAsync(AppProcessor.HistoryQuery,
new PICSHistory
{
ID = appID,
ChangeID = ChangeNumber,
NewValue = SubID.ToString(),
Action = "added_to_sub"
}
);
}
else
{
await DbConnection.ExecuteAsync(DepotProcessor.HistoryQuery,
new DepotHistory
{
DepotID = appID,
ManifestID = 0,
ChangeID = ChangeNumber,
NewValue = SubID,
Action = "added_to_sub"
}
);
}
appAddedToThisPackage = true;
if (packageOwned && !LicenseList.OwnedApps.ContainsKey(appID))
{
LicenseList.OwnedApps.Add(appID, 1);
}
}
}
}
else if (sectionName == "extended")
{
foreach (var children in section.Children)
{
var keyName = string.Format("{0}_{1}", sectionName, children.Name);
if (children.Children.Count > 0)
{
await ProcessKey(keyName, children.Name, Utils.JsonifyKeyValue(children), true);
}
else
{
await ProcessKey(keyName, children.Name, children.Value);
}
}
}
else if (section.Children.Count > 0)
{
sectionName = string.Format("root_{0}", sectionName);
await ProcessKey(sectionName, sectionName, Utils.JsonifyKeyValue(section), true);
}
else if (!string.IsNullOrEmpty(section.Value))
{
var keyName = string.Format("root_{0}", sectionName);
await ProcessKey(keyName, sectionName, section.Value);
}
}
foreach (var data in CurrentData.Values.Where(data => !data.Processed && !data.KeyName.StartsWith("website", StringComparison.Ordinal)))
{
await DbConnection.ExecuteAsync("DELETE FROM `SubsInfo` WHERE `SubID` = @SubID AND `Key` = @Key", new { SubID, data.Key });
await MakeHistory("removed_key", data.Key, data.Value);
}
var appsRemoved = apps.Count > 0;
foreach (var app in apps)
{
await DbConnection.ExecuteAsync("DELETE FROM `SubsApps` WHERE `SubID` = @SubID AND `AppID` = @AppID AND `Type` = @Type", new { SubID, AppID = app.Key, Type = app.Value });
var isAppSection = app.Value == "app";
var typeID = (uint)(isAppSection ? 0 : 1); // 0 = app, 1 = depot; can't store as string because it's in the `key` field
await MakeHistory("removed_from_sub", typeID, app.Key.ToString());
if (isAppSection)
{
await DbConnection.ExecuteAsync(AppProcessor.HistoryQuery,
new PICSHistory
{
ID = app.Key,
ChangeID = ChangeNumber,
OldValue = SubID.ToString(),
Action = "removed_from_sub"
}
);
}
else
{
await DbConnection.ExecuteAsync(DepotProcessor.HistoryQuery,
new DepotHistory
{
DepotID = app.Key,
ManifestID = 0,
ChangeID = ChangeNumber,
OldValue = SubID,
Action = "removed_from_sub"
}
);
}
}
if (appsRemoved)
{
LicenseList.RefreshApps();
}
if (!packageOwned && SubID != 17906 && Settings.Current.CanQueryStore)
{
FreeLicense.RequestFromPackage(SubID, ProductInfo.KeyValues);
}
// Re-queue apps in this package so we can update depots and whatnot
if (appAddedToThisPackage && !Settings.IsFullRun && !string.IsNullOrEmpty(PackageName))
{
JobManager.AddJob(() => Steam.Instance.Apps.PICSGetAccessTokens(ProductInfo.KeyValues["appids"].Children.Select(x => (uint)x.AsInteger()), Enumerable.Empty <uint>()));
}
if (ProductInfo.MissingToken && PICSTokens.HasPackageToken(SubID))
{
Log.WriteError(nameof(PICSTokens), $"Overriden token for subid {SubID} is invalid?");
IRC.Instance.SendOps($"[Tokens] Looks like the overriden token for subid {SubID} ({newPackageName}) is invalid");
}
}
public override async Task OnCommand(CommandArguments command)
{
var s = command.Message.Split(' ');
var count = s.Length;
if (count > 0)
{
uint id;
switch (s[0])
{
case "reload":
await Application.ReloadImportant();
await PICSTokens.Reload();
command.Notice("Reloaded important apps and pics tokens");
return;
case "fullrun":
_ = TaskManager.Run(async() =>
{
command.Reply("Started full metadata scan, this will take a while…");
await FullUpdateProcessor.FullUpdateAppsMetadata(true);
command.Reply("App full scan finished, starting packages, this will take even longer…");
await FullUpdateProcessor.FullUpdatePackagesMetadata();
command.Reply("Full metadata scan finished.");
});
return;
case "add":
if (count < 3)
{
break;
}
if (!uint.TryParse(s[2], out id))
{
break;
}
switch (s[1])
{
case "app":
if (Application.ImportantApps.Contains(id))
{
command.Reply($"App {Colors.BLUE}{id}{Colors.NORMAL} ({Steam.GetAppName(id)}) is already important.");
}
else
{
Application.ImportantApps.Add(id);
await using (var db = await Database.GetConnectionAsync())
{
await db.ExecuteAsync("INSERT INTO `ImportantApps` (`AppID`) VALUES (@AppID)", new { AppID = id });
}
command.Reply($"Marked app {Colors.BLUE}{id}{Colors.NORMAL} ({Steam.GetAppName(id)}) as important.");
}
return;
case "sub":
if (Application.ImportantSubs.Contains(id))
{
command.Reply($"Package {Colors.BLUE}{id}{Colors.NORMAL} ({Steam.GetPackageName(id)}) is already important.");
}
else
{
Application.ImportantSubs.Add(id);
await using (var db = await Database.GetConnectionAsync())
{
await db.ExecuteAsync("INSERT INTO `ImportantSubs` (`SubID`) VALUES (@SubID)", new { SubID = id });
}
command.Reply($"Marked package {Colors.BLUE}{id}{Colors.NORMAL} ({Steam.GetPackageName(id)}) as important.");
}
return;
}
break;
case "remove":
if (count < 3)
{
break;
}
if (!uint.TryParse(s[2], out id))
{
break;
}
switch (s[1])
{
case "app":
if (!Application.ImportantApps.Contains(id))
{
command.Reply($"App {Colors.BLUE}{id}{Colors.NORMAL} ({Steam.GetAppName(id)}) is not important.");
}
else
{
Application.ImportantApps.Remove(id);
await using (var db = await Database.GetConnectionAsync())
{
await db.ExecuteAsync("DELETE FROM `ImportantApps` WHERE `AppID` = @AppID", new { AppID = id });
}
command.Reply($"Removed app {Colors.BLUE}{id}{Colors.NORMAL} ({Steam.GetAppName(id)}) from the important list.");
}
return;
case "sub":
if (!Application.ImportantSubs.Contains(id))
{
command.Reply($"Package {Colors.BLUE}{id}{Colors.NORMAL} ({Steam.GetPackageName(id)}) is not important.");
}
else
{
Application.ImportantSubs.Remove(id);
await using (var db = await Database.GetConnectionAsync())
{
await db.ExecuteAsync("DELETE FROM `ImportantSubs` WHERE `SubID` = @SubID", new { SubID = id });
}
command.Reply($"Removed package {Colors.BLUE}{id}{Colors.NORMAL} ({Steam.GetPackageName(id)}) from the important list.");
}
return;
}
break;
}
}
command.Reply($"Usage:{Colors.OLIVE} important reload {Colors.NORMAL}or{Colors.OLIVE} important <add/remove> <app/sub> <id> {Colors.NORMAL}or{Colors.OLIVE} important fullrun");
}
public static SteamApps.PICSRequest NewPICSRequest(uint id)
{
return(new SteamApps.PICSRequest(id, PICSTokens.GetToken(id), false));
}
private static void OnLicenseListCallback(SteamApps.LicenseListCallback licenseList)
{
if (licenseList.Result != EResult.OK)
{
Log.WriteError(nameof(LicenseList), $"Failed: {licenseList.Result}");
return;
}
Log.WriteInfo(nameof(LicenseList), $"Received {licenseList.LicenseList.Count} licenses from Steam");
if (licenseList.LicenseList.Count == 0)
{
return;
}
var ownedSubs = new Dictionary <uint, byte>();
var newSubs = new List <uint>();
var hasAnyLicense = OwnedSubs.Count > 0;
foreach (var license in licenseList.LicenseList)
{
if (license.AccessToken > 0)
{
PICSTokens.NewPackageRequest(license.PackageID, license.AccessToken);
}
// Expired licenses block access to depots, so we have no use in these
if ((license.LicenseFlags & ELicenseFlags.Expired) != 0)
{
continue;
}
// For some obscure reason license list can contain duplicates
if (ownedSubs.ContainsKey(license.PackageID))
{
#if DEBUG
Log.WriteWarn(nameof(LicenseList), $"Already contains {license.PackageID} ({license.PaymentMethod})");
#endif
continue;
}
if (hasAnyLicense && !OwnedSubs.ContainsKey(license.PackageID))
{
Log.WriteInfo(nameof(LicenseList), $"New license granted: {license.PackageID} ({license.PaymentMethod}, {license.LicenseFlags})");
newSubs.Add(license.PackageID);
}
if (Steam.Instance.FreeLicense.FreeLicensesToRequest.TryRemove(license.PackageID, out _))
{
Log.WriteInfo(nameof(FreeLicense), $"Package {license.PackageID} was granted, removed from free request");
}
ownedSubs.Add(license.PackageID, (byte)license.PaymentMethod);
}
OwnedSubs = ownedSubs;
RefreshApps();
if (newSubs.Count <= 0)
{
return;
}
using var db = Database.Get();
var apps = db.Query <uint>("SELECT `AppID` FROM `SubsApps` WHERE `Type` = \"app\" AND `SubID` IN @Ids", new { Ids = newSubs }).ToList();
JobManager.AddJob(
() => Steam.Instance.Apps.PICSGetAccessTokens(apps, newSubs),
new PICSTokens.RequestedTokens
{
Apps = apps,
Packages = newSubs,
});
}
