Reimplement OAuth2 library - Step 1

Src/GoogleApis/Apis/Requests/ClientServiceRequest.cs

 /*
 Copyright 2011 Google Inc
 
 Licensed under the Apache License, Version 2.0 (the "License");
 you may not use this file except in compliance with the License.
 You may obtain a copy of the License at
 
 http://www.apache.org/licenses/LICENSE-2.0
 
 Unless required by applicable law or agreed to in writing, software
 distributed under the License is distributed on an "AS IS" BASIS,
 WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 See the License for the specific language governing permissions and
 limitations under the License.
 */
 
 using System;
 using System.Collections.Generic;
 using System.IO;
-using System.Linq;
 using System.Net.Http;
 using System.Net.Http.Headers;
-using System.Reflection;
 using System.Threading;
 using System.Threading.Tasks;
 
 using Google.Apis.Discovery;
 using Google.Apis.Http;
 using Google.Apis.Logging;
 using Google.Apis.Services;
 using Google.Apis.Testing;
 using Google.Apis.Util;
 using Google.Apis.Requests.Parameters;
 
 namespace Google.Apis.Requests
 {
 /// <summary>
 /// Represents an abstract, strongly typed request base class to make reques
ts to a service.
 /// Supports a strongly typed response.
 /// </summary>
 /// <typeparam name="TResponse">The type of the response object</typeparam>
 public abstract class ClientServiceRequest<TResponse> : IClientServiceReques
t<TResponse>
 {
- /// <summary> The class logger </summary>
+ /// <summary>The class logger.</summary>
 private static readonly ILogger Logger = ApplicationContext.Logger.ForTy
pe<ClientServiceRequest<TResponse>>();
 
- /// <summary> The service on which this request will be executed. </summ
 ary>
+ /// <summary>The service on which this request will be executed.</summar
 y>
 private readonly IClientService service;
 
- /// <summary> Defines whether the E-Tag will be used in a specified way 
 or be ignored. </summary>
+ /// <summary>Defines whether the E-Tag will be used in a specified way o
 r be ignored.</summary>
 public ETagAction ETagAction { get; set; }
 
 #region IClientServiceRequest Properties
 
 public abstract string MethodName { get; }
 public abstract string RestPath { get; }
 public abstract string HttpMethod { get; }
 
 public IDictionary<string, IParameter> RequestParameters { get; private
set; }
 
 public IClientService Service
 {
 get { return service; }
 }
 
 #endregion
 
- /// <summary> Creates a new service request. </summary>
+ /// <summary>Creates a new service request.</summary>
 protected ClientServiceRequest(IClientService service)
 {
 this.service = service;
 }
 
 /// <summary>
 /// Initializes request's parameters. Inherited classes MUST override th
is method to add parameters to the
 /// <see cref="RequestParameters"/> dictionary.
 /// </summary>
 protected virtual void InitParameters()
 {
 RequestParameters = new Dictionary<string, IParameter>();
 }
 
 #region Execution
 
 public TResponse Execute()
 {
 try
 {
 using (var response = ExecuteUnparsed(CancellationToken.None).Re
sult)
 {
 return ParseResponse(response).Result;
 }
 }
 catch (AggregateException aex)
 {
- // if an exception was thrown during the tasks, unwrap and throw
  it
+ // If an exception was thrown during the tasks, unwrap and throw
  it.
 throw aex.InnerException;
 }
 catch (Exception ex)
 {
 throw ex;
 }
 }
 
 public Stream ExecuteAsStream()
 {
 // TODO(peleyal): should we copy the stream, and dispose the respons
e?
 try
 {
- // sync call
+ // Sync call.
 var response = ExecuteUnparsed(CancellationToken.None).Result;
 return response.Content.ReadAsStreamAsync().Result;
 }
 catch (AggregateException aex)
 {
- // if an exception was thrown during the tasks, unwrap and throw
  it
+ // If an exception was thrown during the tasks, unwrap and throw
  it.
 throw aex.InnerException;
 }
 catch (Exception ex)
 {
 throw ex;
 }
 }
 
 public async Task<TResponse> ExecuteAsync()
 {
@@ skipping 18 matching lines @@
 {
 // TODO(peleyal): should we copy the stream, and dispose the respons
e?
 var response = await ExecuteAsyncUnparsed(cancellationToken).Configu
reAwait(false);
 
 cancellationToken.ThrowIfCancellationRequested();
 return await response.Content.ReadAsStreamAsync().ConfigureAwait(fal
se);
 }
 
 #region Helpers
 
- /// <summary> Sync executes the request without parsing the result. </su
 mmary>
+ /// <summary>Sync executes the request without parsing the result. </sum
 mary>
 private async Task<HttpResponseMessage> ExecuteUnparsed(CancellationToke
n cancellationToken)
 {
 using (var request = CreateRequest())
 {
 return await service.HttpClient.SendAsync(request, cancellationT
oken).ConfigureAwait(false);
 }
 }
 
- /// <summary> Async executes the request without parsing the result. </s
 ummary>
+ /// <summary>Async executes the request without parsing the result. </su
 mmary>
 private Task<HttpResponseMessage> ExecuteAsyncUnparsed(CancellationToken
cancellationToken)
 {
 // TODO(peleyal): remove the creation of a new Task (it's not necess
ary).
 // It should also be removed from ResumableMediaUpload and MediaDown
loader!
-
 // create a new task completion source and return its task. In addit
ional task we actually send the request
 // using ExecuteUnparsed and setting the result or the exception on
the completion source
 TaskCompletionSource<HttpResponseMessage> tcs = new TaskCompletionSo
urce<HttpResponseMessage>();
 Task.Factory.StartNew(async () =>
 {
 try
 {
 var response = await ExecuteUnparsed(cancellationToken).
ConfigureAwait(false);
 tcs.SetResult(response);
 }
 catch (Exception ex)
 {
- // exception was thrown - it must be set on the task com
 pletion source
+ // Exception was thrown - it must be set on the task com
 pletion source.
 tcs.SetException(ex);
 }
 }).ConfigureAwait(false);
 return tcs.Task;
 }
 
- /// <summary> Parses the response and deserialize the content into the r
 equested response object. </summary>
+ /// <summary>Parses the response and deserialize the content into the re
 quested response object. </summary>
 private async Task<TResponse> ParseResponse(HttpResponseMessage response
)
 {
 if (response.IsSuccessStatusCode)
 {
 return await service.DeserializeResponse<TResponse>(response).Co
nfigureAwait(false);
 }
 var error = await service.DeserializeError(response).ConfigureAwait(
false);
 throw new GoogleApiException(service.Name, error.ToString());
 }
 
 #endregion
 
 #endregion
 
 /// <summary>
 /// Creates the <seealso cref="Google.Apis.Requests.RequestBuilder"/> wh
ich is used to generate a request.
 /// </summary>
 /// <returns>
 /// A new builder instance which contains the HTTP method and the right
Uri with its path and query parameters.
 /// </returns>
 private RequestBuilder CreateBuilder()
 {
 var builder = new RequestBuilder()
 {
 BaseUri = new Uri(Service.BaseUri),
 Path = RestPath,
 Method = HttpMethod,
 };
 
- // init parameters
+ // Init parameters.
 builder.AddParameter(RequestParameterType.Query, "key", service.ApiK
ey);
 var parameters = ParameterUtils.CreateParameterDictionary(this);
 AddParameters(builder, ParameterCollection.FromDictionary(parameters
));
 return builder;
 }
 
- /// <summary>Generates the right Url for this request.</summary>
+ /// <summary>Generates the right URL for this request.</summary>
 protected string GenerateRequestUri()
 {
 return CreateBuilder().BuildUri().ToString();
 }
 
 /// <summary>Creates a HTTP request message with all class parameters, d
eveloper-key, ETag, etc.</summary>
 [VisibleForTestOnly]
 internal HttpRequestMessage CreateRequest()
 {
 var builder = CreateBuilder();
 var request = builder.CreateRequest();
 object body = GetBody();
 if (body != null)
 {
 service.SetRequestSerailizedContent(request, body);
 }
 
 AddETag(request);
 return request;
 }
 
 protected virtual object GetBody()
 {
 return null;
 }
 
 #region ETag
 
- /// <summary> 
+ /// <summary>
 /// Adds the right ETag action (e.g. If-Match) header to the given HTTP
request if the body contains ETag.
 /// </summary>
 private void AddETag(HttpRequestMessage request)
 {
 IDirectResponseSchema body = GetBody() as IDirectResponseSchema;
 if (body != null && !string.IsNullOrEmpty(body.ETag))
 {
 ETagAction action = ETagAction == ETagAction.Default ? GetDefaul
tETagAction(HttpMethod) : ETagAction;
 switch (action)
 {
 case ETagAction.IfMatch:
 request.Headers.IfMatch.Add(new EntityTagHeaderValue(bod
y.ETag));
 break;
 case ETagAction.IfNoneMatch:
 request.Headers.IfNoneMatch.Add(new EntityTagHeaderValue
(body.ETag));
 break;
 }
 }
 }
 
- /// <summary>
- /// Returns the default ETagAction for a specific HTTP verb.
- /// </summary>
+ /// <summary>Returns the default ETagAction for a specific HTTP verb.</s
 ummary>
 [VisibleForTestOnly]
 internal static ETagAction GetDefaultETagAction(string httpMethod)
 {
 switch (httpMethod)
 {
 // Incoming data should only be updated if it has been changed o
n the server.
 case HttpConsts.Get:
 return ETagAction.IfNoneMatch;
 
 // Outgoing data should only be committed if it hasn't been chan
ged on the server.
 case HttpConsts.Put:
 case HttpConsts.Post:
 case HttpConsts.Patch:
 case HttpConsts.Delete:
 return ETagAction.IfMatch;
 
 default:
 return ETagAction.Ignore;
 }
 }
 
 #endregion
 
 #region Parameters
 
- /// <summary> Adds path and query parameters to the given <c>requestBuil
 der</c>. </summary>
+ /// <summary>Adds path and query parameters to the given <c>requestBuild
 er</c>.</summary>
 private void AddParameters(RequestBuilder requestBuilder, ParameterColle
ction inputParameters)
 {
 foreach (var parameter in inputParameters)
 {
 IParameter parameterDefinition;
 
 if (!RequestParameters.TryGetValue(parameter.Key, out parameterD
efinition))
 {
 throw new GoogleApiException(Service.Name,
 String.Format("Invalid parameter \"{0}\" was specified",
parameter.Key));
@@ skipping 23 matching lines @@
 requestBuilder.AddParameter(RequestParameterType.Que
ry, parameter.Key, value);
 }
 break;
 default:
 throw new GoogleApiException(service.Name,
 string.Format("Unsupported parameter type \"{0}\" fo
r \"{1}\"",
 parameterDefinition.ParameterType, parameterDefiniti
on.Name));
 }
 }
 
- // check if there is a required parameter which wasn't set
+ // Check if there is a required parameter which wasn't set.
 foreach (var parameter in RequestParameters.Values)
 {
 if (parameter.IsRequired && !inputParameters.ContainsKey(paramet
er.Name))
 {
 throw new GoogleApiException(service.Name,
 string.Format("Parameter \"{0}\" is missing", parameter.
Name));
 }
 }
 }
 
 #endregion
 }
 }