PHXH
/
csharp-sdk-upm
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Merge pull request #60 from onerain88/chore 

Chore
oneRain 2020-05-06 17:43:56 +08:00 committed by GitHub
parent 0e6f4abb98 6bd34720e9
commit cc73b21673
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
21 changed files with 630 additions and 71 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
.vscode/settings.json vendored Normal file
View File

@ -0,0 +1,3 @@
{
"python.pythonPath": "/Users/onerainyu/opt/anaconda3/bin/python"
}

2
Realtime/Realtime/Conversation/LCIMConversationQuery.cs
View File

@ -184,7 +184,7 @@ namespace LeanCloud.Realtime {
/// <param name="key"></param>
/// <returns></returns>
public LCIMConversationQuery OrderBy(string key) {
Condition.OrderBy(key);
Condition.OrderByAscending(key);
return this;
}

6
Storage/Storage-Unity/Storage-Unity.csproj
View File

@ -117,6 +117,12 @@
<Compile Include="..\Storage\Internal\Query\LCCompositionalCondition.cs">
<Link>Internal\Query\LCCompositionalCondition.cs</Link>
</Compile>
<Compile Include="..\Storage\LCCaptchaClient.cs">
<Link>LCCaptchaClient.cs</Link>
</Compile>
<Compile Include="..\Storage\LCSMSClient.cs">
<Link>LCSMSClient.cs</Link>
</Compile>
</ItemGroup>
<ItemGroup>
<Reference Include="Newtonsoft.Json">

36
Storage/Storage.Test/CaptchaTest.cs Normal file
View File

@ -0,0 +1,36 @@
using NUnit.Framework;
using System.Threading.Tasks;
using LeanCloud;
using LeanCloud.Storage;
using static NUnit.Framework.TestContext;
namespace Storage.Test {
public class CaptchaTest {
[SetUp]
public void SetUp() {
LCLogger.LogDelegate += Utils.Print;
LCApplication.Initialize(Utils.AppId, Utils.AppKey, Utils.AppServer);
}
[TearDown]
public void TearDown() {
LCLogger.LogDelegate -= Utils.Print;
}
//[Test]
public async Task Request() {
LCCapture captcha = await LCCaptchaClient.RequestCaptcha();
WriteLine($"url: {captcha.Url}");
WriteLine($"token: {captcha.Token}");
Assert.NotNull(captcha);
Assert.NotNull(captcha.Url);
Assert.NotNull(captcha.Token);
}
//[Test]
public async Task Verify() {
await LCCaptchaClient.VerifyCaptcha("on2r", "1TUDkEMu");
}
}
}

70
Storage/Storage.Test/ObjectTest.cs
View File

@ -5,6 +5,8 @@ using System.Collections.Generic;
using LeanCloud;
using LeanCloud.Storage;
using static NUnit.Framework.TestContext;
namespace Storage.Test {
public class ObjectTest {
[SetUp]
@ -144,5 +146,73 @@ namespace Storage.Test {
TestContext.WriteLine(hello["content"]);
Assert.IsNull(hello["content"]);
}
[Test]
public async Task OperateNullProperty() {
LCObject obj = new LCObject("Hello");
obj.Increment("intValue", 123);
obj.Increment("intValue", 321);
obj.Add("intList", 1);
obj.Add("intList", 2);
obj.Add("intList", 3);
await obj.Save();
WriteLine(obj["intValue"]);
Assert.AreEqual(obj["intValue"], 444);
List<object> intList = obj["intList"] as List<object>;
WriteLine(intList.Count);
Assert.AreEqual(intList.Count, 3);
Assert.AreEqual(intList[0], 1);
Assert.AreEqual(intList[1], 2);
Assert.AreEqual(intList[2], 3);
}
[Test]
public async Task FetchAll() {
List<LCObject> list = new List<LCObject> {
LCObject.CreateWithoutData("Hello", "5e8fe86938ed12000870ae82"),
LCObject.CreateWithoutData("Hello", "5e8fe867158a7a0006be0feb"),
LCObject.CreateWithoutData("Hello", "5e8fe84e5c385800081a1d64"),
};
await LCObject.FetchAll(list);
Assert.Greater(list.Count, 0);
foreach (LCObject obj in list) {
Assert.NotNull(obj["intList"]);
}
}
[Test]
public async Task Serialization() {
LCObject obj = new LCObject("Hello");
obj["intValue"] = 123;
obj["boolValue"] = true;
obj["stringValue"] = "hello, world";
obj["time"] = DateTime.Now;
obj["intList"] = new List<int> { 1, 1, 2, 3, 5, 8 };
obj["stringMap"] = new Dictionary<string, object> {
{ "k1", 111 },
{ "k2", true },
{ "k3", "haha" }
};
LCObject nestedObj = new LCObject("World");
nestedObj["content"] = "7788";
obj["objectValue"] = nestedObj;
obj["pointerList"] = new List<object> {
new LCObject("World"),
nestedObj
};
await obj.Save();
string json = obj.ToString();
WriteLine(json);
LCObject newObj = LCObject.ParseObject(json);
Assert.NotNull(newObj.ObjectId);
Assert.NotNull(newObj.ClassName);
Assert.NotNull(newObj.CreatedAt);
Assert.NotNull(newObj.UpdatedAt);
Assert.AreEqual(newObj["intValue"], 123);
Assert.AreEqual(newObj["boolValue"], true);
Assert.AreEqual(newObj["stringValue"], "hello, world");
}
}
}

141
Storage/Storage.Test/QueryTest.cs
View File

@ -1,4 +1,5 @@
using NUnit.Framework;
using System.Collections.ObjectModel;
using System.Collections.Generic;
using System.Threading.Tasks;
using LeanCloud;
@ -21,7 +22,7 @@ namespace Storage.Test {
public async Task BaseQuery() {
LCQuery<LCObject> query = new LCQuery<LCObject>("Hello");
query.Limit(2);
List<LCObject> list = await query.Find();
ReadOnlyCollection<LCObject> list = await query.Find();
TestContext.WriteLine(list.Count);
Assert.AreEqual(list.Count, 2);
@ -53,8 +54,8 @@ namespace Storage.Test {
[Test]
public async Task OrderBy() {
LCQuery<LCObject> query = new LCQuery<LCObject>("Account");
query.OrderBy("balance");
List<LCObject> results = await query.Find();
query.OrderByAscending("balance");
ReadOnlyCollection<LCObject> results = await query.Find();
Assert.LessOrEqual((int)results[0]["balance"], (int)results[1]["balance"]);
query = new LCQuery<LCObject>("Account");
@ -63,6 +64,22 @@ namespace Storage.Test {
Assert.GreaterOrEqual((int)results[0]["balance"], (int)results[1]["balance"]);
}
[Test]
public async Task AddOrder() {
LCQuery<LCObject> query = new LCQuery<LCObject>("Account");
query.AddAscendingOrder("balance");
query.AddDescendingOrder("createdAt");
ReadOnlyCollection<LCObject> results = await query.Find();
for (int i = 0; i + 1 < results.Count; i++) {
LCObject a1 = results[i];
LCObject a2 = results[i + 1];
int b1 = (int)a1["balance"];
int b2 = (int)a2["balance"];
Assert.IsTrue(b1 < b2 ||
a1.CreatedAt.CompareTo(a2.CreatedAt) >= 0);
}
}
[Test]
public async Task Include() {
LCQuery<LCObject> query = new LCQuery<LCObject>("Hello");
@ -91,7 +108,7 @@ namespace Storage.Test {
public async Task GreaterQuery() {
LCQuery<LCObject> query = new LCQuery<LCObject>("Account");
query.WhereGreaterThan("balance", 200);
List<LCObject> list = await query.Find();
ReadOnlyCollection<LCObject> list = await query.Find();
TestContext.WriteLine(list.Count);
Assert.Greater(list.Count, 0);
}
@ -103,12 +120,12 @@ namespace Storage.Test {
LCQuery<LCObject> q2 = new LCQuery<LCObject>("Account");
q2.WhereLessThan("balance", 500);
LCQuery<LCObject> query = LCQuery<LCObject>.And(new List<LCQuery<LCObject>> { q1, q2 });
List<LCObject> results = await query.Find();
ReadOnlyCollection<LCObject> results = await query.Find();
TestContext.WriteLine(results.Count);
results.ForEach(item => {
foreach (LCObject item in results) {
int balance = (int)item["balance"];
Assert.IsTrue(balance >= 100 || balance <= 500);
});
}
}
[Test]
@ -118,12 +135,12 @@ namespace Storage.Test {
LCQuery<LCObject> q2 = new LCQuery<LCObject>("Account");
q2.WhereGreaterThanOrEqualTo("balance", 500);
LCQuery<LCObject> query = LCQuery<LCObject>.Or(new List<LCQuery<LCObject>> { q1, q2 });
List<LCObject> results = await query.Find();
ReadOnlyCollection<LCObject> results = await query.Find();
TestContext.WriteLine(results.Count);
results.ForEach(item => {
foreach (LCObject item in results) {
int balance = (int)item["balance"];
Assert.IsTrue(balance <= 100 || balance >= 500);
});
}
}
[Test]
@ -141,28 +158,28 @@ namespace Storage.Test {
public async Task Exist() {
LCQuery<LCObject> query = new LCQuery<LCObject>("Account");
query.WhereExists("user");
List<LCObject> results = await query.Find();
results.ForEach(item => {
ReadOnlyCollection<LCObject> results = await query.Find();
foreach (LCObject item in results) {
Assert.NotNull(item["user"]);
});
}
query = new LCQuery<LCObject>("Account");
query.WhereDoesNotExist("user");
results = await query.Find();
results.ForEach(item => {
foreach (LCObject item in results) {
Assert.IsNull(item["user"]);
});
}
}
[Test]
public async Task Select() {
LCQuery<LCObject> query = new LCQuery<LCObject>("Account");
query.Select("balance");
List<LCObject> results = await query.Find();
results.ForEach(item => {
ReadOnlyCollection<LCObject> results = await query.Find();
foreach (LCObject item in results) {
Assert.NotNull(item["balance"]);
Assert.IsNull(item["user"]);
});
}
}
[Test]
@ -170,29 +187,29 @@ namespace Storage.Test {
// Start
LCQuery<LCObject> query = new LCQuery<LCObject>("Hello");
query.WhereStartsWith("stringValue", "hello");
List<LCObject> results = await query.Find();
results.ForEach(item => {
ReadOnlyCollection<LCObject> results = await query.Find();
foreach (LCObject item in results) {
string str = item["stringValue"] as string;
Assert.IsTrue(str.StartsWith("hello"));
});
}
// End
query = new LCQuery<LCObject>("Hello");
query.WhereEndsWith("stringValue", "world");
results = await query.Find();
results.ForEach(item => {
foreach (LCObject item in results) {
string str = item["stringValue"] as string;
Assert.IsTrue(str.EndsWith("world"));
});
}
// Contains
query = new LCQuery<LCObject>("Hello");
query.WhereContains("stringValue", ",");
results = await query.Find();
results.ForEach(item => {
foreach (LCObject item in results) {
string str = item["stringValue"] as string;
Assert.IsTrue(str.Contains(','));
});
}
}
[Test]
@ -200,46 +217,60 @@ namespace Storage.Test {
// equal
LCQuery<LCObject> query = new LCQuery<LCObject>("Book");
query.WhereEqualTo("pages", 3);
List<LCObject>results = await query.Find();
results.ForEach(item => {
ReadOnlyCollection<LCObject>results = await query.Find();
foreach (LCObject item in results) {
List<object> pages = item["pages"] as List<object>;
Assert.IsTrue(pages.Contains(3));
});
}
// contain all
List<int> containAlls = new List<int> { 1, 2, 3, 4, 5, 6, 7 };
query = new LCQuery<LCObject>("Book");
query.WhereContainsAll("pages", containAlls);
results = await query.Find();
results.ForEach(item => {
foreach (LCObject item in results) {
List<object> pages = item["pages"] as List<object>;
pages.ForEach(i => {
Assert.IsTrue(pages.Contains(i));
});
});
}
// contain in
List<int> containIns = new List<int> { 4, 5, 6 };
query = new LCQuery<LCObject>("Book");
query.WhereContainedIn("pages", containIns);
results = await query.Find();
results.ForEach(item => {
foreach (LCObject item in results) {
List<object> pages = item["pages"] as List<object>;
bool f = false;
containIns.ForEach(i => {
f |= pages.Contains(i);
});
Assert.IsTrue(f);
}
// not contain in
List<int> notContainIns = new List<int> { 1, 2, 3 };
query = new LCQuery<LCObject>("Book");
query.WhereNotContainedIn("pages", notContainIns);
results = await query.Find();
foreach (LCObject item in results) {
List<object> pages = item["pages"] as List<object>;
bool f = true;
notContainIns.ForEach(i => {
f &= !pages.Contains(i);
});
Assert.IsTrue(f);
}
// size
query = new LCQuery<LCObject>("Book");
query.WhereSizeEqualTo("pages", 7);
results = await query.Find();
results.ForEach(item => {
foreach (LCObject item in results) {
List<object> pages = item["pages"] as List<object>;
Assert.AreEqual(pages.Count, 7);
});
}
}
[Test]
@ -253,7 +284,7 @@ namespace Storage.Test {
LCQuery<LCObject> query = new LCQuery<LCObject>("Todo");
LCGeoPoint point = new LCGeoPoint(39.91, 116.41);
query.WhereNear("location", point);
List<LCObject> results = await query.Find();
ReadOnlyCollection<LCObject> results = await query.Find();
Assert.Greater(results.Count, 0);
// in box
@ -264,5 +295,47 @@ namespace Storage.Test {
results = await query.Find();
Assert.Greater(results.Count, 0);
}
[Test]
public async Task Regex() {
LCQuery<LCObject> query = new LCQuery<LCObject>("Hello");
query.WhereMatches("stringValue", "^HEllo.*", modifiers: "i");
ReadOnlyCollection<LCObject> results = await query.Find();
Assert.Greater(results.Count, 0);
foreach (LCObject item in results) {
string str = item["stringValue"] as string;
Assert.IsTrue(str.StartsWith("hello"));
}
}
[Test]
public async Task InQuery() {
LCQuery<LCObject> worldQuery = new LCQuery<LCObject>("World");
worldQuery.WhereEqualTo("content", "7788");
LCQuery<LCObject> helloQuery = new LCQuery<LCObject>("Hello");
helloQuery.WhereMatchesQuery("objectValue", worldQuery);
helloQuery.Include("objectValue");
ReadOnlyCollection<LCObject> hellos = await helloQuery.Find();
Assert.Greater(hellos.Count, 0);
foreach (LCObject item in hellos) {
LCObject world = item["objectValue"] as LCObject;
Assert.AreEqual(world["content"], "7788");
}
}
[Test]
public async Task NotInQuery() {
LCQuery<LCObject> worldQuery = new LCQuery<LCObject>("World");
worldQuery.WhereEqualTo("content", "7788");
LCQuery<LCObject> helloQuery = new LCQuery<LCObject>("Hello");
helloQuery.WhereDoesNotMatchQuery("objectValue", worldQuery);
helloQuery.Include("objectValue");
ReadOnlyCollection<LCObject> hellos = await helloQuery.Find();
Assert.Greater(hellos.Count, 0);
foreach (LCObject item in hellos) {
LCObject world = item["objectValue"] as LCObject;
Assert.IsTrue(world == null || world["content"] != "7788");
}
}
}
}

8
Storage/Storage.Test/RelationTest.cs
View File

@ -1,6 +1,6 @@
using NUnit.Framework;
using System.Threading.Tasks;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using LeanCloud;
using LeanCloud.Storage;
@ -56,11 +56,11 @@ namespace Storage.Test {
Assert.NotNull(relation.TargetClass);
LCQuery<LCObject> relationQuery = relation.Query;
List<LCObject> list = await relationQuery.Find();
list.ForEach(item => {
ReadOnlyCollection<LCObject> results = await relationQuery.Find();
foreach (LCObject item in results) {
TestContext.WriteLine(item.ObjectId);
Assert.NotNull(item.ObjectId);
});
}
}
}
}

8
Storage/Storage.Test/RoleTest.cs
View File

@ -1,6 +1,6 @@
using NUnit.Framework;
using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Threading.Tasks;
using LeanCloud;
using LeanCloud.Storage;
@ -34,8 +34,8 @@ namespace Storage.Test {
[Test]
public async Task Query() {
LCQuery<LCRole> query = LCRole.GetQuery();
List<LCRole> list = await query.Find();
list.ForEach(item => {
ReadOnlyCollection<LCRole> results = await query.Find();
foreach (LCRole item in results) {
TestContext.WriteLine($"{item.ObjectId} : {item.Name}");
Assert.NotNull(item.ObjectId);
Assert.NotNull(item.Name);
@ -43,7 +43,7 @@ namespace Storage.Test {
TestContext.WriteLine(item.Users.GetType());
Assert.IsTrue(item.Roles is LCRelation<LCRole>);
Assert.IsTrue(item.Users is LCRelation<LCUser>);
});
}
}
}
}

40
Storage/Storage.Test/SMSTest.cs Normal file
View File

@ -0,0 +1,40 @@
using NUnit.Framework;
using System.Collections.Generic;
using System.Threading.Tasks;
using LeanCloud;
using LeanCloud.Storage;
namespace Storage.Test {
public class SMSTest {
[SetUp]
public void SetUp() {
LCLogger.LogDelegate += Utils.Print;
LCApplication.Initialize(Utils.AppId, Utils.AppKey, Utils.AppServer);
}
[TearDown]
public void TearDown() {
LCLogger.LogDelegate -= Utils.Print;
}
//[Test]
public async Task RequestSMS() {
await LCSMSClient.RequestSMSCode("15101006007",
template: "test_template",
signature: "flutter-test",
variables: new Dictionary<string, object> {
{ "k1", "v1" }
});
}
//[Test]
public async Task RequestVoice() {
await LCSMSClient.RequestVoiceCode("+8615101006007");
}
//[Test]
public async Task Verify() {
await LCSMSClient.VerifyMobilePhone("15101006007", "");
}
}
}

4
Storage/Storage.Test/SubClassTest.cs
View File

@ -1,6 +1,6 @@
using NUnit.Framework;
using System.Threading.Tasks;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using LeanCloud;
using LeanCloud.Storage;
@ -63,7 +63,7 @@ namespace Storage.Test {
LCObject.RegisterSubclass<Account>("Account", () => new Account());
LCQuery<Account> query = new LCQuery<Account>("Account");
query.WhereGreaterThan("balance", 500);
List<Account> list = await query.Find();
ReadOnlyCollection<Account> list = await query.Find();
TestContext.WriteLine(list.Count);
Assert.Greater(list.Count, 0);
foreach (Account account in list) {

1
Storage/Storage.Test/UserTest.cs
View File

@ -79,6 +79,7 @@ namespace Storage.Test {
public async Task LoginAnonymous() {
LCUser user = await LCUser.LoginAnonymously();
Assert.NotNull(user.ObjectId);
Assert.IsTrue(user.IsAnonymous);
}
[Test]

4
Storage/Storage.Test/Utils.cs
View File

@ -3,6 +3,10 @@ using LeanCloud;
namespace Storage.Test {
public static class Utils {
internal const string AppId = "ikGGdRE2YcVOemAaRbgp1xGJ-gzGzoHsz";
internal const string AppKey = "NUKmuRbdAhg1vrb2wexYo1jo";
internal const string AppServer = "https://ikggdre2.lc-cn-n1-shared.com";
internal static void Print(LCLogLevel level, string info) {
switch (level) {
case LCLogLevel.Debug:

14
Storage/Storage/Internal/Object/LCObjectData.cs
View File

@ -55,11 +55,17 @@ namespace LeanCloud.Storage.Internal.Object {
return null;
}
Dictionary<string, object> dict = new Dictionary<string, object> {
{ "className", objectData.ClassName },
{ "objectId", objectData.ObjectId },
{ "createdAt", objectData.CreatedAt },
{ "updatedAt", objectData.UpdatedAt },
{ "className", objectData.ClassName }
};
if (!string.IsNullOrEmpty(objectData.ObjectId)) {
dict["objectId"] = objectData.ObjectId;
}
if (objectData.CreatedAt != null) {
dict["createdAt"] = objectData.CreatedAt;
}
if (objectData.UpdatedAt != null) {
dict["updatedAt"] = objectData.UpdatedAt;
}
if (objectData.CustomPropertyDict != null) {
foreach (KeyValuePair<string, object> kv in objectData.CustomPropertyDict) {
string key = kv.Key;

9
Storage/Storage/Internal/Operation/LCAddOperation.cs
View File

@ -1,6 +1,7 @@
using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;
using LeanCloud.Storage.Internal.Codec;
namespace LeanCloud.Storage.Internal.Operation {
@ -16,11 +17,15 @@ namespace LeanCloud.Storage.Internal.Operation {
return previousOp;
}
if (previousOp is LCAddOperation addOp) {
valueList.AddRange(addOp.valueList);
List<object> list = new List<object>(addOp.valueList);
list.AddRange(valueList);
valueList = list;
return this;
}
if (previousOp is LCAddUniqueOperation addUniqueOp) {
valueList.AddRange(addUniqueOp.values);
List<object> list = addUniqueOp.values.ToList();
list.AddRange(valueList);
valueList = list;
return this;
}
throw new ArgumentException("Operation is invalid after previous operation.");

10
Storage/Storage/Internal/Operation/LCRemoveOperation.cs
View File

@ -17,7 +17,10 @@ namespace LeanCloud.Storage.Internal.Operation {
return previousOp;
}
if (previousOp is LCRemoveOperation removeOp) {
valueList.AddRange(removeOp.valueList);
List<object> list = new List<object>(removeOp.valueList);
list.AddRange(valueList);
valueList = list;
return this;
}
throw new ArgumentException("Operation is invalid after previous operation.");
}
@ -30,7 +33,10 @@ namespace LeanCloud.Storage.Internal.Operation {
}
public object Apply(object oldValue, string key) {
List<object> list = new List<object>(oldValue as IEnumerable<object>);
List<object> list = new List<object>();
if (oldValue != null) {
list.AddRange(oldValue as IEnumerable<object>);
}
list.RemoveAll(item => valueList.Contains(item));
return list;
}

43
Storage/Storage/Internal/Query/LCCompositionalCondition.cs
View File

@ -44,7 +44,7 @@ namespace LeanCloud.Storage.Internal.Query {
}
public void WhereNotContainedIn(string key, IEnumerable values) {
AddOperation(key, "nin", values);
AddOperation(key, "$nin", values);
}
public void WhereContainsAll(string key, IEnumerable values) {
@ -106,6 +106,32 @@ namespace LeanCloud.Storage.Internal.Query {
AddOperation(key, "$regex", $".*{subString}.*");
}
public void WhereMatches(string key, string regex, string modifiers) {
Dictionary<string, object> value = new Dictionary<string, object> {
{ "$regex", regex }
};
if (modifiers != null) {
value["$options"] = modifiers;
}
Add(new LCEqualCondition(key, value));
}
public void WhereMatchesQuery<K>(string key, LCQuery<K> query) where K : LCObject {
Dictionary<string, object> inQuery = new Dictionary<string, object> {
{ "where", query.condition },
{ "className", query.ClassName }
};
AddOperation(key, "$inQuery", inQuery);
}
public void WhereDoesNotMatchQuery<K>(string key, LCQuery<K> query) where K : LCObject {
Dictionary<string, object> inQuery = new Dictionary<string, object> {
{ "where", query.condition },
{ "className", query.ClassName }
};
AddOperation(key, "$notInQuery", inQuery);
}
void AddOperation(string key, string op, object value) {
LCOperationCondition cond = new LCOperationCondition(key, op, value);
Add(cond);
@ -123,15 +149,24 @@ namespace LeanCloud.Storage.Internal.Query {
}
// 筛选条件
public void OrderBy(string key) {
public void OrderByAscending(string key) {
orderByList = new List<string>();
orderByList.Add(key);
}
public void OrderByDescending(string key) {
OrderByAscending($"-{key}");
}
public void AddAscendingOrder(string key) {
if (orderByList == null) {
orderByList = new List<string>();
}
orderByList.Add(key);
}
public void OrderByDescending(string key) {
OrderBy($"-{key}");
public void AddDescendingOrder(string key) {
AddAscendingOrder($"-{key}");
}
public void Include(string key) {

66
Storage/Storage/LCCaptchaClient.cs Normal file
View File

@ -0,0 +1,66 @@
using System;
using System.Collections.Generic;
using System.Threading.Tasks;
namespace LeanCloud.Storage {
/// <summary>
/// 验证码
/// </summary>
public class LCCapture {
public string Url {
get; set;
}
public string Token {
get; set;
}
}
/// <summary>
/// 验证码工具类
/// </summary>
public static class LCCaptchaClient {
/// <summary>
/// 请求验证码
/// </summary>
/// <param name="width">验证码图片宽度</param>
/// <param name="height">验证码图片高度</param>
/// <returns></returns>
public static async Task<LCCapture> RequestCaptcha(int width = 82,
int height = 39) {
string path = "requestCaptcha";
Dictionary<string, object> queryParams = new Dictionary<string, object> {
{ "width", width },
{ "height", height }
};
Dictionary<string, object> response = await LCApplication.HttpClient.Get<Dictionary<string, object>>(path, queryParams: queryParams);
return new LCCapture {
Url = response["captcha_url"] as string,
Token = response["captcha_token"] as string
};
}
/// <summary>
/// 验证
/// </summary>
/// <param name="code"></param>
/// <param name="token"></param>
/// <returns></returns>
public static async Task VerifyCaptcha(string code,
string token) {
if (string.IsNullOrEmpty(code)) {
throw new ArgumentNullException(nameof(code));
}
if (string.IsNullOrEmpty(token)) {
throw new ArgumentNullException(nameof(token));
}
string path = "verifyCaptcha";
Dictionary<string, object> data = new Dictionary<string, object> {
{ "captcha_code", code },
{ "captcha_token", token }
};
await LCApplication.HttpClient.Post<Dictionary<string, object>>(path, data: data);
}
}
}

68
Storage/Storage/LCObject.cs
View File

@ -3,6 +3,7 @@ using System.Collections;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
using Newtonsoft.Json;
using LeanCloud.Storage.Internal.Object;
using LeanCloud.Storage.Internal.Operation;
using LeanCloud.Storage.Internal.Codec;
@ -412,6 +413,43 @@ namespace LeanCloud.Storage {
return this;
}
public static async Task<IEnumerable<LCObject>> FetchAll(IEnumerable<LCObject> objects) {
if (objects == null || objects.Count() == 0) {
throw new ArgumentNullException(nameof(objects));
}
IEnumerable<LCObject> uniqueObjects = objects.Where(item => item.ObjectId != null);
List<Dictionary<string, object>> requestList = uniqueObjects.Select(item => {
string path = $"/{LCApplication.APIVersion}/classes/{item.ClassName}/{item.ObjectId}";
return new Dictionary<string, object> {
{ "path", path },
{ "method", "GET" }
};
}).ToList();
Dictionary<string, object> data = new Dictionary<string, object> {
{ "requests", LCEncoder.Encode(requestList) }
};
List<Dictionary<string, object>> results = await LCApplication.HttpClient.Post<List<Dictionary<string, object>>>("batch",
data: data);
Dictionary<string, LCObjectData> dict = new Dictionary<string, LCObjectData>();
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 LCException(code, message);
}
Dictionary<string, object> d = item["success"] as Dictionary<string, object>;
string objectId = d["objectId"] as string;
dict[objectId] = LCObjectData.Decode(d);
}
foreach (LCObject obj in objects) {
LCObjectData objData = dict[obj.ObjectId];
obj.Merge(objData);
}
return objects;
}
public static void RegisterSubclass<T>(string className, Func<T> constructor) where T : LCObject {
Type classType = typeof(T);
LCSubclassInfo subclassInfo = new LCSubclassInfo(className, classType, constructor);
@ -419,12 +457,27 @@ namespace LeanCloud.Storage {
subclassTypeDict[classType] = subclassInfo;
}
void ApplyOperation(string key, ILCOperation op) {
if (operationDict.TryGetValue(key, out ILCOperation previousOp)) {
operationDict[key] = op.MergeWithPrevious(previousOp);
} else {
operationDict[key] = op;
/// <summary>
/// 序列化为 json 字符串
/// </summary>
/// <returns></returns>
public override string ToString() {
return JsonConvert.SerializeObject(LCObjectData.Encode(data));
}
/// <summary>
/// 反序列化为 LCObject 对象
/// </summary>
/// <param name="json"></param>
/// <returns></returns>
public static LCObject ParseObject(string json) {
LCObjectData objectData = LCObjectData.Decode(JsonConvert.DeserializeObject<Dictionary<string, object>>(json));
LCObject obj = Create(objectData.ClassName);
obj.Merge(objectData);
return obj;
}
void ApplyOperation(string key, ILCOperation op) {
if (op is LCDeleteOperation) {
estimatedData.Remove(key);
} else {
@ -434,6 +487,11 @@ namespace LeanCloud.Storage {
estimatedData[key] = op.Apply(null, key);
}
}
if (operationDict.TryGetValue(key, out ILCOperation previousOp)) {
operationDict[key] = op.MergeWithPrevious(previousOp);
} else {
operationDict[key] = op;
}
}
internal void Merge(LCObjectData objectData) {

81
Storage/Storage/LCQuery.cs
View File

@ -2,6 +2,7 @@
using System.Linq;
using System.Collections;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Threading.Tasks;
using LeanCloud.Storage.Internal.Query;
using LeanCloud.Storage.Internal.Object;
@ -16,7 +17,7 @@ namespace LeanCloud.Storage {
get; private set;
}
LCCompositionalCondition condition;
internal LCCompositionalCondition condition;
public LCQuery(string className) {
ClassName = className;
@ -56,6 +57,17 @@ namespace LeanCloud.Storage {
return this;
}
/// <summary>
/// 不包含
/// </summary>
/// <param name="key"></param>
/// <param name="values"></param>
/// <returns></returns>
public LCQuery<T> WhereNotContainedIn(string key, IEnumerable values) {
condition.WhereNotContainedIn(key, values);
return this;
}
/// <summary>
/// 包含全部
/// </summary>
@ -209,13 +221,48 @@ namespace LeanCloud.Storage {
return this;
}
/// <summary>
/// 正则匹配
/// </summary>
/// <param name="key"></param>
/// <param name="regex"></param>
/// <param name="modifiers"></param>
/// <returns></returns>
public LCQuery<T> WhereMatches(string key, string regex, string modifiers = null) {
condition.WhereMatches(key, regex, modifiers);
return this;
}
/// <summary>
/// 关系查询
/// </summary>
/// <param name="key"></param>
/// <param name="query"></param>
/// <returns></returns>
public LCQuery<T> WhereMatchesQuery<K>(string key, LCQuery<K> query) where K : LCObject {
condition.WhereMatchesQuery(key, query);
return this;
}
/// <summary>
/// 不满足子查询
/// </summary>
/// <typeparam name="K"></typeparam>
/// <param name="key"></param>
/// <param name="query"></param>
/// <returns></returns>
public LCQuery<T> WhereDoesNotMatchQuery<K>(string key, LCQuery<K> query) where K : LCObject {
condition.WhereDoesNotMatchQuery(key, query);
return this;
}
/// <summary>
/// 按 key 升序
/// </summary>
/// <param name="key"></param>
/// <returns></returns>
public LCQuery<T> OrderBy(string key) {
condition.OrderBy(key);
public LCQuery<T> OrderByAscending(string key) {
condition.OrderByAscending(key);
return this;
}
@ -229,6 +276,26 @@ namespace LeanCloud.Storage {
return this;
}
/// <summary>
/// 增加按 key 升序
/// </summary>
/// <param name="key"></param>
/// <returns></returns>
public LCQuery<T> AddAscendingOrder(string key) {
condition.AddAscendingOrder(key);
return this;
}
/// <summary>
/// 增加按 key 降序
/// </summary>
/// <param name="key"></param>
/// <returns></returns>
public LCQuery<T> AddDescendingOrder(string key) {
condition.AddDescendingOrder(key);
return this;
}
/// <summary>
/// 拉取 key 的完整对象
/// </summary>
@ -284,7 +351,7 @@ namespace LeanCloud.Storage {
}
WhereEqualTo("objectId", objectId);
Limit(1);
List<T> results = await Find();
ReadOnlyCollection<T> results = await Find();
if (results != null) {
if (results.Count == 0) {
return null;
@ -294,7 +361,7 @@ namespace LeanCloud.Storage {
return null;
}
public async Task<List<T>> Find() {
public async Task<ReadOnlyCollection<T>> Find() {
string path = $"classes/{ClassName}";
Dictionary<string, object> parameters = BuildParams();
Dictionary<string, object> response = await LCApplication.HttpClient.Get<Dictionary<string, object>>(path, queryParams: parameters);
@ -306,12 +373,12 @@ namespace LeanCloud.Storage {
obj.Merge(objectData);
list.Add(obj);
}
return list;
return list.AsReadOnly();
}
public async Task<T> First() {
Limit(1);
List<T> results = await Find();
ReadOnlyCollection<T> results = await Find();
if (results != null && results.Count > 0) {
return results[0];
}

77
Storage/Storage/LCSMSClient.cs Normal file
View File

@ -0,0 +1,77 @@
using System;
using System.Collections.Generic;
using System.Threading.Tasks;
namespace LeanCloud.Storage {
/// <summary>
/// 短信工具类
/// </summary>
public static class LCSMSClient {
/// <summary>
/// 请求短信验证码
/// </summary>
/// <param name="mobile"></param>
/// <param name="template"></param>
/// <param name="signature"></param>
/// <param name="captchaToken"></param>
/// <param name="variables"></param>
/// <returns></returns>
public static async Task RequestSMSCode(string mobile,
string template = null,
string signature = null,
string captchaToken = null,
Dictionary<string, object> variables = null) {
if (string.IsNullOrEmpty(mobile)) {
throw new ArgumentNullException(nameof(mobile));
}
string path = "requestSmsCode";
Dictionary<string, object> data = new Dictionary<string, object> {
{ "mobilePhoneNumber", mobile }
};
if (!string.IsNullOrEmpty(template)) {
data["template"] = template;
}
if (!string.IsNullOrEmpty(signature)) {
data["sign"] = signature;
}
if (!string.IsNullOrEmpty(captchaToken)) {
data["validate_token"] = captchaToken;
}
if (variables != null) {
foreach (KeyValuePair<string, object> kv in variables) {
data[kv.Key] = kv.Value;
}
}
await LCApplication.HttpClient.Post<Dictionary<string, object>>(path, data: data);
}
/// <summary>
/// 请求语音验证码
/// </summary>
/// <param name="mobile"></param>
/// <returns></returns>
public static async Task RequestVoiceCode(string mobile) {
string path = "requestSmsCode";
Dictionary<string, object> data = new Dictionary<string, object> {
{ "mobilePhoneNumber", mobile },
{ "smsType", "voice" }
};
await LCApplication.HttpClient.Post<Dictionary<string, object>>(path, data: data);
}
/// <summary>
/// 验证手机号
/// </summary>
/// <param name="mobile"></param>
/// <param name="code"></param>
/// <returns></returns>
public static async Task VerifyMobilePhone(string mobile, string code) {
string path = $"verifySmsCode/{code}";
Dictionary<string, object> data = new Dictionary<string, object> {
{ "mobilePhoneNumber", mobile }
};
await LCApplication.HttpClient.Post<Dictionary<string, object>>(path, data: data);
}
}
}

6
Storage/Storage/LCUser.cs
View File

@ -67,6 +67,12 @@ namespace LeanCloud.Storage {
}
}
/// <summary>
/// 是否是匿名登录
/// </summary>
public bool IsAnonymous => AuthData != null &&
AuthData.ContainsKey("anonymous");
static LCUser currentUser;
public static Task<LCUser> GetCurrent() {