Merge pull request #55 from MarkKoz/master

Added Support for the GetPublishedFileDetails Endpoint.

Author: Justin Skiles

src/SteamWebAPI2/AutoMapperConfiguration.cs

@@ -108,6 +108,8 @@ public static void Initialize()
                     CreateSteamWebResponseMap<AssetClassInfoResultContainer, AssetClassInfoResultModel>(x);
                     CreateSteamWebResponseMap<AssetPriceResultContainer, AssetPriceResultModel>(x);
                     CreateSteamWebResponseMap<SteamNewsResultContainer, SteamNewsResultModel>(x);
+                    CreateSteamWebResponseMap<PublishedFileDetailsResultContainer, IReadOnlyCollection<PublishedFileDetailsModel>>(x);
+                    CreateSteamWebResponseMap<PublishedFileDetailsResultContainer, PublishedFileDetailsModel>(x);
                     CreateSteamWebResponseMap<UGCFileDetailsResultContainer, UGCFileDetailsModel>(x);
                     CreateSteamWebResponseMap<PlayerSummaryResultContainer, PlayerSummaryModel>(x);
                     CreateSteamWebResponseMap<PlayerSummaryResultContainer, IReadOnlyCollection<PlayerSummaryModel>>(x);
@@ -380,6 +382,21 @@ public static void Initialize()
 
                     #region Endpoint: SteamRemoteStorage
 
