From 053473394e6e0990c68a924adbb7c7d75f35973d Mon Sep 17 00:00:00 2001 From: Jules Laplace Date: Fri, 11 Dec 2015 02:07:02 -0600 Subject: pushplugin on android --- .../src/wp8/ParsePlugin.cs | 90 + .../src/wp8/parse/Parse.Phone.dll | Bin 0 -> 55808 bytes .../src/wp8/parse/Parse.Phone.xml | 754 ++++++ .../src/wp8/parse/Parse.dll | Bin 0 -> 172032 bytes .../src/wp8/parse/Parse.xml | 2670 ++++++++++++++++++++ 5 files changed, 3514 insertions(+) create mode 100644 StoneIsland/plugins/com.parse.cordova.core.pushplugin/src/wp8/ParsePlugin.cs create mode 100644 StoneIsland/plugins/com.parse.cordova.core.pushplugin/src/wp8/parse/Parse.Phone.dll create mode 100644 StoneIsland/plugins/com.parse.cordova.core.pushplugin/src/wp8/parse/Parse.Phone.xml create mode 100644 StoneIsland/plugins/com.parse.cordova.core.pushplugin/src/wp8/parse/Parse.dll create mode 100644 StoneIsland/plugins/com.parse.cordova.core.pushplugin/src/wp8/parse/Parse.xml (limited to 'StoneIsland/plugins/com.parse.cordova.core.pushplugin/src/wp8') diff --git a/StoneIsland/plugins/com.parse.cordova.core.pushplugin/src/wp8/ParsePlugin.cs b/StoneIsland/plugins/com.parse.cordova.core.pushplugin/src/wp8/ParsePlugin.cs new file mode 100644 index 00000000..58d1c42e --- /dev/null +++ b/StoneIsland/plugins/com.parse.cordova.core.pushplugin/src/wp8/ParsePlugin.cs @@ -0,0 +1,90 @@ +using System; +using System.Collections.Generic; +using Parse; +using WPCordovaClassLib.Cordova; + +namespace WPCordovaClassLib.Cordova.Commands +{ + public class ParsePlugin : BaseCommand + { + + + public async void initialize(string args) + { + + PluginResult result; + + try + { + var appId = JSON.JsonHelper.Deserialize(args)[0].ToString(); + var clientKey = JSON.JsonHelper.Deserialize(args)[1].ToString(); + + ParseClient.Initialize(appId, clientKey); + + + await ParseInstallation.CurrentInstallation.SaveAsync(); + + + DispatchCommandResult( new PluginResult(PluginResult.Status.OK, true)); + } + catch (Exception e) + { + DispatchCommandResult(new PluginResult(PluginResult.Status.ERROR, false)); + } + + + + + } + + public void getInstallationId(string args) + { + + String installationId = ParseInstallation.CurrentInstallation.InstallationId.ToString(); + var result = new PluginResult(PluginResult.Status.OK, installationId); + DispatchCommandResult(result); + + } + + public void getInstallationObjectId(string args) + { + + String objectId = ParseInstallation.CurrentInstallation.ObjectId.ToString(); + var result = new PluginResult(PluginResult.Status.OK, objectId); + DispatchCommandResult(result); + + } + + public void getSubscriptions(string args) + { + + + var installation = ParseInstallation.CurrentInstallation; + IEnumerable subscribedChannels = installation.Channels; + var result = new PluginResult(PluginResult.Status.OK, subscribedChannels); + DispatchCommandResult(result); + + } + + public void subscribe(string args) + { + var topic = JSON.JsonHelper.Deserialize(args)[0].ToString(); + ParsePush.SubscribeAsync(topic); + + DispatchCommandResult( new PluginResult(PluginResult.Status.OK, true)); + + + } + + public void unsubscribe(string args) + { + var topic = JSON.JsonHelper.Deserialize(args)[0].ToString(); + ParsePush.UnsubscribeAsync(topic); + + DispatchCommandResult(new PluginResult(PluginResult.Status.OK, true)); + } + + + + } +} \ No newline at end of file diff --git a/StoneIsland/plugins/com.parse.cordova.core.pushplugin/src/wp8/parse/Parse.Phone.dll b/StoneIsland/plugins/com.parse.cordova.core.pushplugin/src/wp8/parse/Parse.Phone.dll new file mode 100644 index 00000000..4f3421c7 Binary files /dev/null and b/StoneIsland/plugins/com.parse.cordova.core.pushplugin/src/wp8/parse/Parse.Phone.dll differ diff --git a/StoneIsland/plugins/com.parse.cordova.core.pushplugin/src/wp8/parse/Parse.Phone.xml b/StoneIsland/plugins/com.parse.cordova.core.pushplugin/src/wp8/parse/Parse.Phone.xml new file mode 100644 index 00000000..a4a105c4 --- /dev/null +++ b/StoneIsland/plugins/com.parse.cordova.core.pushplugin/src/wp8/parse/Parse.Phone.xml @@ -0,0 +1,754 @@ + + + + Parse.Phone + + + + + Provides an interface to Parse's logging and analytics backend. + + Methods will return immediately and cache requests (along with timestamps) + to be handled in the background. + + + + + Tracks this application being launched. + + An Async Task that can be waited on or ignored. + + + + Tracks the occurrence of a custom event with additional dimensions. + Parse will store a data point at the time of invocation with the + given event name. + + Dimensions will allow segmentation of the occurrences of this + custom event. + + To track a user signup along with additional metadata, consider the + following: + + IDictionary<string, string> dims = new Dictionary<string, string> { + { "gender", "m" }, + { "source", "web" }, + { "dayType", "weekend" } + }; + ParseAnalytics.TrackEventAsync("signup", dims); + + + There is a default limit of 8 dimensions per event tracked. + + The name of the custom event to report to ParseClient + as having happened. + An Async Task that can be waited on or ignored. + + + + Tracks the occurrence of a custom event with additional dimensions. + Parse will store a data point at the time of invocation with the + given event name. + + Dimensions will allow segmentation of the occurrences of this + custom event. + + To track a user signup along with additional metadata, consider the + following: + + IDictionary<string, string> dims = new Dictionary<string, string> { + { "gender", "m" }, + { "source", "web" }, + { "dayType", "weekend" } + }; + ParseAnalytics.TrackEventAsync("signup", dims); + + + There is a default limit of 8 dimensions per event tracked. + + The name of the custom event to report to ParseClient + as having happened. + The dictionary of information by which to + segment this event. + An Async Task that can be waited on or ignored. + + + + Private method, used by platform-specific extensions to report an app-open + to the server. + + An identifying hash for a given push notification, + passed down from the server. + An Async Task that can be waited on or ignored. + + + + This method adds event listeners to track app opens from tiles, the app list, + and push notifications. Windows Phone 8 developers should use TrackAppOpens instead of + TrackAppOpenedAsync, which this method will call automatically. + + This method can be called in Application_Launching or as follows in the Application constructor: + + + this.Startup += (sender, args) => { + ParseAnalytics.TrackAppOpens(RootFrame); + }; + + + The RootFrame of the Application. + + + + Provides a set of utilities for using Parse with Facebook. + + + + + Initializes Facebook for use with Parse. + + Your Facebook application ID. + + + + Logs in a using Facebook for authentication. If a user for the + given Facebook credentials does not already exist, a new user will be created. + + The user's Facebook ID. + A valid access token for the user. + The expiration date of the access token. + The cancellation token. + The user that was either logged in or created. + + + + Logs in a using Facebook for authentication. If a user for the + given Facebook credentials does not already exist, a new user will be created. + + The user's Facebook ID. + A valid access token for the user. + The expiration date of the access token. + The user that was either logged in or created. + + + + Links a to a Facebook account, allowing you to use Facebook + for authentication, and providing access to Facebook data for the user. + + The user to link to a Facebook account. + The user's Facebook ID. + A valid access token for the user. + The expiration date of the access token. + The cancellation token. + + + + Links a to a Facebook account, allowing you to use Facebook + for authentication, and providing access to Facebook data for the user. + + The user to link to a Facebook account. + The user's Facebook ID. + A valid access token for the user. + The expiration date of the access token. + + + + Gets whether the given user is linked to a Facebook account. This can only be used on + the currently authorized user. + + The user to check. + true if the user is linked to a Facebook account. + + + + Unlinks a user from a Facebook account. Unlinking a user will save the user's data. + + The user to unlink. + The cancellation token. + + + + Unlinks a user from a Facebook account. Unlinking a user will save the user's data. + + The user to unlink. + + + + Fetches the app's ProductID from its manifest. + + + + + Checks whether the Uri passed into your application comes from the Facebook + app as a result of a completed login attempt. + + Your code will usually look like this: + + RootFrame.Navigating += async (sender, e) => { + if (ParseFacebookUtils.IsLoginRedirect(e.Uri)) { + ParseUser user = await ParseFacebookUtils.EndLoginAsync( + sender, e, new Uri("/LandingPage.xaml", UriKind.Relative)); + // A new user is now logged in. + } + }; + + + + true iff the Uri is a Facebook login redirect, false + otherwise + + + + Call this method within your RootFrame.Navigating event handler to complete native Facebook + sign-on. When handling a Facebook login redirect URI, this method will cancel the + pending navigation, begin asynchronously logging in the user, and immediately navigate + to the . + + Your code will usually look like this: + + RootFrame.Navigating += async (sender, e) => { + if (ParseFacebookUtils.IsLoginRedirect(e.Uri)) { + ParseUser user = await ParseFacebookUtils.EndLoginAsync( + sender, e, new Uri("/LandingPage.xaml", UriKind.Relative)); + // A new user is now logged in. + } + }; + + + The sender for the Navigating event. + The Navigating event args. + The Uri within your app to redirect to. + The ParseUser created or logged in using Facebook credentials, or null if + this was not a Facebook login redirect. + + + + Logs in a using Facebook for authentication. If a user for the + given Facebook credentials does not already exist, a new user will be created. + + The user will be logged in through the Facebook app's single sign-on mechanism. + + You must add a handler to your RootFrame's Navigating event that calls EndLogInAsync so + that ParseFacebookUtils can handle incoming navigation attempts. + = + A list of Facebook permissions to request. + + + + Logs in a using Facebook for authentication. If a user for the + given Facebook credentials does not already exist, a new user will be created. + + The user will be logged in through Facebook's OAuth web flow, so you must supply a + that will be navigated to Facebook's authentication pages. + + A web view that will be used to present the authorization pages + to the user. + A list of Facebook permissions to request. + The cancellation token. + The user that was either logged in or created. + + + + Links a to a Facebook account, allowing you to use Facebook + for authentication, and providing access to Facebook datta for the user. + + The user will be logged in through Facebook's OAuth web flow, so you must supply a + that will be navigated to Facebook's authentication pages. + + The user to link with Facebook. + A web view that will be used to present the authorization pages + to the user. + A list of Facebook permissions to request. + The cancellation token. + + + + Logs in a using Facebook for authentication . If a user for the + given Facebook credentials does not already exist, a new user will be created. + + The user will be logged in through Facebook's OAuth web flow, so you must supply a + that will be navigated to Facebook's authentication pages. + + A web view that will be used to present the authorization pages + to the user. + A list of Facebook permissions to request. + The user that was either logged in or created. + + + + Links a to a Facebook account, allowing you to use Facebook + for authentication, and providing access to Facebook datta for the user. + + The user will be logged in through Facebook's OAuth web flow, so you must supply a + that will be navigated to Facebook's authentication pages. + + The user to link with Facebook. + A web view that will be used to present the authorization pages + to the user. + A list of Facebook permissions to request. + + + + Gets the Facebook Application ID as supplied to + + + + + Gets the access token for the currently logged in Facebook user. This can be used with a + Facebook SDK to get access to Facebook user data. + + + + + Provides a dictionary that gets persisted on the filesystem between runs of the app. + This is analogous to NSUserDefaults in iOS. + + + + + Wraps the custom settings object for Parse so that it can be exposed as ApplicationSettings. + + + + + A utility class for sending push notifications. + + + + + Extract the JSON dictionary used to send this push. + + The args parameter passed to a push received event. + The JSON dictionary used to send this push. + + + + A method for getting the JSON dictionary used to send a push notification from the + OnNavigated event handler, i.e. + + + public override void OnNavigatedTo(NavigationEventArgs args) { + var json = PushJson(args); + /* ... */ + } + + + The args parameter passed to OnNavigatedTo + The JSON dictionary used to send this push. + + + + Creates a push which will target every device. The Data field must be set before calling SendAsync. + + + + + Request a push to be sent. When this task completes, Parse has successfully acknowledged a request + to send push notifications but has not necessarily finished sending all notifications + requested. The current status of recent push notifications can be seen in your Push Notifications + console on http://parse.com + + A Task for continuation. + + + + Request a push to be sent. When this task completes, Parse has successfully acknowledged a request + to send push notifications but has not necessarily finished sending all notifications + requested. The current status of recent push notifications can be seen in your Push Notifications + console on http://parse.com + + CancellationToken to cancel the current operation. + + + + Subscribe the current installation to this channel. This is shorthand for: + + + var installation = ParseInstallation.CurrentInstallation; + installation.AddUniqueToList("channels", channel); + installation.SaveAsync(); + + + The channel to which this installation should subscribe. + + + + Subscribe the current installation to this channel. This is shorthand for: + + + var installation = ParseInstallation.CurrentInstallation; + installation.AddUniqueToList("channels", channel); + installation.SaveAsync(cancellationToken); + + + The channel to which this installation should subscribe. + CancellationToken to cancel the current operation. + + + + Subscribe the current installation to these channels. This is shorthand for: + + + var installation = ParseInstallation.CurrentInstallation; + installation.AddRangeUniqueToList("channels", channels); + installation.SaveAsync(); + + + The channels to which this installation should subscribe. + + + + Subscribe the current installation to these channels. This is shorthand for: + + + var installation = ParseInstallation.CurrentInstallation; + installation.AddRangeUniqueToList("channels", channels); + installation.SaveAsync(cancellationToken); + + + The channels to which this installation should subscribe. + CancellationToken to cancel the current operation. + + + + Unsubscribe the current installation from this channel. This is shorthand for: + + + var installation = ParseInstallation.CurrentInstallation; + installation.Remove("channels", channel); + installation.SaveAsync(); + + + The channel from which this installation should unsubscribe. + + + + Unsubscribe the current installation from this channel. This is shorthand for: + + + var installation = ParseInstallation.CurrentInstallation; + installation.Remove("channels", channel); + installation.SaveAsync(cancellationToken); + + + The channel from which this installation should unsubscribe. + CancellationToken to cancel the current operation. + + + + Unsubscribe the current installation from these channels. This is shorthand for: + + + var installation = ParseInstallation.CurrentInstallation; + installation.RemoveAllFromList("channels", channels); + installation.SaveAsync(); + + + The channels from which this installation should unsubscribe. + + + + Unsubscribe the current installation from these channels. This is shorthand for: + + + var installation = ParseInstallation.CurrentInstallation; + installation.RemoveAllFromList("channels", channels); + installation.SaveAsync(cancellationToken); + + + The channels from which this installation should unsubscribe. + CancellationToken to cancel the current operation. + + + + Pushes a simple message to every device. This is shorthand for: + + + var push = new ParsePush(); + push.Data = new Dictionary<string, object>{{"alert", alert}}; + return push.SendAsync(); + + + The alert message to send. + + + + Pushes a simple message to every device subscribed to channel. This is shorthand for: + + + var push = new ParsePush(); + push.Channels = new List<string> { channel }; + push.Data = new Dictionary<string, object>{{"alert", alert}}; + return push.SendAsync(); + + + The alert message to send. + An Installation must be subscribed to channel to receive this Push Notification. + + + + Pushes a simple message to every device subscribed to any of channels. This is shorthand for: + + + var push = new ParsePush(); + push.Channels = channels; + push.Data = new Dictionary<string, object>{{"alert", alert}}; + return push.SendAsync(); + + + The alert message to send. + An Installation must be subscribed to any of channels to receive this Push Notification. + + + + Pushes a simple message to every device matching the target query. This is shorthand for: + + + var push = new ParsePush(); + push.Query = query; + push.Data = new Dictionary<string, object>{{"alert", alert}}; + return push.SendAsync(); + + + The alert message to send. + A query filtering the devices which should receive this Push Notification. + + + + Pushes an arbitrary payload to every device. This is shorthand for: + + + var push = new ParsePush(); + push.Data = data; + return push.SendAsync(); + + + A push payload. See the ParsePush.Data property for more information. + + + + Pushes an arbitrary payload to every device subscribed to channel. This is shorthand for: + + + var push = new ParsePush(); + push.Channels = new List<string> { channel }; + push.Data = data; + return push.SendAsync(); + + + A push payload. See the ParsePush.Data property for more information. + An Installation must be subscribed to channel to receive this Push Notification. + + + + Pushes an arbitrary payload to every device subscribed to any of channels. This is shorthand for: + + + var push = new ParsePush(); + push.Channels = channels; + push.Data = data; + return push.SendAsync(); + + + A push payload. See the ParsePush.Data property for more information. + An Installation must be subscribed to any of channels to receive this Push Notification. + + + + Pushes an arbitrary payload to every device matching target. This is shorthand for: + + + var push = new ParsePush(); + push.Query = query + push.Data = data; + return push.SendAsync(); + + + A push payload. See the ParsePush.Data property for more information. + A query filtering the devices which should receive this Push Notification. + + + + An event fired when a push notification of any type (i.e. toast, tile, badge, or raw) is + received. + + + + + A generic event handler for notifications of all types. Because this event is also fired + when a raw notification is sent, the event args are very hard to use. You only get a byte + stream! We'll reveal this publicly once we support raw notifications; in the meantime we + should leave ToastNotificationReceived as the golden road. + + + + + An installation query that specifies which installations shoudl receive + this push. + This should not be used in tandem with Channels. + + + + + A short-hand to set a query which only discriminates on the channels to which a device is subscribed. + This is shorthand for: + + + var push = new Push(); + push.Query = ParseInstallation.Query.WhereKeyContainedIn("channels", channels); + + + This cannot be used in tandem with Query. + + + + + The time at which this push will expire. This should not be used in tandem with ExpirationInterval. + + + + + The time from initial schedul when this push will expire. This should not be used in tandem with Expiration. + + + + + The contents of this push. Some keys have special meaning. A full list of pre-defined + keys can be found in the Parse Push Guide. The following keys affect WinRT devices. + Keys which do not start with x-winrt- can be prefixed with x-winrt- to specify an + override only sent to winrt devices. + alert: the body of the alert text. + title: The title of the text. + x-winrt-payload: A full XML payload to be sent to WinRT installations instead of + the auto-layout. + This should not be used in tandem with Alert. + + + + + A conveninence method which sets Data to a dictionary with alert as its only field. Equivalent to + + + Data = new Dictionary<string, object> {{"alert", alert}}; + + + This should not be used in tandem with Data. + + + + + Represents this app installed on this device. Use this class to track infomation you want + to sample from (i.e. if you update a field on app launch, you can issue a query to see + the number of devices which were active in the last N hours). + + + + + Whether the currentInstallation is known to match the serialized version on disk. + This is useful for saving a filesystem check if you try to load currentInstallation + frequently while there is none on disk. + + + + + Constructs a new ParseInstallation. Generally, you should not need to construct + ParseInstallations yourself. Instead use . + + + + + This mapping of Windows names to a standard everyone else uses is maintained + by the Unicode consortium, which makes this officially the first helpful + interaction between Unicode and Microsoft. + Unfortunately this is a little lossy in that we only store the first mapping in each zone because + Microsoft does not give us more granular location information. + Built from http://unicode.org/repos/cldr-tmp/trunk/diff/supplemental/zone_tzid.html + + + + + Future proofing: Right now there's only one valid channel for the app, but we will likely + want to allow additional channels for auxiliary tiles (i.e. a contacts app can have a new + channel for each contact and the UI needs to pop up on the right tile). The expansion job + generically has one _Installation field it passes to device-specific code, so we store a map + of tag -> channel URI. Right now, there is only one valid tag and it is automatic. + Unsed variable warnings are suppressed becaue this const is used in WinRT and WinPhone but not NetFx. + + + + + Gets an attribute from the Windows Phone App Manifest App element + + the attribute name + the attribute value + + + + Gets the ParseInstallation representing this app on this device. + + + + + Constructs a for ParseInstallations. + + + Only the following types of queries are allowed for installations: + + + query.GetAsync(objectId) + query.WhereEqualTo(key, value) + query.WhereMatchesKeyInQuery<TOther>(key, keyInQuery, otherQuery) + + + You can add additional query conditions, but one of the above must appear as a top-level AND + clause in the query. + + + + + A GUID that uniquely names this app installed on this device. + + + + + The time zone in which this device resides. This string is in the tz database format + Parse uses for local-time pushes. Due to platform restrictions, the mapping is less + granular on Windows than it may be on other systems. E.g. The zones + America/Vancouver America/Dawson America/Whitehorse, America/Tijuana, PST8PDT, and + America/Los_Angeles are all reported as America/Los_Angeles. + + + + + The version of the Parse SDK used to build this application. + + + + + A sequence of arbitrary strings which are used to identify this installation for push notifications. + By convention, the empty string is known as the "Broadcast" channel. + + + + + The runtime target of this application. Is one of winrt, winphone, or dotnet. + + + + + The user-friendly display name of this application. + + + + + The system-dependent unique identifier of this installation. This identifier should be + sufficient to distinctly name an app on stores which may allow multiple apps with the + same display name. + + + + + A version string consisting of Major.Minor.Build.Revision. + + + + diff --git a/StoneIsland/plugins/com.parse.cordova.core.pushplugin/src/wp8/parse/Parse.dll b/StoneIsland/plugins/com.parse.cordova.core.pushplugin/src/wp8/parse/Parse.dll new file mode 100644 index 00000000..a7d32fff Binary files /dev/null and b/StoneIsland/plugins/com.parse.cordova.core.pushplugin/src/wp8/parse/Parse.dll differ diff --git a/StoneIsland/plugins/com.parse.cordova.core.pushplugin/src/wp8/parse/Parse.xml b/StoneIsland/plugins/com.parse.cordova.core.pushplugin/src/wp8/parse/Parse.xml new file mode 100644 index 00000000..c3709e5a --- /dev/null +++ b/StoneIsland/plugins/com.parse.cordova.core.pushplugin/src/wp8/parse/Parse.xml @@ -0,0 +1,2670 @@ + + + + Parse + + + + + Authenticates with the service. + + The cancellation token. + + + + Deauthenticates (logs out) the user associated with this provider. This + call may block. + + + + + Restores authentication that has been serialized, such as session keys, + etc. + + The auth data for the provider. This value may be null + when unlinking an account. + true iff the authData was successfully synchronized. A false return + value indicates that the user should no longer be associated because of bad auth + data. + + + + Provides a unique name for the type of authentication the provider does. + For example, the FacebookAuthenticationProvider would return "facebook". + + + + + Parses a uri, looking for a base uri that represents facebook login completion, and then + converting the query string into a dictionary of key-value pairs. (e.g. access_token) + + + + + Provides a Dictionary implementation that can delegate to any other + dictionary, regardless of its value type. Used for coercion of + dictionaries when returning them to users. + + The resulting type of value in the dictionary. + The original type of value in the dictionary. + + + + Provides a List implementation that can delegate to any other + list, regardless of its value type. Used for coercion of + lists when returning them to users. + + The resulting type of value in the list. + The original type of value in the list. + + + + An equality comparer that uses the object identity (i.e. ReferenceEquals) + rather than .Equals, allowing identity to be used for checking equality in + ISets and IDictionaries. + + + + + Provides helper methods that allow us to use terser code elsewhere. + + + + + Ensures a task (even null) is awaitable. + + + + + + + + Ensures a task (even null) is awaitable. + + + + + + + Partial methods cannot return a value, so we instead make partial accessors + use ref params. This helper can be used to write code more normally so we get + the out-param or default when calling a partial method. Given a partial method: + partial void GetFoo(ref string foo) + we can say string foo = this.GetPartial<string>(GetFoo); + + + + + + + + Partial methods cannot return a value, so we instead make partial accessors + use ref params. This means you cannot effectively make a partial which is + async. This code helps create a design pattern where a partial takes a ref Task + param and we can await the PartialAsync of it. Given a partial method: + partial void FooAsync(ref Task<string> task) + we can say string foo = await PartialAsync<string>(FooAsync); + + + + + + + + + A ParseFieldOperation represents a modification to a value in a ParseObject. + For example, setting, deleting, or incrementing a value are all different kinds of + ParseFieldOperations. ParseFieldOperations themselves can be considered to be + immutable. + + + + + Converts the ParseFieldOperation to a data structure that can be converted to JSON and sent to + Parse as part of a save operation. + + An object to be JSONified. + + + + Returns a field operation that is composed of a previous operation followed by + this operation. This will not mutate either operation. However, it may return + this if the current operation is not affected by previous changes. + For example: + {increment by 2}.MergeWithPrevious({set to 5}) -> {set to 7} + {set to 5}.MergeWithPrevious({increment by 2}) -> {set to 5} + {add "foo"}.MergeWithPrevious({delete}) -> {set to ["foo"]} + {delete}.MergeWithPrevious({add "foo"}) -> {delete} /// + The most recent operation on the field, or null if none. + A new ParseFieldOperation or this. + + + + Returns a new estimated value based on a previous value and this operation. This + value is not intended to be sent to Parse, but it is used locally on the client to + inspect the most likely current value for a field. + + The key and object are used solely for ParseRelation to be able to construct objects + that refer back to their parents. + + The previous value for the field. + The object that contains this value. + The key that this value is for. + The new value for the field. + + + + A simple recursive-descent JSON Parser based on the grammar defined at http://www.json.org + and http://tools.ietf.org/html/rfc4627 + + + + + Place at the start of a regex to force the match to begin wherever the search starts (i.e. + anchored at the index of the first character of the search, even when that search starts + in the middle of the string). + + + + + Parses a JSON-text as defined in http://tools.ietf.org/html/rfc4627, returning an + IDictionary<string, object> or an IList<object> depending on whether + the value was an array or dictionary. Nested objects also match these types. + + + + + Encodes a dictionary into a JSON string. Suppots values that are + IDictionary<string, object>, IList<object>, strings, + nulls, and any of the primitive types. + + + + + Encodes a list into a JSON string. Suppots values that are + IDictionary<string, object>, IList<object>, strings, + nulls, and any of the primitive types. + + + + + Encodes an object into a JSON string. + + + + + Parses JSON object syntax (e.g. '{}') + + + + + Parses JSON member syntax (e.g. '"keyname" : null') + + + + + Parses JSON array syntax (e.g. '[]') + + + + + Parses a value (i.e. the right-hand side of an object member assignment or + an element in an array) + + + + + Parses a JSON string (e.g. '"foo\u1234bar\n"') + + + + + Parses a number. Returns a long if the number is an integer or has an exponent, + otherwise returns a double. + + + + + Matches the string to a regex, consuming part of the string and returning the match. + + + + + An operation where a field is deleted from the object. + + + + + The ParseConfig is a representation of the remote configuration object, + that enables you to add things like feature gating, a/b testing or simple "Message of the day". + + + + + Retrieves the ParseConfig asynchronously from the server. + + ParseConfig object that was fetched + + + + Retrieves the ParseConfig asynchronously from the server. + + The cancellation token. + ParseConfig object that was fetched + + + + Gets a value for the key of a particular type. + + The type to convert the value to. Supported types are + ParseObject and its descendents, Parse types such as ParseRelation and ParseGeopoint, + primitive types,IList<T>, IDictionary<string, T> and strings. + The key of the element to get. + The property is retrieved + and is not found. + The property under this + key was found, but of a different type. + + + + Populates result with the value for the key, if possible. + + The desired type for the value. + The key to retrieve a value for. + The value for the given key, converted to the + requested type, or null if unsuccessful. + true if the lookup and conversion succeeded, otherwise false. + + + + Gets the latest fetched ParseConfig. + + ParseConfig object + + + + Gets a value on the config. + + The key for the parameter. + The property is + retrieved and is not found. + The value for the key. + + + + Specifies a field name for a property on a ParseObject subclass. + + + + + Constructs a new ParseFieldName attribute. + + The name of the field on the ParseObject that the + property represents. + + + + Gets the name of the field represented by this property. + + + + + This method helps simplify the process of getting a constructor for a type. + A method like this exists in .NET but is not allowed in a Portable Class Library, + so we've built our own. + + + + + + + + Represents an event handler that calls back from the synchronization context + that subscribed. + Should look like an EventArgs, but may not inherit EventArgs if T is implemented by the Windows team. + + + + + A helper class for enqueuing tasks + + + + + We only need to keep the tail of the queue. Cancelled tasks will + just complete normally/immediately when their turn arrives. + + + + + Gets a cancellable task that can be safely awaited and is dependent + on the current tail of the queue. This essentially gives us a proxy + for the tail end of the queue whose awaiting can be cancelled. + + A cancellation token that cancels + the task even if the task is still in the queue. This allows the + running task to return immediately without breaking the dependency + chain. It also ensures that errors do not propagate. + A new task that should be awaited by enqueued tasks. + + + + Enqueues a task created by . If the task is + cancellable (or should be able to be cancelled while it is waiting in the + queue), pass a cancellationToken. + + The type of task. + A function given a task to await once state is + snapshotted (e.g. after capturing session tokens at the time of the save call). + Awaiting this task will wait for the created task's turn in the queue. + A cancellation token that can be used to + cancel waiting in the queue. + The task created by the taskStart function. + + + + Defines the class name for a subclass of ParseObject. + + + + + Constructs a new ParseClassName attribute. + + The class name to associate with the ParseObject subclass. + + + + Gets the class name to associate with the ParseObject subclass. + + + + + ParseFile is a local representation of a file that is saved to the Parse cloud. + + + The workflow is to construct a with data and a filename, + then save it and set it as a field on a ParseObject: + + + var file = new ParseFile("hello.txt", + new MemoryStream(Encoding.UTF8.GetBytes("hello"))); + await file.SaveAsync(); + var obj = new ParseObject("TestObject"); + obj["file"] = file; + await obj.SaveAsync(); + + + + + + Creates a new file from a byte array and a name. + + The file's name, ideally with an extension. The file name + must begin with an alphanumeric character, and consist of alphanumeric + characters, periods, spaces, underscores, or dashes. + The file's data. + To specify the content-type used when uploading the + file, provide this parameter. + + + + Creates a new file from a stream and a name. + + The file's name, ideally with an extension. The file name + must begin with an alphanumeric character, and consist of alphanumeric + characters, periods, spaces, underscores, or dashes. + The file's data. + To specify the content-type used when uploading the + file, provide this parameter. + + + + Saves the file to the Parse cloud. + + + + + Saves the file to the Parse cloud. + + The cancellation token. + + + + Saves the file to the Parse cloud. + + The progress callback. + + + + Saves the file to the Parse cloud. + + The progress callback. + The cancellation token. + + + + A list of file extensions to mime types as found here: + http://stackoverflow.com/questions/58510/using-net-how-can-you-find-the-mime-type-of-a-file-based-on-the-file-signature + + + + + Gets whether the file still needs to be saved. + + + + + Gets the name of the file. Before save is called, this is the filename given by + the user. After save is called, that name gets prefixed with a unique identifier. + + + + + Gets the MIME type of the file. This is either passed in to the constructor or + inferred from the file extension. "unknown/unknown" will be used if neither is + available. + + + + + Gets the url of the file. It is only available after you save the file or after + you get the file from a . + + + + + Provides extension methods for to support + Linq-style queries. + + + + + Gets a MethodInfo for a top-level method call. + + + + + When a query is normalized, this is a placeholder to indicate we should + add a WhereContainedIn() clause. + + + + + When a query is normalized, this is a placeholder to indicate we should + add a WhereNotContainedIn() clause. + + + + + When a query is normalized, this is a placeholder to indicate that we should + add a WhereExists() clause. + + + + + When a query is normalized, this is a placeholder to indicate that we should + add a WhereDoesNotExist() clause. + + + + + Evaluates an expression and throws if the expression has components that can't be + evaluated (e.g. uses the parameter that's only represented by an object on the server). + + + + + Checks whether the MethodCallExpression is a call to ParseObject.Get(), + which is the call we normalize all indexing into the ParseObject to. + + + + + Converts a normalized method call expression into the appropriate ParseQuery clause. + + + + + Converts a normalized binary expression into the appropriate ParseQuery clause. + + + + + Filters a query based upon the predicate provided. + + The type of ParseObject being queried for. + The base to which + the predicate will be added. + A function to test each ParseObject for a condition. + The predicate must be able to be represented by one of the standard Where + functions on ParseQuery + A new ParseQuery whose results will match the given predicate as + well as the source's filters. + + + + Normalizes an OrderBy's keySelector expression and then extracts the path + from the ParseObject.Get() call. + + + + + Orders a query based upon the key selector provided. + + The type of ParseObject being queried for. + The type of key returned by keySelector. + The query to order. + A function to extract a key from the ParseObject. + A new ParseQuery based on source whose results will be ordered by + the key specified in the keySelector. + + + + Orders a query based upon the key selector provided. + + The type of ParseObject being queried for. + The type of key returned by keySelector. + The query to order. + A function to extract a key from the ParseObject. + A new ParseQuery based on source whose results will be ordered by + the key specified in the keySelector. + + + + Performs a subsequent ordering of a query based upon the key selector provided. + + The type of ParseObject being queried for. + The type of key returned by keySelector. + The query to order. + A function to extract a key from the ParseObject. + A new ParseQuery based on source whose results will be ordered by + the key specified in the keySelector. + + + + Performs a subsequent ordering of a query based upon the key selector provided. + + The type of ParseObject being queried for. + The type of key returned by keySelector. + The query to order. + A function to extract a key from the ParseObject. + A new ParseQuery based on source whose results will be ordered by + the key specified in the keySelector. + + + + Correlates the elements of two queries based on matching keys. + + The type of ParseObjects of the first query. + The type of ParseObjects of the second query. + The type of the keys returned by the key selector + functions. + The type of the result. This must match either + TOuter or TInner + The first query to join. + The query to join to the first query. + A function to extract a join key from the results of + the first query. + A function to extract a join key from the results of + the second query. + A function to select either the outer or inner query + result to determine which query is the base query. + A new ParseQuery with a WhereMatchesQuery or WhereMatchesKeyInQuery + clause based upon the query indicated in the . + + + + Visits an Expression, converting ParseObject.Get/ParseObject[]/ParseObject.Property, + and nested indices into a single call to ParseObject.Get() with a "field path" like + "foo.bar.baz" + + + + + Check for a ParseFieldName attribute and use that as the path component, turning + properties like foo.ObjectId into foo.Get("objectId") + + + + + If a ParseObject.Get() call has been cast, just change the generic parameter. + + + + + Normalizes Where expressions. + + + + + Normalizes binary operators. <, >, <=, >= !=, and == + This puts the ParseObject.Get() on the left side of the operation + (reversing it if necessary), and normalizes the ParseObject.Get() + + + + + If a ! operator is used, this removes the ! and instead calls the equivalent + function (so e.g. == becomes !=, < becomes >=, Contains becomes NotContains) + + + + + Normalizes .Equals into == and Contains() into the appropriate stub. + + + + + A ParseACL is used to control which users and roles can access or modify a particular object. Each + can have its own ParseACL. You can grant read and write permissions + separately to specific users, to groups of users that belong to roles, or you can grant permissions + to "the public" so that, for example, any user could read a particular object but only a particular + set of users could write to that object. + + + + + Creates an ACL with no permissions granted. + + + + + Creates an ACL where only the provided user has access. + + The only user that can read or write objects governed by this ACL. + + + + Sets whether the given user id is allowed to read this object. + + The objectId of the user. + Whether the user has permission. + + + + Sets whether the given user is allowed to read this object. + + The user. + Whether the user has permission. + + + + Sets whether the given user id is allowed to write this object. + + The objectId of the user. + Whether the user has permission. + + + + Sets whether the given user is allowed to write this object. + + The user. + Whether the user has permission. + + + + Gets whether the given user id is *explicitly* allowed to read this object. + Even if this returns false, the user may still be able to read it if + PublicReadAccess is true or a role that the user belongs to has read access. + + The user objectId to check. + Whether the user has access. + + + + Gets whether the given user is *explicitly* allowed to read this object. + Even if this returns false, the user may still be able to read it if + PublicReadAccess is true or a role that the user belongs to has read access. + + The user to check. + Whether the user has access. + + + + Gets whether the given user id is *explicitly* allowed to write this object. + Even if this returns false, the user may still be able to write it if + PublicReadAccess is true or a role that the user belongs to has write access. + + The user objectId to check. + Whether the user has access. + + + + Gets whether the given user is *explicitly* allowed to write this object. + Even if this returns false, the user may still be able to write it if + PublicReadAccess is true or a role that the user belongs to has write access. + + The user to check. + Whether the user has access. + + + + Sets whether users belonging to the role with the given + are allowed to read this object. + + The name of the role. + Whether the role has access. + + + + Sets whether users belonging to the given role are allowed to read this object. + + The role. + Whether the role has access. + + + + Gets whether users belonging to the role with the given + are allowed to read this object. Even if this returns false, the role may still be + able to read it if a parent role has read access. + + The name of the role. + Whether the role has access. + + + + Gets whether users belonging to the role are allowed to read this object. + Even if this returns false, the role may still be able to read it if a + parent role has read access. + + The name of the role. + Whether the role has access. + + + + Sets whether users belonging to the role with the given + are allowed to write this object. + + The name of the role. + Whether the role has access. + + + + Sets whether users belonging to the given role are allowed to write this object. + + The role. + Whether the role has access. + + + + Gets whether users belonging to the role with the given + are allowed to write this object. Even if this returns false, the role may still be + able to write it if a parent role has write access. + + The name of the role. + Whether the role has access. + + + + Gets whether users belonging to the role are allowed to write this object. + Even if this returns false, the role may still be able to write it if a + parent role has write access. + + The name of the role. + Whether the role has access. + + + + Gets or sets whether the public is allowed to read this object. + + + + + Gets or sets whether the public is allowed to write this object. + + + + + ParseClient contains static functions that handle global + configuration for the Parse library. + + + + + Authenticates this client as belonging to your application. This must be + called before your application can use the Parse library. The recommended + way is to put a call to ParseFramework.Initialize in your + Application startup. + + The Application ID provided in the Parse dashboard. + + The .NET API Key provided in the Parse dashboard. + + + + + Convenience alias for RequestAsync that takes a string instead of a Uri. + + + + + The main mechanism for making requests to Parse. Attaches headers related to + the SDK, session token, etc., then JSON-parses the result of the request and throws + a ParseException if necessary. + + The HTTP method to use. + A relative URI for the API. + The session token for the request. + A JSON-style data object that will be stringified + for the request body. + The cancellation token for the request. + A tuple indicating the HTTP status code and the JSON data + returned by the request. + + + + Performs an upload that reports progress. + + + + + Performs a ConvertTo, but returns null if the object can't be + converted to that type. + + + + + Converts a value to the requested type -- coercing primitives to + the desired type, wrapping lists and dictionaries appropriately, + or else passing the object along to the caller unchanged. + + This should be used on any containers that might be coming from a + user to normalize the collection types. Collection types coming from + JSON deserialization can be safely assumed to be lists or dictionaries of + objects. + + + + + Holds a dictionary that maps a cache of interface types for related concrete types. + The lookup is slow the first time for each type because it has to enumerate all interface + on the object type, but made fast by the cache. + + The map is: + (object type, generic interface type) => constructed generic type + + + + + Flattens dictionaries and lists into a single enumerable of all contained objects + that can then be queried over. + + The root of the traversal + Whether to traverse into ParseObjects' children + Whether to include the root in the result + + + + + The ParseCloud class provides methods for interacting with Parse Cloud Functions. + + + For example, this sample code calls the + "validateGame" Cloud Function and calls processResponse if the call succeeded + and handleError if it failed. + + + var result = + await ParseCloud.CallFunctionAsync<IDictionary<string, object>>("validateGame", parameters); + + + + + + Calls a cloud function. + + The type of data you will receive from the cloud function. This + can be an IDictionary, string, IList, ParseObject, or any other type supported by + ParseObject. + The cloud function to call. + The parameters to send to the cloud function. This + dictionary can contain anything that could be passed into a ParseObject except for + ParseObjects themselves. + The result of the cloud call. + + + + Calls a cloud function. + + The type of data you will receive from the cloud function. This + can be an IDictionary, string, IList, ParseObject, or any other type supported by + ParseObject. + The cloud function to call. + The parameters to send to the cloud function. This + dictionary can contain anything that could be passed into a ParseObject except for + ParseObjects themselves. + The cancellation token. + The result of the cloud call. + + + + Exceptions that may occur when sending requests to Parse. + + + + + The Parse error code associated with the exception. + + + + + Error codes that may be delivered in response to requests to Parse. + + + + + Error code indicating that an unknown error or an error unrelated to Parse + occurred. + + + + + Error code indicating that something has gone wrong with the server. + If you get this error code, it is Parse's fault. Please report the bug to + https://parse.com/help. + + + + + Error code indicating the connection to the Parse servers failed. + + + + + Error code indicating the specified object doesn't exist. + + + + + Error code indicating you tried to query with a datatype that doesn't + support it, like exact matching an array or object. + + + + + Error code indicating a missing or invalid classname. Classnames are + case-sensitive. They must start with a letter, and a-zA-Z0-9_ are the + only valid characters. + + + + + Error code indicating an unspecified object id. + + + + + Error code indicating an invalid key name. Keys are case-sensitive. They + must start with a letter, and a-zA-Z0-9_ are the only valid characters. + + + + + Error code indicating a malformed pointer. You should not see this unless + you have been mucking about changing internal Parse code. + + + + + Error code indicating that badly formed JSON was received upstream. This + either indicates you have done something unusual with modifying how + things encode to JSON, or the network is failing badly. + + + + + Error code indicating that the feature you tried to access is only + available internally for testing purposes. + + + + + You must call Parse.initialize before using the Parse library. + + + + + Error code indicating that a field was set to an inconsistent type. + + + + + Error code indicating an invalid channel name. A channel name is either + an empty string (the broadcast channel) or contains only a-zA-Z0-9_ + characters and starts with a letter. + + + + + Error code indicating that push is misconfigured. + + + + + Error code indicating that the object is too large. + + + + + Error code indicating that the operation isn't allowed for clients. + + + + + Error code indicating the result was not found in the cache. + + + + + Error code indicating that an invalid key was used in a nested + JSONObject. + + + + + Error code indicating that an invalid filename was used for ParseFile. + A valid file name contains only a-zA-Z0-9_. characters and is between 1 + and 128 characters. + + + + + Error code indicating an invalid ACL was provided. + + + + + Error code indicating that the request timed out on the server. Typically + this indicates that the request is too expensive to run. + + + + + Error code indicating that the email address was invalid. + + + + + Error code indicating that a unique field was given a value that is + already taken. + + + + + Error code indicating that a role's name is invalid. + + + + + Error code indicating that an application quota was exceeded. Upgrade to + resolve. + + + + + Error code indicating that a Cloud Code script failed. + + + + + Error code indicating that a Cloud Code validation failed. + + + + + Error code indicating that deleting a file failed. + + + + + Error code indicating that the application has exceeded its request limit. + + + + + Error code indicating that the provided event name is invalid. + + + + + Error code indicating that the username is missing or empty. + + + + + Error code indicating that the password is missing or empty. + + + + + Error code indicating that the username has already been taken. + + + + + Error code indicating that the email has already been taken. + + + + + Error code indicating that the email is missing, but must be specified. + + + + + Error code indicating that a user with the specified email was not found. + + + + + Error code indicating that a user object without a valid session could + not be altered. + + + + + Error code indicating that a user can only be created through signup. + + + + + Error code indicating that an an account being linked is already linked + to another user. + + + + + Error code indicating that the current session token is invalid. + + + + + Error code indicating that a user cannot be linked to an account because + that account's id could not be found. + + + + + Error code indicating that a user with a linked (e.g. Facebook) account + has an invalid session. + + + + + Error code indicating that a service being linked (e.g. Facebook or + Twitter) is unsupported. + + + + + Provides convenience extension methods for working with collections + of ParseObjects so that you can easily save and fetch them in batches. + + + + + Saves all of the ParseObjects in the enumeration. Equivalent to + calling . + + The objects to save. + + + + Saves all of the ParseObjects in the enumeration. Equivalent to + calling + . + + The objects to save. + The cancellation token. + + + + Fetches all of the objects in the enumeration. Equivalent to + calling . + + The objects to save. + + + + Fetches all of the objects in the enumeration. Equivalent to + calling + . + + The objects to fetch. + The cancellation token. + + + + Fetches all of the objects in the enumeration that don't already have + data. Equivalent to calling + . + + The objects to fetch. + + + + Fetches all of the objects in the enumeration that don't already have + data. Equivalent to calling + . + + The objects to fetch. + The cancellation token. + + + + Constructs a query that is the or of the given queries. + + The type of ParseObject being queried. + An initial query to 'or' with additional queries. + The list of ParseQueries to 'or' together. + A query that is the or of the given queries. + + + + Fetches this object with the data from the server. + + + + + Fetches this object with the data from the server. + + The ParseObject to fetch. + The cancellation token. + + + + If this ParseObject has not been fetched (i.e. returns + false), fetches this object with the data from the server. + + The ParseObjhect to fetch. + + + + If this ParseObject has not been fetched (i.e. returns + false), fetches this object with the data from the server. + + The ParseObject to fetch. + The cancellation token. + + + + Represents a distance between two ParseGeoPoints. + + + + + Creates a ParseGeoDistance. + + The distance in radians. + + + + Gets a ParseGeoDistance from a number of miles. + + The number of miles. + A ParseGeoDistance for the given number of miles. + + + + Gets a ParseGeoDistance from a number of kilometers. + + The number of kilometers. + A ParseGeoDistance for the given number of kilometers. + + + + Gets a ParseGeoDistance from a number of radians. + + The number of radians. + A ParseGeoDistance for the given number of radians. + + + + Gets the distance in radians. + + + + + Gets the distance in miles. + + + + + Gets the distance in kilometers. + + + + + ParseGeoPoint represents a latitude / longitude point that may be associated + with a key in a ParseObject or used as a reference point for geo queries. + This allows proximity-based queries on the key. + + Only one key in a class may contain a GeoPoint. + + + + + Constructs a ParseGeoPoint with the specified latitude and longitude. + + The point's latitude. + The point's longitude. + + + + Get the distance in radians between this point and another GeoPoint. This is the smallest angular + distance between the two points. + + GeoPoint describing the other point being measured against. + The distance in between the two points. + + + + Gets or sets the latitude of the GeoPoint. Valid range is [-90, 90]. + Extremes should not be used. + + + + + Gets or sets the longitude. Valid range is [-180, 180]. + Extremes should not be used. + + + + + The ParseObject is a local representation of data that can be saved and + retrieved from the Parse cloud. + + + The basic workflow for creating new data is to construct a new ParseObject, + use the indexer to fill it with data, and then use SaveAsync() to persist to the + database. + + + The basic workflow for accessing existing data is to use a ParseQuery + to specify which existing data to retrieve. + + + + + + Constructor for use in ParseObject subclasses. Subclasses must specify a ParseClassName attribute. + + + + + Constructs a new ParseObject with no data in it. A ParseObject constructed in this way will + not have an ObjectId and will not persist to the database until + is called. + + + Class names must be alphanumerical plus underscore, and start with a letter. It is recommended + to name classes in CamelCaseLikeThis. + + The className for this ParseObject. + + + + Sets the value of a property based upon its associated ParseFieldName attribute. + + The new value. + The name of the property. + The type for the property. + + + + Gets a relation for a property based upon its associated ParseFieldName attribute. + + The ParseRelation for the property. + The name of the property. + The ParseObject subclass type of the ParseRelation. + + + + Gets the value of a property based upon its associated ParseFieldName attribute. + + The value of the property. + The name of the property. + The return type of the property. + + + + Gets the value of a property based upon its associated ParseFieldName attribute. + + The value of the property. + The value to return if the property is not present on the ParseObject. + The name of the property. + The return type of the property. + + + + Allows subclasses to set values for non-pointer construction. + + + + + Gets the appropriate factory for the given class name. If there is no factory for the class, + a factory that produces a regular ParseObject will be created. + + The class name for the ParseObjects the factory will create. + + + + + Creates a new ParseObject based upon a class name. If the class name is a special type (e.g. + for ), then the appropriate type of ParseObject is returned. + + The class of object to create. + A new ParseObject for the given class name. + + + + Creates a reference to an existing ParseObject for use in creating associations between + ParseObjects. Calling on this object will return + false until has been called. + No network request will be made. + + The object's class. + The object id for the referenced object. + A ParseObject without data. + + + + Creates a new ParseObject based upon a given subclass type. + + A new ParseObject for the given class name. + + + + Creates a reference to an existing ParseObject for use in creating associations between + ParseObjects. Calling on this object will return + false until has been called. + No network request will be made. + + The object id for the referenced object. + A ParseObject without data. + + + + Registers a custom subclass type with the Parse SDK, enabling strong-typing of those ParseObjects whenever + they appear. Subclasses must specify the ParseClassName attribute, have a default constructor, and properties + backed by ParseObject fields should have ParseFieldName attributes supplied. + + The ParseObject subclass type to register. + + + + Clears any changes to this object made since the last call to . + + + + + Updates the JSON cache value for the given object. + + + + + Inspects to see if a given mutable container owned by this object has + been mutated, and treats any mutation as a new "set" operation. + + + + + Inspects to see if any mutable container owned by this object has been mutated, and + treats any mutation as a new 'Set' operation. + + + + + Deep traversal of this object to grab a copy of any object referenced by this object. + These instances may have already been fetched, and we don't want to lose their data when + refreshing or saving. + + Map of objectId to ParseObject which have been fetched. + + + + Pushes new operations onto the queue and returns the current set of operations. + + + + + Saves this object to the server. + + + + + Saves this object to the server. + + The cancellation token. + + + + Fetches this object with the data from the server. + + The cancellation token. + + + + If this ParseObject has not been fetched (i.e. returns + false), fetches this object with the data from the server. + + The cancellation token. + + + + Deletes this object on the server. + + + + + Deletes this object on the server. + + The cancellation token. + + + + Helper version of CollectDirtyChildren so that callers don't have to add the internally + used parameters. + + + + + Returns true if the given object can be serialized for saving as a value + that is pointed to by a ParseObject. + + + + + Adds a task to the queue for all of the given objects. + + + + + Fetches all of the objects that don't have data in the provided list. + + The list passed in for convenience. + + + + Fetches all of the objects that don't have data in the provided list. + + The objects to fetch. + The cancellation token. + The list passed in for convenience. + + + + Fetches all of the objects in the provided list. + + The objects to fetch. + The list passed in for convenience. + + + + Fetches all of the objects in the provided list. + + The objects to fetch. + The cancellation token. + The list passed in for convenience. + + + + Fetches all of the objects in the list. + + The objects to fetch. + If false, only objects without data will be fetched. + A task to await before starting. + The cancellation token. + The list passed in for convenience. + + + + Saves each object in the provided list. + + The objects to save. + + + + Saves each object in the provided list. + + The objects to save. + The cancellation token. + + + + Removes a key from the object's data if it exists. + + The key to remove. + + + + Updates the estimated values in the map based on the given set of ParseFieldOperations. + + + + + Regenerates the estimatedData map from the serverData and operations. + + + + + PerformOperation is like setting a value at an index, but instead of + just taking a new value, it takes a ParseFieldOperation that modifies the value. + + + + + Override to run validations on key/value pairs. Make sure to still + call the base version. + + + + + Perform Set internally which is not gated by mutability check. + + key for the object. + the value for the key. + + + + Atomically increments the given key by 1. + + The key to increment. + + + + Atomically increments the given key by the given number. + + The key to increment. + The amount to increment by. + + + + Atomically increments the given key by the given number. + + The key to increment. + The amount to increment by. + + + + Atomically adds an object to the end of the list associated with the given key. + + The key. + The object to add. + + + + Atomically adds objects to the end of the list associated with the given key. + + The key. + The objects to add. + + + + Atomically adds an object to the end of the list associated with the given key, + only if it is not already present in the list. The position of the insert is not + guaranteed. + + The key. + The object to add. + + + + Atomically adds objects to the end of the list associated with the given key, + only if they are not already present in the list. The position of the inserts are not + guaranteed. + + The key. + The objects to add. + + + + Atomically removes all instances of the objects in + from the list associated with the given key. + + The key. + The objects to remove. + + + + Returns whether this object has a particular key. + + The key to check for + + + + Gets a value for the key of a particular type. + The type to convert the value to. Supported types are + ParseObject and its descendents, Parse types such as ParseRelation and ParseGeopoint, + primitive types,IList<T>, IDictionary<string, T>, and strings. + The key of the element to get. + The property is + retrieved and is not found. + + + + + Access or create a Relation value for a key. + + The type of object to create a relation for. + The key for the relation field. + A ParseRelation for the key. + + + + Populates result with the value for the key, if possible. + + The desired type for the value. + The key to retrieve a value for. + The value for the given key, converted to the + requested type, or null if unsuccessful. + true if the lookup and conversion succeeded, otherwise + false. + + + + A helper function for checking whether two ParseObjects point to + the same object in the cloud. + + + + + Indicates whether key is unsaved for this ParseObject. + + The key to check for. + true if the key has been altered and not saved yet, otherwise + false. + + + + Sets the objectId without marking dirty. + + The new objectId + + + + Adds a value for the given key, throwing an Exception if the key + already has a value. + + + This allows you to use collection initialization syntax when creating ParseObjects, + such as: + + var obj = new ParseObject("MyType") + { + {"name", "foo"}, + {"count", 10}, + {"found", false} + }; + + + The key for which a value should be set. + The value for the key. + + + + Gets a for the type of object specified by + + + The class name of the object. + A new . + + + + Raises change notifications for all properties associated with the given + field names. If fieldNames is null, this will notify for all known field-linked + properties (e.g. this happens when we recalculate all estimated data from scratch) + + + + + Raises change notifications for a property. Passing null or the empty string + notifies the binding framework that all properties/indexes have changed. + Passing "Item[]" tells the binding framework that all indexed values + have changed (but not all properties) + + + + + Gets or sets a value on the object. It is recommended to name + keys in partialCamelCaseLikeThis. + + The key for the object. Keys must be alphanumeric plus underscore + and start with a letter. + The property is + retrieved and is not found. + The value for the key. + + + + Gets whether the ParseObject has been fetched. + + + + + Gets a set view of the keys contained in this object. This does not include createdAt, + updatedAt, or objectId. It does include things like username and ACL. + + + + + Gets or sets the ParseACL governing this object. + + + + + Returns true if this object was created by the Parse server when the + object might have already been there (e.g. in the case of a Facebook + login) + + + + + Gets the last time this object was updated as the server sees it, so that if you make changes + to a ParseObject, then wait a while, and then call , the updated time + will be the time of the call rather than the time the object was + changed locally. + + + + + Gets the first time this object was saved as the server sees it, so that if you create a + ParseObject, then wait a while, and then call , the + creation time will be the time of the first call rather than + the time the object was created locally. + + + + + Indicates whether this ParseObject has unsaved changes. + + + + + Gets or sets the object id. An object id is assigned as soon as an object is + saved to the server. The combination of a and an + uniquely identifies an object in your application. + + + + + Gets the class name for the ParseObject. + + + + + Gets the set of fieldName->propertyName mappings for the current class. + + + + + Occurs when a property value changes. + + + + + The ParseQuery class defines a query that is used to fetch ParseObjects. The + most common use case is finding all objects that match a query through the + method. + + + This sample code fetches all objects of + class "MyClass": + + + ParseQuery query = new ParseQuery("MyClass"); + IEnumerable<ParseObject> result = await query.FindAsync(); + + + A ParseQuery can also be used to retrieve a single object whose id is known, + through the method. For example, this sample code + fetches an object of class "MyClass" and id myId. + + + ParseQuery query = new ParseQuery("MyClass"); + ParseObject result = await query.GetAsync(myId); + + + A ParseQuery can also be used to count the number of objects that match the + query without retrieving all of those objects. For example, this sample code + counts the number of objects of the class "MyClass". + + + ParseQuery query = new ParseQuery("MyClass"); + int count = await query.CountAsync(); + + + + + + Private constructor for composition of queries. A source query is required, + but the remaining values can be null if they won't be changed in this + composition. + + + + + Constructs a query based upon the ParseObject subclass used as the generic parameter for the ParseQuery. + + + + + Constructs a query. A default query with no further parameters will retrieve + all s of the provided class. + + The name of the class to retrieve ParseObjects for. + + + + Constructs a query that is the or of the given queries. + + The list of ParseQueries to 'or' together. + A ParseQquery that is the 'or' of the passed in queries. + + + + Sorts the results in ascending order by the given key. + This will override any existing ordering for the query. + + The key to order by. + A new query with the additional constraint. + + + + Sorts the results in descending order by the given key. + This will override any existing ordering for the query. + + The key to order by. + A new query with the additional constraint. + + + + Sorts the results in ascending order by the given key, after previous + ordering has been applied. + + This method can only be called if there is already an + or + on this query. + + The key to order by. + A new query with the additional constraint. + + + + Sorts the results in descending order by the given key, after previous + ordering has been applied. + + This method can only be called if there is already an + or on this query. + + The key to order by. + A new query with the additional constraint. + + + + Include nested ParseObjects for the provided key. You can use dot notation + to specify which fields in the included objects should also be fetched. + + The key that should be included. + A new query with the additional constraint. + + + + Restrict the fields of returned ParseObjects to only include the provided key. + If this is called multiple times, then all of the keys specified in each of + the calls will be included. + + The key that should be included. + A new query with the additional constraint. + + + + Skips a number of results before returning. This is useful for pagination + of large queries. Chaining multiple skips together will cause more results + to be skipped. + + The number of results to skip. + A new query with the additional constraint. + + + + Controls the maximum number of results that are returned. Setting a negative + limit denotes retrieval without a limit. Chaining multiple limits + results in the last limit specified being used. The default limit is + 100, with a maximum of 1000 results being returned at a time. + + The maximum number of results to return. + A new query with the additional constraint. + + + + Adds a constraint to the query that requires a particular key's value to be + contained in the provided list of values. + + The key to check. + The values that will match. + A new query with the additional constraint. + + + + Add a constraint to the querey that requires a particular key's value to be + a list containing all of the elements in the provided list of values. + + The key to check. + The values that will match. + A new query with the additional constraint. + + + + Adds a constraint for finding string values that contain a provided string. + This will be slow for large data sets. + + The key that the string to match is stored in. + The substring that the value must contain. + A new query with the additional constraint. + + + + Adds a constraint for finding objects that do not contain a given key. + + The key that should not exist. + A new query with the additional constraint. + + + + Adds a constraint to the query that requires that a particular key's value + does not match another ParseQuery. This only works on keys whose values are + ParseObjects or lists of ParseObjects. + + The key to check. + The query that the value should not match. + A new query with the additional constraint. + + + + Adds a constraint for finding string values that end with a provided string. + This will be slow for large data sets. + + The key that the string to match is stored in. + The substring that the value must end with. + A new query with the additional constraint. + + + + Adds a constraint to the query that requires a particular key's value to be + equal to the provided value. + + The key to check. + The value that the ParseObject must contain. + A new query with the additional constraint. + + + + Adds a constraint for finding objects that contain a given key. + + The key that should exist. + A new query with the additional constraint. + + + + Adds a constraint to the query that requires a particular key's value to be + greater than the provided value. + + The key to check. + The value that provides a lower bound. + A new query with the additional constraint. + + + + Adds a constraint to the query that requires a particular key's value to be + greater or equal to than the provided value. + + The key to check. + The value that provides a lower bound. + A new query with the additional constraint. + + + + Adds a constraint to the query that requires a particular key's value to be + less than the provided value. + + The key to check. + The value that provides an upper bound. + A new query with the additional constraint. + + + + Adds a constraint to the query that requires a particular key's value to be + less than or equal to the provided value. + + The key to check. + The value that provides a lower bound. + A new query with the additional constraint. + + + + Adds a regular expression constraint for finding string values that match the provided + regular expression. This may be slow for large data sets. + + The key that the string to match is stored in. + The regular expression pattern to match. The Regex must + have the options flag set. + Any of the following supported PCRE modifiers: + i - Case insensitive search + m Search across multiple lines of input + A new query with the additional constraint. + + + + Adds a regular expression constraint for finding string values that match the provided + regular expression. This may be slow for large data sets. + + The key that the string to match is stored in. + The regular expression pattern to match. The Regex must + have the options flag set. + A new query with the additional constraint. + + + + Adds a regular expression constraint for finding string values that match the provided + regular expression. This may be slow for large data sets. + + The key that the string to match is stored in. + The PCRE regular expression pattern to match. + Any of the following supported PCRE modifiers: + i - Case insensitive search + m Search across multiple lines of input + A new query with the additional constraint. + + + + Adds a regular expression constraint for finding string values that match the provided + regular expression. This may be slow for large data sets. + + The key that the string to match is stored in. + The PCRE regular expression pattern to match. + A new query with the additional constraint. + + + + Adds a constraint to the query that requires a particular key's value + to match a value for a key in the results of another ParseQuery. + + The key whose value is being checked. + The key in the objects from the subquery to look in. + The subquery to run + A new query with the additional constraint. + + + + Adds a constraint to the query that requires a particular key's value + does not match any value for a key in the results of another ParseQuery. + + The key whose value is being checked. + The key in the objects from the subquery to look in. + The subquery to run + A new query with the additional constraint. + + + + Adds a constraint to the query that requires that a particular key's value + matches another ParseQuery. This only works on keys whose values are + ParseObjects or lists of ParseObjects. + + The key to check. + The query that the value should match. + A new query with the additional constraint. + + + + Adds a proximity-based constraint for finding objects with keys whose GeoPoint + values are near the given point. + + The key that the ParseGeoPoint is stored in. + The reference ParseGeoPoint. + A new query with the additional constraint. + + + + Adds a constraint to the query that requires a particular key's value to be + contained in the provided list of values. + + The key to check. + The values that will match. + A new query with the additional constraint. + + + + Adds a constraint to the query that requires a particular key's value not + to be equal to the provided value. + + The key to check. + The value that that must not be equalled. + A new query with the additional constraint. + + + + Adds a constraint for finding string values that start with the provided string. + This query will use the backend index, so it will be fast even with large data sets. + + The key that the string to match is stored in. + The substring that the value must start with. + A new query with the additional constraint. + + + + Add a constraint to the query that requires a particular key's coordinates to be + contained within a given rectangular geographic bounding box. + + The key to be constrained. + The lower-left inclusive corner of the box. + The upper-right inclusive corner of the box. + A new query with the additional constraint. + + + + Adds a proximity-based constraint for finding objects with keys whose GeoPoint + values are near the given point and within the maximum distance given. + + The key that the ParseGeoPoint is stored in. + The reference ParseGeoPoint. + The maximum distance (in radians) of results to return. + A new query with the additional constraint. + + + + Retrieves a list of ParseObjects that satisfy this query from Parse. + + The list of ParseObjects that match this query. + + + + Retrieves a list of ParseObjects that satisfy this query from Parse. + + The cancellation token. + The list of ParseObjects that match this query. + + + + Retrieves at most one ParseObject that satisfies this query. + + A single ParseObject that satisfies this query, or else null. + + + + Retrieves at most one ParseObject that satisfies this query. + + The cancellation token. + A single ParseObject that satisfies this query, or else null. + + + + Retrieves at most one ParseObject that satisfies this query. + + A single ParseObject that satisfies this query. + If no results match the query. + + + + Retrieves at most one ParseObject that satisfies this query. + + The cancellation token. + A single ParseObject that satisfies this query. + If no results match the query. + + + + Counts the number of objects that match this query. + + The number of objects that match this query. + + + + Counts the number of objects that match this query. + + The cancellation token. + The number of objects that match this query. + + + + Constructs a ParseObject whose id is already known by fetching data + from the server. + + ObjectId of the ParseObject to fetch. + The ParseObject for the given objectId. + + + + Constructs a ParseObject whose id is already known by fetching data + from the server. + + ObjectId of the ParseObject to fetch. + The cancellation token. + The ParseObject for the given objectId. + + + + For debugging purposes. + + + + + A common base class for ParseRelations. + + + + + Produces the proper ParseRelation<T> instance for the given classname. + + + + + Provides access to all of the children of a many-to-many relationship. Each instance of + ParseRelation is associated with a particular parent and key. + + The type of the child objects. + + + + Adds an object to this relation. The object must already have been saved. + + The object to add. + + + + Removes an object from this relation. The object must already have been saved. + + The object to remove. + + + + Gets a query that can be used to query the objects in this relation. + + + + + Represents a Role on the Parse server. ParseRoles represent groupings + of s for the purposes of granting permissions (e.g. + specifying a for a . Roles + are specified by their sets of child users and child roles, all of which are granted + any permissions that the parent role has. + + Roles must have a name (that cannot be changed after creation of the role), + and must specify an ACL. + + + + + Constructs a new ParseRole. You must assign a name and ACL to the role. + + + + + Constructs a new ParseRole with the given name. + + The name of the role to create. + The ACL for this role. Roles must have an ACL. + + + + Gets the name of the role. + + + + + Gets the for the s that are + direct children of this role. These users are granted any privileges that + this role has been granted (e.g. read or write access through ACLs). You can + add or remove child users from the role through this relation. + + + + + Gets the for the s that are + direct children of this role. These roles' users are granted any privileges that + this role has been granted (e.g. read or write access through ACLs). You can + add or remove child roles from the role through this relation. + + + + + Gets a over the Role collection. + + + + + Represents a session of a user for a Parse application. + + + + + Gets the current object related to the current user. + + + + + Gets the current object related to the current user. + + The cancellation token + + + + Gets the session token for a user, if they are logged in. + + + + + Constructs a for ParseSession. + + + + + Represents upload progress. + + + + + Gets the progress (a number between 0.0 and 1.0) of an upload. + + + + + Represents a user for a Parse application. + + + + + Whether the currentUser is known to match the serialized version on disk. + This is useful for saving a filesystem check if you try to load currentUser + frequently while there is none on disk. + + + + + Constructs a new ParseUser with no data. + + + + + Removes a key from the object's data if it exists. + + The key to remove. + Cannot remove the username key. + + + + Signs up a new user. This will create a new ParseUser on the server and will also persist the + session on disk so that you can access the user using . A username and + password must be set before calling SignUpAsync. + + + + + Signs up a new user. This will create a new ParseUser on the server and will also persist the + session on disk so that you can access the user using . A username and + password must be set before calling SignUpAsync. + + The cancellation token. + + + + Logs in a user with a username and password. On success, this saves the session to disk so you + can retrieve the currently logged in user using . + + The username to log in with. + The password to log in with. + The newly logged-in user. + + + + Logs in a user with a username and password. On success, this saves the session to disk so you + can retrieve the currently logged in user using . + + The username to log in with. + The password to log in with. + The cancellation token. + The newly logged-in user. + + + + Logs in a user with a username and password. On success, this saves the session to disk so you + can retrieve the currently logged in user using . + + The session token to authorize with + The user if authorization was successful + + + + Logs in a user with a username and password. On success, this saves the session to disk so you + can retrieve the currently logged in user using . + + The session token to authorize with + The cancellation token. + The user if authorization was successful + + + + Logs out the currently logged in user session. This will remove the session from disk, log out of + linked services, and future calls to will return null. + + + + + Logs out the currently logged in user session. This will remove the session from disk, log out of + linked services, and future calls to will return null. + + This is preferable to using , unless your code is already running from a + background thread. + + + + + Logs out the currently logged in user session. This will remove the session from disk, log out of + linked services, and future calls to will return null. + + This is preferable to using , unless your code is already running from a + background thread. + + + + + Gets the currently logged in ParseUser with a valid session, either from memory or disk + if necessary, asynchronously. + + + + + Gets the currently logged in ParseUser with a valid session, either from memory or disk + if necessary, asynchronously. + + + + + Tells server to use revocable session on LogIn and SignUp, even when App's Settings + has "Require Revocable Session" turned off. Issues network request in background to + migrate the sessionToken on disk to revocable session. + + The Task that upgrades the session. + + + + Tells server to use revocable session on LogIn and SignUp, even when App's Settings + has "Require Revocable Session" turned off. Issues network request in background to + migrate the sessionToken on disk to revocable session. + + The Task that upgrades the session. + + + + Requests a password reset email to be sent to the specified email address associated with the + user account. This email allows the user to securely reset their password on the Parse site. + + The email address associated with the user that forgot their password. + + + + Requests a password reset email to be sent to the specified email address associated with the + user account. This email allows the user to securely reset their password on the Parse site. + + The email address associated with the user that forgot their password. + The cancellation token. + + + + Removes null values from authData (which exist temporarily for unlinking) + + + + + Synchronizes authData for all providers. + + + + + Unlinks a user from a service. + + + + + Checks whether a user is linked to a service. + + + + + Whether the ParseUser has been authenticated on this device. Only an authenticated + ParseUser can be saved and deleted. + + + + + Gets or sets the username. + + + + + Sets the password. + + + + + Sets the email address. + + + + + Gets the currently logged in ParseUser with a valid session, either from memory or disk + if necessary. + + + + + Constructs a for ParseUsers. + + + + + Gets the authData for this user. + + + + -- cgit v1.2.3-70-g09d2