PageRenderTime 50ms CodeModel.GetById 21ms RepoModel.GetById 0ms app.codeStats 0ms

/trunk/source/Stacky/StackyClient/AnswerMethods.cs

#
C# | 178 lines | 92 code | 8 blank | 78 comment | 0 complexity | a92a0826ea8b938d587ba0ba97018953 MD5 | raw file
    

  1. using System.Collections.Generic;

    2. 

  2. using System;

    3. 

  3. using System.Linq;

    4. 

  4. 

    5. 

  5. namespace Stacky

    6. 

  6. {

    7. 

  7.     /// <summary>

    8. 

  8.     /// 

    9. 

  9.     /// </summary>

    10. 

  10.     public partial class StackyClient

    11. 

  11.     {

    12. 

  12. 

    13. 

  13.         /// <summary>

    14. 

  14.         /// Gets the users answers.

    15. 

  15.         /// </summary>

    16. 

  16.         /// <param name="userId">The user id.</param>

    17. 

  17.         /// <param name="sortBy">The sort by.</param>

    18. 

  18.         /// <param name="sortDirection">The sort direction.</param>

    19. 

  19.         /// <param name="page">The page.</param>

    20. 

  20.         /// <param name="pageSize">Size of the page.</param>

    21. 

  21.         /// <param name="includeBody">if set to <c>true</c> [include body].</param>

    22. 

  22.         /// <param name="includeComments">if set to <c>true</c> [include comments].</param>

    23. 

  23.         /// <param name="min">The min.</param>

    24. 

  24.         /// <param name="max">The max.</param>

    25. 

  25.         /// <param name="fromDate">From date.</param>

    26. 

  26.         /// <param name="toDate">To date.</param>

    27. 

  27.         /// <returns></returns>

    28. 

  28.         public virtual IPagedList<Answer> GetUsersAnswers(int userId, QuestionsByUserSort sortBy = QuestionsByUserSort.Activity, SortDirection sortDirection = SortDirection.Descending, int? page = null, int? pageSize = null, bool includeBody = false, bool includeComments = false, int? min = null, int? max = null, DateTime? fromDate = null, DateTime? toDate = null)

    29. 

  29.         {

    30. 

  30.             return GetUsersAnswers(userId.ToArray(), sortBy, sortDirection, page, pageSize, includeBody, includeComments, min, max, fromDate, toDate);

    31. 

  31.         }

    32. 

  32. 

    33. 

  33.         /// <summary>

    34. 

  34.         /// Gets the users answers.

    35. 

  35.         /// </summary>

    36. 

  36.         /// <param name="userIds">The user ids.</param>

    37. 

  37.         /// <param name="sortBy">The sort by.</param>

    38. 

  38.         /// <param name="sortDirection">The sort direction.</param>

    39. 

  39.         /// <param name="page">The page.</param>

    40. 

  40.         /// <param name="pageSize">Size of the page.</param>

    41. 

  41.         /// <param name="includeBody">if set to <c>true</c> [include body].</param>

    42. 

  42.         /// <param name="includeComments">if set to <c>true</c> [include comments].</param>

    43. 

  43.         /// <param name="min">The min.</param>

    44. 

  44.         /// <param name="max">The max.</param>

    45. 

  45.         /// <param name="fromDate">From date.</param>

    46. 

  46.         /// <param name="toDate">To date.</param>

    47. 

  47.         /// <returns></returns>

    48. 

  48.         public virtual IPagedList<Answer> GetUsersAnswers(IEnumerable<int> userIds, QuestionsByUserSort sortBy = QuestionsByUserSort.Creation, SortDirection sortDirection = SortDirection.Descending, int? page = null, int? pageSize = null, bool includeBody = false, bool includeComments = false, int? min = null, int? max = null, DateTime? fromDate = null, DateTime? toDate = null)

    49. 

  49.         {

    50. 

  50.             var response = MakeRequest<AnswerResponse>("users", new string[] { userIds.Vectorize(), "answers" }, new

    51. 

  51.             {

    52. 

  52.                 key = apiKey,

    53. 

  53.                 page = page ?? null,

    54. 

  54.                 pagesize = pageSize ?? null,

    55. 

  55.                 body = includeBody ? (bool?)true : null,

    56. 

  56.                 comments = includeComments ? (bool?)true : null,

    57. 

  57.                 sort = sortBy.ToString().ToLower(),

    58. 

  58.                 order = GetSortDirection(sortDirection),

    59. 

  59.                 min = min ?? null,

    60. 

  60.                 max = max ?? null,

    61. 

  61.                 fromdate = fromDate.HasValue ? (long?)fromDate.Value.ToUnixTime() : null,

    62. 

  62.                 todate = toDate.HasValue ? (long?)toDate.Value.ToUnixTime() : null

    63. 

  63.             });

    64. 

  64.             return new PagedList<Answer>(response.Answers, response);

    65. 

  65.         }

    66. 

  66. 

    67. 

  67.         /// <summary>

    68. 

  68.         /// Gets the question answers.

    69. 

  69.         /// </summary>

    70. 

  70.         /// <param name="questionIds">The question ids.</param>

    71. 

  71.         /// <param name="sortBy">The sort by.</param>

    72. 

  72.         /// <param name="sortDirection">The sort direction.</param>

    73. 

  73.         /// <param name="page">The page.</param>

    74. 

  74.         /// <param name="pageSize">Size of the page.</param>

    75. 

  75.         /// <param name="includeBody">if set to <c>true</c> [include body].</param>

    76. 

  76.         /// <param name="includeComments">if set to <c>true</c> [include comments].</param>

    77. 

  77.         /// <param name="min">The min.</param>

    78. 

  78.         /// <param name="max">The max.</param>

    79. 

  79.         /// <param name="fromDate">From date.</param>

    80. 

  80.         /// <param name="toDate">To date.</param>

    81. 

  81.         /// <returns></returns>

    82. 

  82.         public virtual IPagedList<Answer> GetQuestionAnswers(IEnumerable<int> questionIds, QuestionsByUserSort sortBy = QuestionsByUserSort.Activity, SortDirection sortDirection = SortDirection.Descending, int? page = null, int? pageSize = null, bool includeBody = false, bool includeComments = false, int? min = null, int? max = null, DateTime? fromDate = null, DateTime? toDate = null)

    83. 

  83.         {

    84. 

  84.             var response = MakeRequest<AnswerResponse>("questions", new string[] { questionIds.Vectorize(), "answers" }, new

    85. 

  85.             {

    86. 

  86.                 key = apiKey,

    87. 

  87.                 page = page ?? null,

    88. 

  88.                 pagesize = pageSize ?? null,

    89. 

  89.                 body = includeBody ? (bool?)true : null,

    90. 

  90.                 sort = sortBy.ToString().ToLower(),

    91. 

  91.                 order = GetSortDirection(sortDirection),

    92. 

  92.                 min = min ?? null,

    93. 

  93.                 max = max ?? null,

    94. 

  94.                 fromdate = fromDate.HasValue ? (long?)fromDate.Value.ToUnixTime() : null,

    95. 

  95.                 todate = toDate.HasValue ? (long?)toDate.Value.ToUnixTime() : null

    96. 

  96.             });

    97. 

  97.             return new PagedList<Answer>(response.Answers, response);

    98. 

  98.         }

    99. 

  99. 

    100. 

  100.         /// <summary>

    101. 

  101.         /// Gets the question answers.

    102. 

  102.         /// </summary>

    103. 

  103.         /// <param name="questionId">The question id.</param>

    104. 

  104.         /// <param name="sortBy">The sort by.</param>

    105. 

  105.         /// <param name="sortDirection">The sort direction.</param>

    106. 

  106.         /// <param name="page">The page.</param>

    107. 

  107.         /// <param name="pageSize">Size of the page.</param>

    108. 

  108.         /// <param name="includeBody">if set to <c>true</c> [include body].</param>

    109. 

  109.         /// <param name="includeComments">if set to <c>true</c> [include comments].</param>

    110. 

  110.         /// <param name="min">The min.</param>

    111. 

  111.         /// <param name="max">The max.</param>

    112. 

  112.         /// <param name="fromDate">From date.</param>

    113. 

  113.         /// <param name="toDate">To date.</param>

    114. 

  114.         /// <returns></returns>

    115. 

  115.         public virtual IPagedList<Answer> GetQuestionAnswers(int questionId, QuestionsByUserSort sortBy = QuestionsByUserSort.Activity, SortDirection sortDirection = SortDirection.Descending, int? page = null, int? pageSize = null, bool includeBody = false, bool includeComments = false, int? min = null, int? max = null, DateTime? fromDate = null, DateTime? toDate = null)

    116. 

  116.         {

    117. 

  117.             return GetQuestionAnswers(questionId.ToArray(), sortBy, sortDirection, page, pageSize, includeBody, includeComments, min, max, fromDate, toDate);

    118. 

  118.         }

    119. 

  119. 

    120. 

  120.         public virtual Answer GetAnswer(int answerId, bool includeBody = true, bool includeComments = true)

    121. 

  121.         {

    122. 

  122.             return GetAnswers(answerId.ToArray(), includeBody: includeBody, includeComments : includeComments).FirstOrDefault();

    123. 

  123.         }

    124. 

  124. 

    125. 

  125.         public virtual IPagedList<Answer> GetAnswers(IEnumerable<int> answerIds, AnswerSort sortBy = AnswerSort.Activity, SortDirection sortDirection = SortDirection.Descending, int? page = null, int? pageSize = null, bool includeBody = false, bool includeComments = false, int? min = null, int? max = null, DateTime? fromDate = null, DateTime? toDate = null)

    126. 

  126.         {

    127. 

  127.             var response = MakeRequest<AnswerResponse>("answers", new string[] { answerIds.Vectorize() }, new

    128. 

  128.             {

    129. 

  129.                 key = apiKey,

    130. 

  130.                 page = page ?? null,

    131. 

  131.                 pagesize = pageSize ?? null,

    132. 

  132.                 body = includeBody ? (bool?)true : null,

    133. 

  133.                 sort = sortBy.ToString().ToLower(),

    134. 

  134.                 order = GetSortDirection(sortDirection),

    135. 

  135.                 min = min ?? null,

    136. 

  136.                 max = max ?? null,

    137. 

  137.                 fromdate = fromDate.HasValue ? (long?)fromDate.Value.ToUnixTime() : null,

    138. 

  138.                 todate = toDate.HasValue ? (long?)toDate.Value.ToUnixTime() : null

    139. 

  139.             });

    140. 

  140.             return new PagedList<Answer>(response.Answers, response);

    141. 

  141.         }

    142. 

  142. 

    143. 

  143.         /// <summary>

    144. 

  144.         /// Returns all the answers in the system

    145. 

  145.         /// </summary>

    146. 

  146.         /// <param name="sortBy">How a collection should be sorted.</param>

    147. 

  147.         /// <param name="sortDirection"></param>

    148. 

  148.         /// <param name="page">The pagination offset for the current collection. Affected by the specified pagesize.</param>

    149. 

  149.         /// <param name="pageSize">The number of collection results to display during pagination. Should be between 0 and 100 inclusive.</param>

    150. 

  150.         /// <param name="includeBody">When "true", a post's body will be included in the response.</param>

    151. 

  151.         /// <param name="includeComments">When "true", any comments on a post will be included in the response.</param>

    152. 

  152.         /// <param name="includeAnswers"> When "true", the answers to a question will be returned</param>

    153. 

  153.         /// <param name="min">Minimum of the range to include in the response according to the current sort.</param>

    154. 

  154.         /// <param name="max">Maximum of the range to include in the response according to the current sort.</param>

    155. 

  155.         /// <param name="fromDate">Unix timestamp of the minimum creation date on a returned item.</param>

    156. 

  156.         /// <param name="toDate">Unix timestamp of the maximum creation date on a returned item.</param>

    157. 

  157.         /// <returns></returns>

    158. 

  158.         public virtual IPagedList<Answer> GetAnswers(AnswerSort sortBy = AnswerSort.Activity, SortDirection sortDirection = SortDirection.Descending, int? page = null, int? pageSize = null, bool includeBody = false, bool includeComments = false, bool includeAnswers = false, int? min = null, int? max = null, DateTime? fromDate = null, DateTime? toDate = null)

    159. 

  159.         {

    160. 

  160.             var response = MakeRequest<AnswerResponse>("answers", null, new

    161. 

  161.             {

    162. 

  162.                 key = apiKey,

    163. 

  163.                 page = page ?? null,

    164. 

  164.                 pagesize = pageSize ?? null,

    165. 

  165.                 body = includeBody ? (bool?)true : null,

    166. 

  166.                 comments = includeComments ? (bool?)true : null,

    167. 

  167.                 answers = includeAnswers ? (bool?)true : null,

    168. 

  168.                 sort = sortBy.ToString().ToLower(),

    169. 

  169.                 order = GetSortDirection(sortDirection),

    170. 

  170.                 min = min ?? null,

    171. 

  171.                 max = max ?? null,

    172. 

  172.                 fromdate = fromDate.HasValue ? (long?)fromDate.Value.ToUnixTime() : null,

    173. 

  173.                 todate = toDate.HasValue ? (long?)toDate.Value.ToUnixTime() : null

    174. 

  174.             });

    175. 

  175.             return new PagedList<Answer>(response.Answers, response);

    176. 

  176.         }

    177. 

  177.     }

    178. 

  178. }
    179.