+                    x.CreateMap<uint, PublishedFileVisibility>();
+                    x.CreateMap<PublishedFileDetails, PublishedFileDetailsModel>()
+                        .ForMember(dest => dest.FileUrl, opts => opts.MapFrom(source => new Uri(source.FileUrl)))
+                        .ForMember(dest => dest.PreviewUrl, opts => opts.MapFrom(source => new Uri(source.PreviewUrl)));
+                    x.CreateMap<PublishedFileDetailsResultContainer, IReadOnlyCollection<PublishedFileDetailsModel>>()
+                        .ConvertUsing(
+                            src => Mapper.Map<IList<PublishedFileDetails>, IReadOnlyCollection<PublishedFileDetailsModel>>(
+                                src.Result?.Result == 1 ? src.Result.Details : null)
+                    );
+                    x.CreateMap<PublishedFileDetailsResultContainer, PublishedFileDetailsModel>()
+                        .ConvertUsing(
+                            src => Mapper.Map<PublishedFileDetails, PublishedFileDetailsModel>(
+                                src.Result?.Result == 1 ? src.Result.Details?.SingleOrDefault() : null)
+                        );
+
                     x.CreateMap<UGCFileDetails, UGCFileDetailsModel>();
                     x.CreateMap<UGCFileDetailsResultContainer, UGCFileDetailsModel>().ConvertUsing(
                         src => Mapper.Map<UGCFileDetails, UGCFileDetailsModel>(src.Result)

src/SteamWebAPI2/Interfaces/ISteamRemoteStorage.cs

@@ -4,8 +4,16 @@
 
 namespace SteamWebAPI2.Interfaces
 {
+    using System.Collections.Generic;
+
     public interface ISteamRemoteStorage
     {
+        Task<ISteamWebResponse<IReadOnlyCollection<PublishedFileDetailsModel>>> GetPublishedFileDetailsAsync(uint itemCount, IList<ulong> publishedFileIds);
+
+        Task<ISteamWebResponse<IReadOnlyCollection<PublishedFileDetailsModel>>> GetPublishedFileDetailsAsync(IList<ulong> publishedFileIds);
+
+        Task<ISteamWebResponse<PublishedFileDetailsModel>> GetPublishedFileDetailsAsync(ulong publishedFileId);
+
         Task<ISteamWebResponse<UGCFileDetailsModel>> GetUGCFileDetailsAsync(ulong ugcId, uint appId, ulong? steamId = null);
     }
 }

src/SteamWebAPI2/Interfaces/SteamRemoteStorage.cs

@@ -1,8 +1,10 @@
 using Steam.Models;
 using SteamWebAPI2.Models;
 using SteamWebAPI2.Utilities;
+using System;
 using System.Collections.Generic;
 using System.Diagnostics;
+using System.Linq;
 using System.Net.Http;
 using System.Threading.Tasks;
 
@@ -23,6 +25,74 @@ public SteamRemoteStorage(string steamWebApiKey, ISteamWebInterface steamWebInte
                 : steamWebInterface;
         }
 
+        /// <summary>
+        /// Retrieves information about published files such as workshop items and screenshots.
+        /// </summary>
+        /// <param name="itemCount">The quantity of items for which to retrieve details.
+        /// This can be smaller than the amount of items in <paramref name="publishedFileIds"/>, but not larger.</param>
+        /// <param name="publishedFileIds">The list of IDs of files for which to retrieve details.</param>
+        /// <returns>A collection of the details of each file or <c>null</c> if the request failed.</returns>
+        /// <exception cref="ArgumentNullException">Thrown when <paramref name="publishedFileIds"/> is null.</exception>
+        /// <exception cref="ArgumentOutOfRangeException">Thrown when <paramref name="publishedFileIds"/> is empty or <paramref name="itemCount"/>is greater than the number of elements in <paramref name="publishedFileIds"/>.</exception>
+        public async Task<ISteamWebResponse<IReadOnlyCollection<PublishedFileDetailsModel>>> GetPublishedFileDetailsAsync(uint itemCount, IList<ulong> publishedFileIds) {
+            if (publishedFileIds == null)
+            {
+                throw new ArgumentNullException(nameof(publishedFileIds));
+            }
+
+            if (!publishedFileIds.Any())
+            {
+                throw new ArgumentOutOfRangeException(nameof(publishedFileIds), $"{nameof(publishedFileIds)} is empty.");
+            }
+
+            if (itemCount > publishedFileIds.Count)
+            {
+                throw new ArgumentOutOfRangeException(nameof(itemCount), itemCount, $"{nameof(itemCount)} cannot be greater than the number of elements in {nameof(publishedFileIds)}.");
+            }
+
+            List<SteamWebRequestParameter> parameters = new List<SteamWebRequestParameter>();
+            parameters.AddIfHasValue(itemCount, "itemcount");
+
+            for (int i = 0; i < publishedFileIds.Count; ++i)
+            {
+                parameters.AddIfHasValue(publishedFileIds[i], $"publishedfileids[{i}]");
+            }
+
+            return await GetPublishedFileDetailsAsync<IReadOnlyCollection<PublishedFileDetailsModel>>(parameters);
+        }
+
+        /// <summary>
+        /// Retrieves information about published files such as workshop items and screenshots.
+        /// </summary>
+        /// <param name="publishedFileIds">The list of IDs of files for which to retrieve details.</param>
+        /// <returns>A collection of the details of each file or <c>null</c> if the request failed.</returns>
+        /// <exception cref="ArgumentNullException">Thrown when <paramref name="publishedFileIds"/> is null.</exception>
+        /// <exception cref="ArgumentOutOfRangeException">Thrown when <paramref name="publishedFileIds"/> is empty.</exception>
+        public async Task<ISteamWebResponse<IReadOnlyCollection<PublishedFileDetailsModel>>> GetPublishedFileDetailsAsync(IList<ulong> publishedFileIds)
+        {
+            if (publishedFileIds == null)
+            {
+                throw new ArgumentNullException(nameof(publishedFileIds));
+            }
+
+            return await GetPublishedFileDetailsAsync((uint)publishedFileIds.Count, publishedFileIds);
+        }
+
+        /// <summary>
+        /// Retrieves information about a published file such as a workshop item or screenshot.
+        /// </summary>
+        /// <param name="publishedFileId">The ID of the file for which to retrieve details.</param>
+        /// <returns>The details of the file or <c>null</c> if the request failed.</returns>
+        public async Task<ISteamWebResponse<PublishedFileDetailsModel>> GetPublishedFileDetailsAsync(ulong publishedFileId)
+        {
+            List<SteamWebRequestParameter> parameters = new List<SteamWebRequestParameter>();
+
+            parameters.AddIfHasValue(1, "itemcount");
+            parameters.AddIfHasValue(publishedFileId, "publishedfileids[0]");
+
+            return await GetPublishedFileDetailsAsync<PublishedFileDetailsModel>(parameters);
+        }
+
         /// <summary>
         /// Returns information about how to download a user generated content based on a UGC ID, App ID, and Steam ID.
         /// </summary>
@@ -45,7 +115,7 @@ public async Task<ISteamWebResponse<UGCFileDetailsModel>> GetUGCFileDetailsAsync
                 var steamWebResponse = await steamWebInterface.GetAsync<UGCFileDetailsResultContainer>("GetUGCFileDetails", 1, parameters);
 
                 var steamWebResponseModel = AutoMapperConfiguration.Mapper.Map<
-                    ISteamWebResponse<UGCFileDetailsResultContainer>, 
+                    ISteamWebResponse<UGCFileDetailsResultContainer>,
                     ISteamWebResponse<UGCFileDetailsModel>>(steamWebResponse);
 
                 return steamWebResponseModel;
@@ -55,5 +125,28 @@ public async Task<ISteamWebResponse<UGCFileDetailsModel>> GetUGCFileDetailsAsync
                 return null;
             }
         }
