Modularized Parse.Core

Author: richardjrossiii

Parse/Internal/Authentication/IParseAuthenticationProvider.cs renamed to ParseCore/Internal/Authentication/IParseAuthenticationProvider.cs

@@ -4,14 +4,14 @@
 using System.Threading;
 using System.Threading.Tasks;
 
-namespace Parse.Internal {
-  interface IParseAuthenticationProvider {
+namespace Parse.Core.Internal {
+  public interface IParseAuthenticationProvider {
     /// <summary>
     /// Authenticates with the service.
     /// </summary>
     /// <param name="cancellationToken">The cancellation token.</param>
     Task<IDictionary<string, object>> AuthenticateAsync(CancellationToken cancellationToken);
-    
+
     /// <summary>
     /// Deauthenticates (logs out) the user associated with this provider. This
     /// call may block.

Parse/Internal/Cloud/Controller/IParseCloudCodeController.cs renamed to ParseCore/Internal/Cloud/Controller/IParseCloudCodeController.cs

@@ -5,8 +5,8 @@
 using System.Threading;
 using System.Threading.Tasks;
 
-namespace Parse.Internal {
-  interface IParseCloudCodeController {
+namespace Parse.Core.Internal {
+  public interface IParseCloudCodeController {
     Task<T> CallFunctionAsync<T>(String name,
         IDictionary<string, object> parameters,
         string sessionToken,

Parse/Internal/Cloud/Controller/ParseCloudCodeController.cs renamed to ParseCore/Internal/Cloud/Controller/ParseCloudCodeController.cs

@@ -5,12 +5,13 @@
 using System.Threading;
 using System.Threading.Tasks;
 using Parse.Utilities;
+using Parse.Common.Internal;
 
-namespace Parse.Internal {
-  internal class ParseCloudCodeController : IParseCloudCodeController {
+namespace Parse.Core.Internal {
+  public class ParseCloudCodeController : IParseCloudCodeController {
     private readonly IParseCommandRunner commandRunner;
 
-    internal ParseCloudCodeController(IParseCommandRunner commandRunner) {
+    public ParseCloudCodeController(IParseCommandRunner commandRunner) {
       this.commandRunner = commandRunner;
     }
 
@@ -22,13 +23,13 @@ public Task<T> CallFunctionAsync<T>(String name,
           method: "POST",
           sessionToken: sessionToken,
           data: NoObjectsEncoder.Instance.Encode(parameters) as IDictionary<string, object>);
-      
+
       return commandRunner.RunCommandAsync(command, cancellationToken: cancellationToken).OnSuccess(t => {
         var decoded = ParseDecoder.Instance.Decode(t.Result.Item2) as IDictionary<string, object>;
         if (!decoded.ContainsKey("result")) {
           return default(T);
         }
-        return (T)Conversion.ConvertTo<T>(decoded["result"]);
+        return Conversion.To<T>(decoded["result"]);
       });
     }
   }

Parse/Internal/Command/IParseCommandRunner.cs renamed to ParseCore/Internal/Command/IParseCommandRunner.cs

@@ -6,8 +6,8 @@
 using System.Threading;
 using System.Threading.Tasks;
 
-namespace Parse.Internal {
-  internal interface IParseCommandRunner {
+namespace Parse.Core.Internal {
+  public interface IParseCommandRunner {
     /// <summary>
     /// Executes <see cref="ParseCommand"/> and convert the result into Dictionary.
     /// </summary>

ParseCore/Internal/Command/ParseCommand.cs

@@ -0,0 +1,69 @@
+// Copyright (c) 2015-present, Parse, LLC.  All rights reserved.  This source code is licensed under the BSD-style license found in the LICENSE file in the root directory of this source tree.  An additional grant of patent rights can be found in the PATENTS file in the same directory.
+
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Text;
+using Parse.Common.Internal;
+using System.Linq;
+
+namespace Parse.Core.Internal {
+  /// <summary>
+  /// ParseCommand is an <see cref="HttpRequest"/> with pre-populated
+  /// headers.
+  /// </summary>
+  public class ParseCommand : HttpRequest {
+    public IDictionary<string, object> DataObject { get; private set; }
+    public override Stream Data {
+      get {
+        if (base.Data != null) {
+          return base.Data;
+        }
+
+        return base.Data = (DataObject != null
+          ? new MemoryStream(Encoding.UTF8.GetBytes(Json.Encode(DataObject)))
+          : null);
+      }
+      set { base.Data = value; }
+    }
+
+    public ParseCommand(string relativeUri,
+        string method,
+        string sessionToken = null,
+        IList<KeyValuePair<string, string>> headers = null,
+        IDictionary<string, object> data = null) : this(relativeUri: relativeUri,
+            method: method,
+            sessionToken: sessionToken,
+            headers: headers,
+            stream: null,
+            contentType: data != null ? "application/json" : null) {
+      DataObject = data;
+    }
+
+    public ParseCommand(string relativeUri,
+        string method,
+        string sessionToken = null,
+        IList<KeyValuePair<string, string>> headers = null,
+        Stream stream = null,
+        string contentType = null) {
+      Uri = new Uri(new Uri(ParseClient.CurrentConfiguration.Server), relativeUri);
+      Method = method;
+      Data = stream;
+      Headers = new List<KeyValuePair<string, string>>(headers ?? Enumerable.Empty<KeyValuePair<string, string>>());
+
+      if (!string.IsNullOrEmpty(sessionToken)) {
+        Headers.Add(new KeyValuePair<string, string>("X-Parse-Session-Token", sessionToken));
+      }
+      if (!string.IsNullOrEmpty(contentType)) {
+        Headers.Add(new KeyValuePair<string, string>("Content-Type", contentType));
+      }
+    }
+
+    public ParseCommand(ParseCommand other) {
+      this.Uri = other.Uri;
+      this.Method = other.Method;
+      this.DataObject = other.DataObject;
+      this.Headers = new List<KeyValuePair<string, string>>(other.Headers);
+    }
+  }
+}

ParseCore/Internal/Command/ParseCommandRunner.cs

@@ -0,0 +1,108 @@
+// Copyright (c) 2015-present, Parse, LLC.  All rights reserved.  This source code is licensed under the BSD-style license found in the LICENSE file in the root directory of this source tree.  An additional grant of patent rights can be found in the PATENTS file in the same directory.
+
+using System;
+using System.Collections.Generic;
+using System.Net;
+using System.Threading;
+using System.Threading.Tasks;
+using Parse.Common.Internal;
+
+namespace Parse.Core.Internal {
+  public class ParseCommandRunner : IParseCommandRunner {
+    private readonly IHttpClient httpClient;
+    private readonly IInstallationIdController installationIdController;
+
+    public ParseCommandRunner(IHttpClient httpClient, IInstallationIdController installationIdController) {
+      this.httpClient = httpClient;
+      this.installationIdController = installationIdController;
+    }
+
+    public Task<Tuple<HttpStatusCode, IDictionary<string, object>>> RunCommandAsync(ParseCommand command,
+        IProgress<ParseUploadProgressEventArgs> uploadProgress = null,
+        IProgress<ParseDownloadProgressEventArgs> downloadProgress = null,
+        CancellationToken cancellationToken = default(CancellationToken)) {
+      return PrepareCommand(command).ContinueWith(commandTask => {
+        return httpClient.ExecuteAsync(commandTask.Result, uploadProgress, downloadProgress, cancellationToken).OnSuccess(t => {
+          cancellationToken.ThrowIfCancellationRequested();
+
+          var response = t.Result;
+          var contentString = response.Item2;
+          int responseCode = (int)response.Item1;
+          if (responseCode >= 500) {
+            // Server error, return InternalServerError.
+            throw new ParseException(ParseException.ErrorCode.InternalServerError, response.Item2);
+          } else if (contentString != null) {
+            IDictionary<string, object> contentJson = null;
+            try {
+              if (contentString.StartsWith("[")) {
+                var arrayJson = Json.Parse(contentString);
+                contentJson = new Dictionary<string, object> { { "results", arrayJson } };
+              } else {
+                contentJson = Json.Parse(contentString) as IDictionary<string, object>;
+              }
+            } catch (Exception e) {
+              throw new ParseException(ParseException.ErrorCode.OtherCause,
+                  "Invalid response from server", e);
+            }
+            if (responseCode < 200 || responseCode > 299) {
+              int code = (int)(contentJson.ContainsKey("code") ? (long)contentJson["code"] : (int)ParseException.ErrorCode.OtherCause);
+              string error = contentJson.ContainsKey("error") ?
+                  contentJson["error"] as string :
+                  contentString;
+              throw new ParseException((ParseException.ErrorCode)code, error);
+            }
+            return new Tuple<HttpStatusCode, IDictionary<string, object>>(response.Item1,
+                contentJson);
+          }
+          return new Tuple<HttpStatusCode, IDictionary<string, object>>(response.Item1, null);
+        });
+      }).Unwrap();
+    }
+
+    private const string revocableSessionTokenTrueValue = "1";
+    private Task<ParseCommand> PrepareCommand(ParseCommand command) {
+      ParseCommand newCommand = new ParseCommand(command);
+
+      Task<ParseCommand> installationIdTask = installationIdController.GetAsync().ContinueWith(t => {
+        newCommand.Headers.Add(new KeyValuePair<string, string>("X-Parse-Installation-Id", t.Result.ToString()));
+        return newCommand;
+      });
+
+      // TODO (richardross): Inject configuration instead of using shared static here.
+      ParseClient.Configuration configuration = ParseClient.CurrentConfiguration;
+      newCommand.Headers.Add(new KeyValuePair<string, string>("X-Parse-Application-Id", configuration.ApplicationId));
+      newCommand.Headers.Add(new KeyValuePair<string, string>("X-Parse-Client-Version", ParseClient.VersionString));
+
+      if (configuration.AdditionalHTTPHeaders != null) {
+        foreach (var header in configuration.AdditionalHTTPHeaders) {
+          newCommand.Headers.Add(header);
+        }
+      }
+
+      if (!string.IsNullOrEmpty(configuration.VersionInfo.BuildVersion)) {
+        newCommand.Headers.Add(new KeyValuePair<string, string>("X-Parse-App-Build-Version", configuration.VersionInfo.BuildVersion));
+      }
+      if (!string.IsNullOrEmpty(configuration.VersionInfo.DisplayVersion)) {
+        newCommand.Headers.Add(new KeyValuePair<string, string>("X-Parse-App-Display-Version", configuration.VersionInfo.DisplayVersion));
+      }
+      if (!string.IsNullOrEmpty(configuration.VersionInfo.OSVersion)) {
+        newCommand.Headers.Add(new KeyValuePair<string, string>("X-Parse-OS-Version", configuration.VersionInfo.OSVersion));
+      }
+
+      // TODO (richardross): I hate the idea of having this super tightly coupled static variable in here.
+      // Lets eventually get rid of it.
+      if (!string.IsNullOrEmpty(ParseClient.MasterKey)) {
+        newCommand.Headers.Add(new KeyValuePair<string, string>("X-Parse-Master-Key", ParseClient.MasterKey));
+      } else {
+        newCommand.Headers.Add(new KeyValuePair<string, string>("X-Parse-Windows-Key", configuration.WindowsKey));
+      }
+
+      // TODO (richardross): Inject this instead of using static here.
+      if (ParseUser.IsRevocableSessionEnabled) {
+        newCommand.Headers.Add(new KeyValuePair<string, string>("X-Parse-Revocable-Session", revocableSessionTokenTrueValue));
+      }
+
+      return installationIdTask;
+    }
+  }
+}

Parse/Internal/Config/Controller/IParseConfigController.cs renamed to ParseCore/Internal/Config/Controller/IParseConfigController.cs

@@ -4,8 +4,8 @@
 using System.Threading.Tasks;
 using System.Threading;
 
-namespace Parse.Internal {
-  interface IParseConfigController {
+namespace Parse.Core.Internal {
+  public interface IParseConfigController {
     /// <summary>
     /// Gets the current config controller.
     /// </summary>

Parse/Internal/Config/Controller/IParseCurrentConfigController.cs renamed to ParseCore/Internal/Config/Controller/IParseCurrentConfigController.cs

@@ -3,8 +3,8 @@
 using System;
 using System.Threading.Tasks;
 
-namespace Parse.Internal {
-  interface IParseCurrentConfigController {
+namespace Parse.Core.Internal {
+  public interface IParseCurrentConfigController {
     /// <summary>
     /// Gets the current config async.
     /// </summary>

Parse/Internal/Config/Controller/ParseConfigController.cs renamed to ParseCore/Internal/Config/Controller/ParseConfigController.cs

@@ -3,19 +3,24 @@
 using System;
 using System.Threading.Tasks;
 using System.Threading;
+using Parse.Common.Internal;
 
-namespace Parse.Internal {
+namespace Parse.Core.Internal {
   /// <summary>
   /// Config controller.
   /// </summary>
   internal class ParseConfigController : IParseConfigController {
+    private readonly IParseCommandRunner commandRunner;
+
     /// <summary>
     /// Initializes a new instance of the <see cref="ParseConfigController"/> class.
     /// </summary>
-    public ParseConfigController() {
-      CurrentConfigController = new ParseCurrentConfigController();
+    public ParseConfigController(IParseCommandRunner commandRunner, IStorageController storageController) {
+      this.commandRunner = commandRunner;
+      CurrentConfigController = new ParseCurrentConfigController(storageController);
     }
 
+    public IParseCommandRunner CommandRunner { get; internal set; }
     public IParseCurrentConfigController CurrentConfigController { get; internal set; }
 
     public Task<ParseConfig> FetchConfigAsync(String sessionToken, CancellationToken cancellationToken) {
@@ -24,7 +29,7 @@ public Task<ParseConfig> FetchConfigAsync(String sessionToken, CancellationToken
           sessionToken: sessionToken,
           data: null);
 
-      return ParseClient.ParseCommandRunner.RunCommandAsync(command, cancellationToken: cancellationToken).OnSuccess(task => {
+      return commandRunner.RunCommandAsync(command, cancellationToken: cancellationToken).OnSuccess(task => {
         cancellationToken.ThrowIfCancellationRequested();
         return new ParseConfig(task.Result.Item2);
       }).OnSuccess(task => {