Issue/32 (#96)

* Starting to fix and update the EconService methods around trades

* Added finishing touches to EconService endpoints.

* Fixed wrong parameter name

Author: Justin Skiles

src/Steam.Models/SteamEconomy/TradeHoldDurationsModel.cs

@@ -0,0 +1,11 @@
+using System;
+
+namespace Steam.Models.SteamEconomy
+{
+    public class TradeHoldDurationsModel
+    {
+        public TimeSpan EscrowEndDuration { get; set; }
+
+        public DateTime EscrowEndDate { get; set; }
+    }
+}

src/Steam.Models/SteamEconomy/TradeHoldDurationsResultModel.cs

@@ -0,0 +1,11 @@
+namespace Steam.Models.SteamEconomy
+{
+    public class TradeHoldDurationsResultModel
+    {
+        public TradeHoldDurationsModel MyEscrow { get; set; }
+
+        public TradeHoldDurationsModel TheirEscrow { get; set; }
+
+        public TradeHoldDurationsModel BothEscrow { get; set; }
+    }
+}

src/SteamWebAPI2/AutoMapperConfiguration.cs

@@ -97,6 +97,7 @@ public static void Initialize()
                     CreateSteamWebResponseMap<ResetLoginTokenContainer, string>(x);
                     CreateSteamWebResponseMap<AccountPublicInfoContainer, AccountPublicInfoModel>(x);
                     CreateSteamWebResponseMap<QueryLoginTokenContainer, QueryLoginTokenModel>(x);
+                    CreateSteamWebResponseMap<TradeHoldDurationsResultContainer, TradeHoldDurationsResultModel>(x);
 
                     x.AddProfile<DOTA2EconProfile>();
                     x.AddProfile<DOTA2FantasyProfile>();

src/SteamWebAPI2/Interfaces/EconService.cs

@@ -1,5 +1,7 @@
-using SteamWebAPI2.Models.SteamEconomy;
+using Steam.Models.SteamEconomy;
+using SteamWebAPI2.Models.SteamEconomy;
 using SteamWebAPI2.Utilities;
+using System;
 using System.Collections.Generic;
 using System.Threading.Tasks;
 
@@ -32,18 +34,30 @@ public EconService(ISteamWebRequest steamWebRequest, ISteamWebInterface steamWeb
         /// <param name="includeFailed">If set, trades in status k_ETradeStatus_Failed, k_ETradeStatus_RollbackFailed, k_ETradeStatus_RollbackAbandoned, and k_ETradeStatus_EscrowRollback will be included</param>
         /// <param name="includeTotal">Unknown</param>
         /// <returns></returns>
-        public async Task<ISteamWebResponse<Steam.Models.SteamEconomy.TradeHistoryModel>> GetTradeHistoryAsync(uint maxTrades, uint startAfterTime = 0, ulong startAfterTradeId = 0, bool navigatingBack = false, bool getDescriptions = false, string language = "", bool includeFailed = false, bool includeTotal = false)
+        public async Task<ISteamWebResponse<TradeHistoryModel>> GetTradeHistoryAsync(
+            uint maxTrades,
+            DateTime? startAfterTime = null,
+            ulong startAfterTradeId = 0,
+            bool navigatingBack = false,
+            bool getDescriptions = false,
+            string language = "",
+            bool includeFailed = false,
+            bool includeTotal = false)
         {
             List<SteamWebRequestParameter> parameters = new List<SteamWebRequestParameter>();
 
+            ulong? startAfterTimeUnix = startAfterTime.HasValue 
+                ? startAfterTime.Value.ToUnixTimeStamp() 
+                : (ulong?)null;
+
             parameters.AddIfHasValue(maxTrades, "max_trades");
-            parameters.AddIfHasValue(startAfterTime, "start_after_time");
+            parameters.AddIfHasValue(startAfterTimeUnix, "start_after_time");
             parameters.AddIfHasValue(startAfterTradeId, "start_after_tradeid");
             parameters.AddIfHasValue(navigatingBack, "navigating_back");
             parameters.AddIfHasValue(getDescriptions, "get_descriptions");
             parameters.AddIfHasValue(language, "language");
             parameters.AddIfHasValue(includeFailed, "include_failed");
-            parameters.AddIfHasValue(includeTotal, "inclue_total");
+            parameters.AddIfHasValue(includeTotal, "include_total");
 
             var steamWebResponse = await steamWebInterface.GetAsync<TradeHistoryResultContainer>("GetTradeHistory", 1, parameters);
 
@@ -65,20 +79,31 @@ public EconService(ISteamWebRequest steamWebRequest, ISteamWebInterface steamWeb
         /// <param name="historicalOnly">Return trade offers that are not in an active state.</param>
         /// <param name="timeHistoricalCutoff">A unix time value. when active_only is set, inactive offers will be returned if their state was updated since this time. Useful to get delta updates on what has changed. WARNING: If not passed, this will default to the time your account last viewed the trade offers page. To avoid this behavior use a very low or very high date.</param>
         /// <returns></returns>
-        public async Task<ISteamWebResponse<Steam.Models.SteamEconomy.TradeOffersResultModel>> GetTradeOffersAsync(bool getSentOffers, bool getReceivedOffers, bool getDescriptions = false, string language = "", bool activeOnly = false, bool historicalOnly = false, uint timeHistoricalCutoff = 0)
+        public async Task<ISteamWebResponse<TradeOffersResultModel>> GetTradeOffersAsync(
+            bool getSentOffers,
+            bool getReceivedOffers,
+            bool getDescriptions = false,
+            string language = "",
+            bool activeOnly = false,
+            bool historicalOnly = false,
+            DateTime? timeHistoricalCutoff = null)
         {
             List<SteamWebRequestParameter> parameters = new List<SteamWebRequestParameter>();
 
             int getSentOffersBit = getSentOffers ? 1 : 0;
             int getReceivedOffersBit = getReceivedOffers ? 1 : 0;
 
+            ulong? timeHistoricalCutoffUnix = timeHistoricalCutoff.HasValue 
+                ? timeHistoricalCutoff.Value.ToUnixTimeStamp() 
+                : (ulong?)null;
+
             parameters.AddIfHasValue(getSentOffersBit, "get_sent_offers");
             parameters.AddIfHasValue(getReceivedOffersBit, "get_received_offers");
             parameters.AddIfHasValue(getDescriptions, "get_descriptions");
             parameters.AddIfHasValue(language, "language");
             parameters.AddIfHasValue(activeOnly, "active_only");
             parameters.AddIfHasValue(historicalOnly, "historicalOnly");
-            parameters.AddIfHasValue(timeHistoricalCutoff, "time_historical_cutoff");
+            parameters.AddIfHasValue(timeHistoricalCutoffUnix, "time_historical_cutoff");
 
             var steamWebResponse = await steamWebInterface.GetAsync<TradeOffersResultContainer>("GetTradeOffers", 1, parameters);
 
@@ -95,12 +120,16 @@ public EconService(ISteamWebRequest steamWebRequest, ISteamWebInterface steamWeb
         /// <param name="tradeOfferId">The trade offer identifier</param>
         /// <param name="language">The language to use for item display information.</param>
         /// <returns></returns>
-        public async Task<ISteamWebResponse<Steam.Models.SteamEconomy.TradeOfferResultModel>> GetTradeOfferAsync(ulong tradeOfferId, string language = "")
+        public async Task<ISteamWebResponse<TradeOfferResultModel>> GetTradeOfferAsync(
+            ulong tradeOfferId,
+            string language = "",
+            bool getDescriptions = false)
         {
             List<SteamWebRequestParameter> parameters = new List<SteamWebRequestParameter>();
 
             parameters.AddIfHasValue(tradeOfferId, "tradeOfferId");
             parameters.AddIfHasValue(language, "language");
+            parameters.AddIfHasValue(getDescriptions, "get_descriptions");
 
             var steamWebResponse = await steamWebInterface.GetAsync<TradeOfferResultContainer>("GetTradeOffer", 1, parameters);
 
@@ -110,5 +139,57 @@ public EconService(ISteamWebRequest steamWebRequest, ISteamWebInterface steamWeb
 
             return steamWebResponseModel;
         }
+
+        public async Task<ISteamWebResponse<dynamic>> GetTradeStatusAsync(ulong tradeId, bool getDescriptions, string language)
+        {
+            List<SteamWebRequestParameter> parameters = new List<SteamWebRequestParameter>();
+            parameters.AddIfHasValue(tradeId, "tradeid");
+            parameters.AddIfHasValue(getDescriptions, "get_descriptions");
+            parameters.AddIfHasValue(language, "language");
+            var steamWebResponse = await steamWebInterface.GetAsync<dynamic>("GetTradeStatus", 1, parameters);
+            return steamWebResponse;
+        }
+
+        public async Task<ISteamWebResponse<dynamic>> GetTradeOffersSummaryAsync(DateTime? timeLastVisit = null)
+        {
+            ulong? timeLastVisitUnix = timeLastVisit.HasValue 
+                ? timeLastVisit.Value.ToUnixTimeStamp() 
+                : (ulong?)null;
+
+            List<SteamWebRequestParameter> parameters = new List<SteamWebRequestParameter>();
+            parameters.AddIfHasValue(timeLastVisitUnix, "time_last_visit");
+            var steamWebResponse = await steamWebInterface.GetAsync<dynamic>("GetTradeOffersSummary", 1, parameters);
+            return steamWebResponse;
+        }
+
+        public async Task<ISteamWebResponse<dynamic>> DeclineTradeOfferAsync(ulong tradeOfferId)
+        {
+            List<SteamWebRequestParameter> parameters = new List<SteamWebRequestParameter>();
+            parameters.AddIfHasValue(tradeOfferId, "tradeofferid");
+            var steamWebResponse = await steamWebInterface.PostAsync<dynamic>("DeclineTradeOffer", 1, parameters);
+            return steamWebResponse;
+        }
+
+        public async Task<ISteamWebResponse<dynamic>> CancelTradeOfferAsync(ulong tradeOfferId)
+        {
+            List<SteamWebRequestParameter> parameters = new List<SteamWebRequestParameter>();
+            parameters.AddIfHasValue(tradeOfferId, "tradeofferid");
+            var steamWebResponse = await steamWebInterface.PostAsync<dynamic>("CancelTradeOffer", 1, parameters);
+            return steamWebResponse;
+        }
+
+        public async Task<ISteamWebResponse<TradeHoldDurationsResultModel>> GetTradeHoldDurationsAsync(ulong steamIdTarget, string tradeOfferAccessToken = "")
+        {
+            List<SteamWebRequestParameter> parameters = new List<SteamWebRequestParameter>();
+            parameters.AddIfHasValue(steamIdTarget, "steamid_target");
+            parameters.AddIfHasValue(tradeOfferAccessToken, "trade_offer_access_token");
+            var steamWebResponse = await steamWebInterface.GetAsync<TradeHoldDurationsResultContainer>("GetTradeHoldDurations", 1, parameters);
+            
+            var steamWebResponseModel = AutoMapperConfiguration.Mapper.Map<
+                ISteamWebResponse<TradeHoldDurationsResultContainer>,
+                ISteamWebResponse<TradeHoldDurationsResultModel>>(steamWebResponse);
+
+            return steamWebResponseModel;
+        }
     }
 }

src/SteamWebAPI2/Interfaces/IEconService.cs

@@ -1,5 +1,6 @@
 using Steam.Models.SteamEconomy;
 using SteamWebAPI2.Utilities;
+using System;
 using System.Threading.Tasks;
 
 namespace SteamWebAPI2.Interfaces
@@ -18,7 +19,20 @@ public interface IEconService
         /// <param name="includeFailed">If set, trades in status k_ETradeStatus_Failed, k_ETradeStatus_RollbackFailed, k_ETradeStatus_RollbackAbandoned, and k_ETradeStatus_EscrowRollback will be included</param>
         /// <param name="includeTotal">Unknown</param>
         /// <returns></returns>
-        Task<ISteamWebResponse<TradeHistoryModel>> GetTradeHistoryAsync(uint maxTrades, uint startAfterTime, ulong startAfterTradeId, bool navigatingBack, bool getDescriptions, string language, bool includeFailed, bool includeTotal);
+        Task<ISteamWebResponse<TradeHistoryModel>> GetTradeHistoryAsync(
+            uint maxTrades,
+            DateTime? startAfterTime,
+            ulong startAfterTradeId,
+            bool navigatingBack,
+            bool getDescriptions,
+            string language,
+            bool includeFailed,
+            bool includeTotal);
+
+        Task<ISteamWebResponse<dynamic>> GetTradeStatusAsync(
+            ulong tradeId,
+            bool getDescriptions,
+            string language);
 
         /// <summary>
         /// This API gets a list of trade offers (up to a maximum of 500 sent or 1000 received regardless of time_historical_cutoff) for the account associated with the WebAPI key. You cannot call this API for accounts other than your own.
@@ -29,20 +43,31 @@ public interface IEconService
         /// <param name="language">Needed if get_descriptions is set, the language to use for item descriptions.</param>
         /// <param name="activeOnly">Return only trade offers in an active state (offers that haven't been accepted yet), or any offers that have had their state change since time_historical_cutoff.</param>
         /// <param name="historicalOnly">Return trade offers that are not in an active state.</param>
-        /// <param name="timeHistoricalCutoff">A unix time value. when active_only is set, inactive offers will be returned if their state was updated since this time. Useful to get delta updates on what has changed. WARNING: If not passed, this will default to the time your account last viewed the trade offers page. To avoid this behavior use a very low or very high date.</param>
+        /// <param name="timeHistoricalCutoff">A unix time value. When active_only is set, inactive offers will be returned if their state was updated since this time. Useful to get delta updates on what has changed. WARNING: If not passed, this will default to the time your account last viewed the trade offers page. To avoid this behavior use a very low or very high date.</param>
         /// <returns></returns>
-        Task<ISteamWebResponse<TradeOffersResultModel>> GetTradeOffersAsync(bool getSentOffers, bool getReceivedOffers, bool getDescriptions, string language, bool activeOnly, bool historicalOnly, uint timeHistoricalCutoff);
+        Task<ISteamWebResponse<TradeOffersResultModel>> GetTradeOffersAsync(
+            bool getSentOffers,
+            bool getReceivedOffers,
+            bool getDescriptions,
+            string language,
+            bool activeOnly,
+            bool historicalOnly,
+            DateTime? timeHistoricalCutoff);
 
         /// <summary>
         /// This API gets details about a single trade offer. The trade offer must have been sent to or from the account associated with the WebAPI key. You cannot call this API for accounts other than your own.
         /// </summary>
         /// <param name="tradeOfferId">The trade offer identifier</param>
         /// <param name="language">The language to use for item display information.</param>
         /// <returns></returns>
-        Task<ISteamWebResponse<TradeOfferResultModel>> GetTradeOfferAsync(ulong tradeOfferId, string language);
+        Task<ISteamWebResponse<TradeOfferResultModel>> GetTradeOfferAsync(ulong tradeOfferId, string language, bool getDescriptions);
+
+        Task<ISteamWebResponse<dynamic>> GetTradeOffersSummaryAsync(DateTime? timeLastVisit);
+
+        Task<ISteamWebResponse<dynamic>> DeclineTradeOfferAsync(ulong tradeOfferId);
+        
+        Task<ISteamWebResponse<dynamic>> CancelTradeOfferAsync(ulong tradeOfferId);
 
-        //Task GetTradeOffersSummary(ulong timeLastVisit);
-        //Task DeclineTradeOffer(ulong tradeOfferId);
-        //Task CancelTradeOffer(ulong tradeOfferId);
+        Task<ISteamWebResponse<TradeHoldDurationsResultModel>> GetTradeHoldDurationsAsync(ulong steamIdTarget, string tradeOfferAccessToken);
     }
 }

src/SteamWebAPI2/Mappings/EconServiceProfile.cs

@@ -1,3 +1,4 @@
+using System;
 using AutoMapper;
 using Steam.Models.SteamEconomy;
 using SteamWebAPI2.Models.SteamEconomy;
@@ -35,6 +36,15 @@ public EconServiceProfile()
             CreateMap<TradeOffersResultContainer, TradeOffersResultModel>().ConvertUsing((src, dest, context) =>
                 context.Mapper.Map<TradeOffersResult, TradeOffersResultModel>(src.Result)
             );
+            CreateMap<TradeHoldDurationsResultContainer, TradeHoldDurationsResultModel>().ConvertUsing((src, dest, context) =>
+                context.Mapper.Map<TradeHoldDurationsResult, TradeHoldDurationsResultModel>(src.Result)
+            );
+            CreateMap<TradeHoldDurationsResult, TradeHoldDurationsResultModel>();
+            CreateMap<TradeHoldDurations, TradeHoldDurationsModel>()
+                .ForMember(dest => dest.EscrowEndDate, 
+                    opts => opts.MapFrom(src => src.EscrowEndDateRfc3339))
+                .ForMember(dest => dest.EscrowEndDuration, 
+                    opts => opts.MapFrom(src => TimeSpan.FromSeconds(src.EscrowEndDurationSeconds)));
         }
     }
 }