+
+        /// <summary>
+        /// Sends a request to GetPublishedFileDetails and maps the response's data to <typeparamref name="TData"/>.
+        /// </summary>
+        /// <typeparam name="TData">The type to which to map the data of the response.</typeparam>
+        /// <param name="parameters">The parameters of the request.</param>
+        /// <returns>The response of the request to the API or <c>null</c> if the request failed.</returns>
+        private async Task<ISteamWebResponse<TData>> GetPublishedFileDetailsAsync<TData>(IList<SteamWebRequestParameter> parameters) {
+            try
+            {
+                var steamWebResponse = await steamWebInterface.PostAsync<PublishedFileDetailsResultContainer>("GetPublishedFileDetails", 1, parameters);
+
+                var steamWebResponseModel = AutoMapperConfiguration.Mapper.Map<
+                    ISteamWebResponse<PublishedFileDetailsResultContainer>,
+                    ISteamWebResponse<TData>>(steamWebResponse);
+
+                return steamWebResponseModel;
+            }
+            catch (HttpRequestException)
+            {
+                return null;
+            }
+        }
     }
 }

src/SteamWebAPI2/Models/PublishedFileDetailsResultContainer.cs

@@ -0,0 +1,105 @@
+using System;
+using System.Collections.Generic;
+
+using Newtonsoft.Json;
+
+namespace SteamWebAPI2.Models
+{
+    using SteamWebAPI2.Utilities.JsonConverters;
+
+    internal class PublishedFileDetailsResultContainer
+    {
+        [JsonProperty("response")]
+        public PublishedFileDetailsResult Result { get; set; }
+    }
+
+    internal class PublishedFileDetailsResult
+    {
+        [JsonProperty("result")]
+        public uint Result { get; set; }
+
+        [JsonProperty("resultcount")]
+        public uint Count { get; set; }
+
+        [JsonProperty("publishedfiledetails")]
+        public IList<PublishedFileDetails> Details { get; set; }
+    }
+
+    internal class PublishedFileDetails
+    {
+        [JsonProperty("publishedfileid")]
+        public ulong PublishedFileId { get; set; }
+
+        [JsonProperty("result")]
+        public uint Result { get; set; }
+
+        [JsonProperty("creator")]
+        public ulong Creator { get; set; }
+
+        [JsonProperty("creator_app_id")]
+        public uint CreatorAppId { get; set; }
+
+        [JsonProperty("consumer_app_id")]
+        public uint ConsumerAppId { get; set; }
+
+        [JsonProperty("filename")]
+        public string FileName { get; set; }
+
+        [JsonProperty("file_size")]
+        public uint FileSize { get; set; }
+
+        [JsonProperty("file_url")]
+        public string FileUrl { get; set; }
+
+        [JsonProperty("hcontent_file")]
+        public ulong FileContentHandle { get; set; }
+
+        [JsonProperty("preview_url")]
+        public string PreviewUrl { get; set; }
+
+        [JsonProperty("hcontent_preview")]
+        public ulong PreviewContentHandle { get; set; }
+
+        [JsonProperty("title")]
+        public string Title { get; set; }
+
+        [JsonProperty("description")]
+        public string Description { get; set; }
+
+        [JsonProperty("time_created")]
+        [JsonConverter(typeof(UnixTimeJsonConverter))]
+        public DateTime TimeCreated { get; set; }
+
+        [JsonProperty("time_updated")]
+        [JsonConverter(typeof(UnixTimeJsonConverter))]
+        public DateTime TimeUpdated { get; set; }
+
+        [JsonProperty("visibility")]
+        public uint Visibility { get; set; }
+
+        [JsonProperty("banned")]
+        public bool Banned { get; set; }
+
+        [JsonProperty("ban_reason")]
+        public string BanReason { get; set; }
+
+        [JsonProperty("subscriptions")]
+        public ulong Subscriptions { get; set; }
+
+        [JsonProperty("favorited")]
+        public ulong Favorited { get; set; }
+
+        [JsonProperty("lifetime_subscriptions")]
+        public ulong LifetimeSubscriptions { get; set; }
+
+        [JsonProperty("lifetime_favorited")]
+        public ulong LifetimeFavorited { get; set; }
+
+        [JsonProperty("views")]
+        public ulong Views { get; set; }
+
+        [JsonProperty("tags")]
+        [JsonConverter(typeof(TagsJsonConverter))]
+        public IList<string> Tags { get; set; }
+    }
+}

