public static Dictionary <string, object> Encode(ParseObjectData objectData)
{
if (objectData == null)
{
return(null);
}
Dictionary <string, object> dict = new Dictionary <string, object> {
{ "className", objectData.ClassName }
};
if (!string.IsNullOrEmpty(objectData.ObjectId))
{
dict["objectId"] = objectData.ObjectId;
}
if (objectData.CreatedAt != null)
{
dict["createdAt"] = objectData.CreatedAt.ToUniversalTime();
}
if (objectData.UpdatedAt != null)
{
dict["updatedAt"] = objectData.UpdatedAt.ToUniversalTime();
}
if (objectData.CustomPropertyDict != null)
{
foreach (KeyValuePair <string, object> kv in objectData.CustomPropertyDict)
{
string key = kv.Key;
object value = kv.Value;
dict[key] = ParseEncoder.Encode(value);
}
}
return(dict);
}
object IParseOperation.Encode()
{
return(new Dictionary <string, object> {
{ "__op", "Add" },
{ "objects", ParseEncoder.Encode(valueList) }
});
}
public object Encode()
{
return(new Dictionary <string, object> {
{ "__op", "Remove" },
{ "objects", ParseEncoder.Encode(valueList) }
});
}
public object Encode()
{
return(new Dictionary <string, object> {
{ "__op", "AddUnique" },
{ "objects", ParseEncoder.Encode(values.ToList()) }
});
}
public Dictionary <string, object> Encode()
{
return(new Dictionary <string, object> {
{ key, new Dictionary <string, object> {
{ op, ParseEncoder.Encode(value) }
} }
});
}
public Dictionary <string, object> Encode()
{
return(new Dictionary <string, object> {
{ "$relatedTo", new Dictionary <string, object> {
{ "object", ParseEncoder.Encode(parent) },
{ "key", key }
} }
});
}
public static async Task <object> RPC(string name, object parameters = null)
{
string path = $"call/{name}";
object encodeParams = ParseEncoder.Encode(parameters);
Dictionary <string, object> response = await ParseClient.HttpClient.Post <Dictionary <string, object> >(path,
data : encodeParams);
return(ParseDecoder.Decode(response["result"]));
}
public static async Task <Dictionary <string, object> > Run(string name,
Dictionary <string, object> parameters = null)
{
string path = $"functions/{name}";
object encodeParams = ParseEncoder.Encode(parameters);
Dictionary <string, object> response = await ParseClient.HttpClient.Post <Dictionary <string, object> >(path,
data : encodeParams);
return(response);
}
/// <summary>
/// Converts a normalized binary expression into the appropriate ParseQuery clause.
/// </summary>
private static ParseQuery <T> WhereBinaryExpression <T>(
this ParseQuery <T> source, Expression <Func <T, bool> > expression, BinaryExpression node)
where T : ParseObject
{
var leftTransformed = new ObjectNormalizer().Visit(node.Left) as MethodCallExpression;
if (leftTransformed != null && !(IsParseObjectGet(leftTransformed) &&
leftTransformed.Object == expression.Parameters[0]))
{
throw new InvalidOperationException(
"Where expressions must have one side be a field operation on a ParseObject.");
}
if (leftTransformed != null)
{
var fieldPath = GetValue(leftTransformed.Arguments[0]) as string;
var filterValue = GetValue(node.Right);
if (filterValue != null && !ParseEncoder.IsValidType(filterValue))
{
throw new InvalidOperationException(
"Where clauses must use types compatible with ParseObjects.");
}
switch (node.NodeType)
{
case ExpressionType.GreaterThan:
return(source.WhereGreaterThan(fieldPath, filterValue));
case ExpressionType.GreaterThanOrEqual:
return(source.WhereGreaterThanOrEqualTo(fieldPath, filterValue));
case ExpressionType.LessThan:
return(source.WhereLessThan(fieldPath, filterValue));
case ExpressionType.LessThanOrEqual:
return(source.WhereLessThanOrEqualTo(fieldPath, filterValue));
case ExpressionType.Equal:
return(source.WhereEqualTo(fieldPath, filterValue));
case ExpressionType.NotEqual:
return(source.WhereNotEqualTo(fieldPath, filterValue));
default:
throw new InvalidOperationException(
"Where expressions do not support this operator.");
}
}
return(null);
}
public Dictionary <string, object> Encode()
{
if (conditionList == null || conditionList.Count == 0)
{
return(null);
}
if (conditionList.Count == 1)
{
IParseQueryCondition cond = conditionList[0];
return(cond.Encode());
}
return(new Dictionary <string, object> {
{ composition, ParseEncoder.Encode(conditionList) }
});
}
static async Task SaveBatches(Stack <ParseBatch> batches)
{
while (batches.Count > 0)
{
ParseBatch batch = batches.Pop();
List <ParseObject> dirtyObjects = batch.objects.Where(item => item.IsDirty)
.ToList();
List <Dictionary <string, object> > requestList = dirtyObjects.Select(item => {
string path = item.ObjectId == null ?
$"/parse/classes/{item.ClassName}" :
$"/parse/classes/{item.ClassName}/{item.ClassName}";
string method = item.ObjectId == null ? "POST" : "PUT";
Dictionary <string, object> body = ParseEncoder.Encode(item.operationDict) as Dictionary <string, object>;
return(new Dictionary <string, object> {
{ "path", path },
{ "method", method },
{ "body", body }
});
}).ToList();
Dictionary <string, object> data = new Dictionary <string, object> {
{ "requests", ParseEncoder.Encode(requestList) }
};
List <Dictionary <string, object> > results = await ParseClient.HttpClient.Post <List <Dictionary <string, object> > >("batch", data : data);
List <ParseObjectData> resultList = results.Select(item => {
if (item.TryGetValue("error", out object error))
{
Dictionary <string, object> err = error as Dictionary <string, object>;
int code = (int)err["code"];
string message = (string)err["error"];
throw new ParseException(code, message as string);
}
return(ParseObjectData.Decode(item["success"] as IDictionary));
}).ToList();
for (int i = 0; i < dirtyObjects.Count; i++)
{
ParseObject obj = dirtyObjects[i];
ParseObjectData objData = resultList[i];
obj.Merge(objData);
}
}
}
public static async Task <IEnumerable <ParseObject> > FetchAll(IEnumerable <ParseObject> objects)
{
if (objects == null || objects.Count() == 0)
{
throw new ArgumentNullException(nameof(objects));
}
IEnumerable <ParseObject> uniqueObjects = objects.Where(item => item.ObjectId != null);
List <Dictionary <string, object> > requestList = uniqueObjects.Select(item => {
string path = $"/parse/classes/{item.ClassName}/{item.ObjectId}";
return(new Dictionary <string, object> {
{ "path", path },
{ "method", "GET" }
});
}).ToList();
Dictionary <string, object> data = new Dictionary <string, object> {
{ "requests", ParseEncoder.Encode(requestList) }
};
List <Dictionary <string, object> > results = await ParseClient.HttpClient.Post <List <Dictionary <string, object> > >("batch",
data : data);
Dictionary <string, ParseObjectData> dict = new Dictionary <string, ParseObjectData>();
foreach (Dictionary <string, object> item in results)
{
if (item.TryGetValue("error", out object error))
{
int code = (int)error;
string message = item["error"] as string;
throw new ParseException(code, message);
}
Dictionary <string, object> d = item["success"] as Dictionary <string, object>;
string objectId = d["objectId"] as string;
dict[objectId] = ParseObjectData.Decode(d);
}
foreach (ParseObject obj in objects)
{
ParseObjectData objData = dict[obj.ObjectId];
obj.Merge(objData);
}
return(objects);
}
public static async Task DeleteAll(List <ParseObject> objectList)
{
if (objectList == null || objectList.Count == 0)
{
throw new ArgumentNullException(nameof(objectList));
}
IEnumerable <ParseObject> objects = objectList.Where(item => item.ObjectId != null);
HashSet <ParseObject> objectSet = new HashSet <ParseObject>(objects);
List <Dictionary <string, object> > requestList = objectSet.Select(item => {
string path = $"/parse/classes/{item.ClassName}/{item.ObjectId}";
return(new Dictionary <string, object> {
{ "path", path },
{ "method", "DELETE" }
});
}).ToList();
Dictionary <string, object> data = new Dictionary <string, object> {
{ "requests", ParseEncoder.Encode(requestList) }
};
await ParseClient.HttpClient.Post <List <object> >("batch", data : data);
}
public void TestIsValidType()
{
Assert.IsTrue(ParseEncoder.IsValidType(322));
Assert.IsTrue(ParseEncoder.IsValidType(0.3f));
Assert.IsTrue(ParseEncoder.IsValidType(new byte[] { 1, 2, 3, 4 }));
Assert.IsTrue(ParseEncoder.IsValidType("corgi"));
Assert.IsTrue(ParseEncoder.IsValidType(new ParseObject("Corgi")));
Assert.IsTrue(ParseEncoder.IsValidType(new ParseACL()));
Assert.IsTrue(ParseEncoder.IsValidType(new ParseFile("Corgi", new byte[0])));
Assert.IsTrue(ParseEncoder.IsValidType(new ParseGeoPoint(1, 2)));
Assert.IsTrue(ParseEncoder.IsValidType(new ParseRelation <ParseObject>(new ParseObject("Corgi"), "corgi")));
Assert.IsTrue(ParseEncoder.IsValidType(new DateTime()));
Assert.IsTrue(ParseEncoder.IsValidType(new List <object>()));
Assert.IsTrue(ParseEncoder.IsValidType(new Dictionary <string, string>()));
Assert.IsTrue(ParseEncoder.IsValidType(new Dictionary <string, object>()));
Assert.IsFalse(ParseEncoder.IsValidType(new ParseAddOperation(new List <object>())));
Assert.IsFalse(ParseEncoder.IsValidType(Task <ParseObject> .FromResult(new ParseObject("Corgi"))));
Assert.Throws <MissingMethodException>(() => ParseEncoder.IsValidType(new Dictionary <object, object>()));
Assert.Throws <MissingMethodException>(() => ParseEncoder.IsValidType(new Dictionary <object, string>()));
}
public async Task <ParseObject> Save(bool fetchWhenSave = false, ParseQuery <ParseObject> query = null)
{
if (ParseBatch.HasCircleReference(this, new HashSet <ParseObject>()))
{
throw new ArgumentException("Found a circle dependency when save.");
}
Stack <ParseBatch> batches = ParseBatch.BatchObjects(new List <ParseObject> {
this
}, false);
if (batches.Count > 0)
{
await SaveBatches(batches);
}
string path = ObjectId == null ? $"classes/{ClassName}" : $"classes/{ClassName}/{ObjectId}";
Dictionary <string, object> queryParams = new Dictionary <string, object>();
if (fetchWhenSave)
{
queryParams["fetchWhenSave"] = true;
}
if (query != null)
{
queryParams["where"] = query.BuildWhere();
}
Dictionary <string, object> response = ObjectId == null ?
await ParseClient.HttpClient.Post <Dictionary <string, object> >(path, data : ParseEncoder.Encode(operationDict) as Dictionary <string, object>, queryParams : queryParams) :
await ParseClient.HttpClient.Put <Dictionary <string, object> >(path, data : ParseEncoder.Encode(operationDict) as Dictionary <string, object>, queryParams : queryParams);
ParseObjectData data = ParseObjectData.Decode(response);
Merge(data);
return(this);
}
public object Encode()
{
return(ParseEncoder.Encode(value));
}