src/SteamWebAPI2/Models/SteamEconomy/TradeHoldDurationResultsContainer.cs

@@ -0,0 +1,35 @@
+using Newtonsoft.Json;
+using System;
+
+namespace SteamWebAPI2.Models.SteamEconomy
+{
+    internal class TradeHoldDurations
+    {
+        [JsonProperty("escrow_end_duration_seconds")]
+        public uint EscrowEndDurationSeconds { get; set; }
+        
+        [JsonProperty("escrow_end_date")]
+        public uint EscrowEndDate { get; set; }
+
+        [JsonProperty("escrow_end_date_rfc3339")]
+        public DateTime EscrowEndDateRfc3339 { get; set;}
+    }
+
+    internal class TradeHoldDurationsResult
+    {
+        [JsonProperty("my_escrow")]
+        public TradeHoldDurations MyEscrow { get; set; }
+        
+        [JsonProperty("their_escrow")]
+        public TradeHoldDurations TheirEscrow { get; set; }
+        
+        [JsonProperty("both_escrow")]
+        public TradeHoldDurations BothEscrow { get; set; }
+    }
+
+    internal class TradeHoldDurationsResultContainer
+    {
+        [JsonProperty("response")]
+        public TradeHoldDurationsResult Result { get; set; }
+    }
+}