src/SteamWebAPI2/SteamWebAPI2.csproj

@@ -14,7 +14,7 @@
   <ItemGroup>
     <PackageReference Include="automapper" Version="6.1.1" />
     <PackageReference Include="newtonsoft.json" Version="10.0.3" />
-    <PackageReference Include="Steam.Models" Version="3.0.4" />
+    <PackageReference Include="Steam.Models" Version="3.0.6" />
   </ItemGroup>
 
 </Project>

src/SteamWebAPI2/Utilities/ISteamWebHttpClient.cs

@@ -8,15 +8,16 @@ public interface ISteamWebHttpClient
         /// <summary>
         /// Performs an HTTP GET with the passed URL command.
         /// </summary>
-        /// <param name="command">URL command for GET operation</param>
+        /// <param name="uri">URL command for GET operation</param>
         /// <returns>String response such as JSON or XML</returns>
         Task<HttpResponseMessage> GetAsync(string uri);
 
         /// <summary>
         /// Performs an HTTP POST with the passed URL command.
         /// </summary>
-        /// <param name="command">URL command for POST operation</param>
+        /// <param name="uri">URL command for POST operation</param>
+        /// <param name="content">The HTTP request content sent to the server.</param>
         /// <returns>String response such as JSON or XML</returns>
-        Task<HttpResponseMessage> PostAsync(string uri);
+        Task<HttpResponseMessage> PostAsync(string uri, HttpContent content);
     }
 }

src/SteamWebAPI2/Utilities/JsonConverters/TagsJsonConverter.cs

@@ -0,0 +1,38 @@
+using System;
+using System.Collections.Generic;
+using System.Reflection;
+
+using Newtonsoft.Json;
+
+namespace SteamWebAPI2.Utilities.JsonConverters
+{
+    /// <inheritdoc />
+    /// <summary>
+    /// Converts the tags stored in a list of dictionaries to a list of the values of the dictionary.
+    /// <remarks>The keys seem to always be the string "tag".</remarks>
+    /// </summary>
+    internal class TagsJsonConverter : JsonConverter
+    {
+        public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
+        {
+            throw new NotImplementedException();
+        }
+
+        public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
+        {
+            var original = serializer.Deserialize<List<Dictionary<string, string>>>(reader);
+            var tags = new List<string>();
+
+            original.ForEach(tag => tags.AddRange(tag.Values));
+
+            return tags;
+        }
+
+        public override bool CanWrite => false;
+
+        public override bool CanConvert(Type objectType)
+        {
+            return typeof(IList<IDictionary<string, string>>).GetTypeInfo().IsAssignableFrom(objectType.GetTypeInfo());
+        }
+    }
+}

src/SteamWebAPI2/Utilities/SteamWebHttpClient.cs

@@ -38,15 +38,16 @@ public async Task<HttpResponseMessage> GetAsync(string command)
         /// Performs an HTTP POST with the passed URL command.
         /// </summary>
         /// <param name="command">URL command for POST operation</param>
+        /// <param name="content">The HTTP request content sent to the server.</param>
         /// <returns>String response such as JSON or XML</returns>
-        public async Task<HttpResponseMessage> PostAsync(string command)
+        public async Task<HttpResponseMessage> PostAsync(string command, HttpContent content)
         {
             Debug.Assert(!String.IsNullOrWhiteSpace(command));
 
             HttpClient httpClient = new HttpClient();
 
-            var response = await httpClient.PostAsync(command, null);
-            
+            var response = await httpClient.PostAsync(command, content);
+
             response.EnsureSuccessStatusCode();
 
             if (response.Content == null)