public async Task AddAndRemove()
{
LCObject parent = new LCObject("Parent");
LCObject c1 = new LCObject("Child");
parent.AddRelation("children", c1);
LCObject c2 = new LCObject("Child");
parent.AddRelation("children", c2);
await parent.Save();
LCRelation <LCObject> relation = parent["children"] as LCRelation <LCObject>;
LCQuery <LCObject> query = relation.Query;
int count = await query.Count();
TestContext.WriteLine($"count: {count}");
Assert.AreEqual(count, 2);
parent.RemoveRelation("children", c2);
await parent.Save();
int count2 = await query.Count();
TestContext.WriteLine($"count: {count2}");
Assert.AreEqual(count2, 1);
}
public static async Task <LCObject> GetObject([LCEngineFunctionParam("className")] string className,
[LCEngineFunctionParam("id")] string id)
{
LCQuery <LCObject> query = new LCQuery <LCObject>(className);
return(await query.Get(id));
}
public async Task Get()
{
LCQuery <LCObject> query = new LCQuery <LCObject>("Account");
LCObject account = await query.Get("5e0d9f7fd4b56c008e5d048a");
Assert.AreEqual(account["balance"], 400);
}
public async Task String()
{
// Start
LCQuery <LCObject> query = new LCQuery <LCObject>("Hello");
query.WhereStartsWith("stringValue", "hello");
List <LCObject> results = await query.Find();
results.ForEach(item => {
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 => {
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 => {
string str = item["stringValue"] as string;
Assert.IsTrue(str.Contains(','));
});
}
public async Task Query()
{
LCObject geoObj = new LCObject("GeoObj");
Random random = new Random();
LCGeoPoint p1 = new LCGeoPoint(-90 + random.NextDouble() * 180, -180 + random.NextDouble() * 360);
geoObj["location"] = p1;
await geoObj.Save();
LCGeoPoint p2 = new LCGeoPoint(p1.Latitude + 0.01, p1.Longitude + 0.01);
double km = p1.KilometersTo(p2);
TestContext.WriteLine($"km: {km}, {Math.Ceiling(km)}");
LCQuery <LCObject> query = new LCQuery <LCObject>("GeoObj");
query.WhereWithinKilometers("location", p2, Math.Ceiling(km));
Assert.Greater((await query.Find()).Count, 0);
double miles = p1.MilesTo(p2);
query = new LCQuery <LCObject>("GeoObj");
query.WhereWithinMiles("location", p2, Math.Ceiling(miles));
Assert.Greater((await query.Find()).Count, 0);
double radians = p1.RadiansTo(p2);
query = new LCQuery <LCObject>("GeoObj");
query.WhereWithinRadians("location", p2, Math.Ceiling(radians));
Assert.Greater((await query.Find()).Count, 0);
}
public async Task QueryFollowersAndFollowees()
{
await LCUser.BecomeWithSessionToken(user2.SessionToken);
LCQuery <LCObject> query = user2.FolloweeQuery();
ReadOnlyCollection <LCObject> results = await query.Find();
Assert.Greater(results.Count, 0);
foreach (LCObject item in results)
{
Assert.IsTrue(item["followee"] is LCObject);
Assert.AreEqual(user1.ObjectId, (item["followee"] as LCObject).ObjectId);
}
query = user2.FollowerQuery();
results = await query.Find();
Assert.Greater(results.Count, 0);
foreach (LCObject item in results)
{
Assert.IsTrue(item["follower"] is LCObject);
Assert.AreEqual(user3.ObjectId, (item["follower"] as LCObject).ObjectId);
}
LCFollowersAndFollowees followersAndFollowees = await user2.GetFollowersAndFollowees(true, true, true);
Assert.AreEqual(followersAndFollowees.FollowersCount, 1);
Assert.AreEqual(followersAndFollowees.FolloweesCount, 1);
}
public async Task UserReadAndWrite()
{
await LCUser.Login("hello", "world");
LCObject account = new LCObject("Account");
LCUser currentUser = await LCUser.GetCurrent();
LCACL acl = LCACL.CreateWithOwner(currentUser);
account.ACL = acl;
account["balance"] = 512;
await account.Save();
Assert.IsTrue(acl.GetUserReadAccess(currentUser));
Assert.IsTrue(acl.GetUserWriteAccess(currentUser));
LCQuery <LCObject> query = new LCQuery <LCObject>("Account");
LCObject result = await query.Get(account.ObjectId);
TestContext.WriteLine(result.ObjectId);
Assert.NotNull(result.ObjectId);
await LCUser.Logout();
result = await query.Get(account.ObjectId);
Assert.IsNull(result);
}
public async Task First()
{
LCQuery <LCObject> query = new LCQuery <LCObject>("Account");
LCObject account = await query.First();
Assert.NotNull(account.ObjectId);
}
public async Task Geo()
{
LCObject obj = new LCObject("Todo");
LCGeoPoint location = new LCGeoPoint(39.9, 116.4);
obj["location"] = location;
await obj.Save();
// near
LCQuery <LCObject> query = new LCQuery <LCObject>("Todo");
LCGeoPoint point = new LCGeoPoint(39.91, 116.41);
query.WhereNear("location", point);
ReadOnlyCollection <LCObject> results = await query.Find();
Assert.Greater(results.Count, 0);
// in box
query = new LCQuery <LCObject>("Todo");
LCGeoPoint southwest = new LCGeoPoint(30, 115);
LCGeoPoint northeast = new LCGeoPoint(40, 118);
query.WhereWithinGeoBox("location", southwest, northeast);
results = await query.Find();
Assert.Greater(results.Count, 0);
}
public async Task UserReadAndWrite()
{
await LCUser.Login(TestPhone, TestPhone);
account = new Account();
LCUser currentUser = await LCUser.GetCurrent();
account.ACL = LCACL.CreateWithOwner(currentUser);
account.Balance = 512;
await account.Save();
Assert.IsTrue(account.ACL.GetUserReadAccess(currentUser));
Assert.IsTrue(account.ACL.GetUserWriteAccess(currentUser));
LCQuery <LCObject> query = new LCQuery <LCObject>("Account");
LCObject result = await query.Get(account.ObjectId);
TestContext.WriteLine(result.ObjectId);
Assert.NotNull(result.ObjectId);
await LCUser.Logout();
try {
await query.Get(account.ObjectId);
} catch (LCException e) {
Assert.AreEqual(e.Code, 403);
}
}
public async Task BaseQuery()
{
LCQuery <LCObject> query = new LCQuery <LCObject>("Hello");
query.Limit(2);
ReadOnlyCollection <LCObject> list = await query.Find();
TestContext.WriteLine(list.Count);
Assert.AreEqual(list.Count, 2);
foreach (LCObject item in list)
{
Assert.NotNull(item.ClassName);
Assert.NotNull(item.ObjectId);
Assert.NotNull(item.CreatedAt);
Assert.NotNull(item.UpdatedAt);
TestContext.WriteLine(item.ClassName);
TestContext.WriteLine(item.ObjectId);
TestContext.WriteLine(item.CreatedAt);
TestContext.WriteLine(item.UpdatedAt);
TestContext.WriteLine(item["intValue"]);
TestContext.WriteLine(item["boolValue"]);
TestContext.WriteLine(item["stringValue"]);
}
}
public static async Task <Dictionary <string, LCObject> > GetObjectMap()
{
LCQuery <LCObject> query = new LCQuery <LCObject>("Todo");
ReadOnlyCollection <LCObject> todos = await query.Find();
return(todos.ToDictionary(t => t.ObjectId));
}
public static async Task <ReadOnlyCollection <LCObject> > GetObjects()
{
LCQuery <LCObject> query = new LCQuery <LCObject>("Account");
query.WhereGreaterThan("balance", 100);
return(await query.Find());
}
public async Task QueryFile()
{
LCQuery <LCFile> query = LCFile.GetQuery();
LCFile file = await query.Get(avatar.ObjectId);
Assert.NotNull(file.Url);
TestContext.WriteLine(file.Url);
TestContext.WriteLine(file.GetThumbnailUrl(32, 32));
}
public async Task Array()
{
// equal
LCQuery <LCObject> query = new LCQuery <LCObject>("Book");
query.WhereEqualTo("pages", 3);
List <LCObject> results = await query.Find();
results.ForEach(item => {
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 => {
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 => {
List <object> pages = item["pages"] as List <object>;
bool f = false;
containIns.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 => {
List <object> pages = item["pages"] as List <object>;
Assert.AreEqual(pages.Count, 7);
});
}
/// <summary>
/// Subscribes a LCQuery.
/// </summary>
/// <param name="query"></param>
/// <returns></returns>
public static async Task <LCLiveQuery> Subscribe(this LCQuery query)
{
LCLiveQuery liveQuery = new LCLiveQuery {
Query = query
};
await liveQuery.Subscribe();
return(liveQuery);
}
public async Task QueryFile()
{
LCQuery <LCFile> query = LCFile.GetQuery();
LCFile file = await query.Get("5e0dbfa0562071008e21c142");
Assert.NotNull(file.Url);
TestContext.WriteLine(file.Url);
TestContext.WriteLine(file.GetThumbnailUrl(32, 32));
}
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);
}
async Task <ReadOnlyCollection <LCObject> > GetFriends()
{
LCUser user = await LCUser.GetCurrent();
LCQuery <LCObject> query = new LCQuery <LCObject>("_Followee")
.WhereEqualTo("user", user)
.WhereEqualTo("friendStatus", true);
return(await query.Find());
}
public async Task Count()
{
LCQuery <LCObject> query = new LCQuery <LCObject>("Account");
query.WhereGreaterThan("balance", 200);
int count = await query.Count();
TestContext.WriteLine(count);
Assert.Greater(count, 0);
}
public async Task Query()
{
await LCUser.Login(TestPhone, TestPhone);
LCQuery <LCObject> query = new LCQuery <LCObject>("Account");
Account queryAccount = (await query.Get(account.ObjectId)) as Account;
TestContext.WriteLine(queryAccount.ObjectId);
Assert.NotNull(queryAccount.ObjectId);
}
public async Task GreaterQuery()
{
LCQuery <LCObject> query = new LCQuery <LCObject>("Account");
query.WhereGreaterThan("balance", 200);
ReadOnlyCollection <LCObject> list = await query.Find();
TestContext.WriteLine(list.Count);
Assert.Greater(list.Count, 0);
}
public async Task Query()
{
await LCUser.Login("game", "play");
LCQuery <LCObject> query = new LCQuery <LCObject>("Account");
LCObject account = await query.Get("5e144525dd3c13006a8f8de2");
TestContext.WriteLine(account.ObjectId);
Assert.NotNull(account.ObjectId);
}
async Task <LCFriendshipRequest> GetRequest()
{
LCUser user = await LCUser.GetCurrent();
LCQuery <LCFriendshipRequest> query = new LCQuery <LCFriendshipRequest>("_FriendshipRequest")
.WhereEqualTo("friend", user)
.WhereEqualTo("status", "pending");
return(await query.First());
}
public async Task Get()
{
Account account = new Account {
Balance = 1024
};
await account.Save();
LCQuery <LCObject> query = new LCQuery <LCObject>("Account");
Account newAccount = (await query.Get(account.ObjectId)) as Account;
Assert.AreEqual(newAccount.Balance, 1024);
}
async Task Query()
{
LCQuery <LCObject> query = new LCQuery <LCObject>("Hello");
query.Limit(2);
List <LCObject> list = await query.Find();
foreach (LCObject obj in list)
{
Debug.Log($"object id: {obj.ObjectId}");
}
}
public async Task Select()
{
LCQuery <LCObject> query = new LCQuery <LCObject>("Account");
query.Select("balance");
List <LCObject> results = await query.Find();
results.ForEach(item => {
Assert.NotNull(item["balance"]);
Assert.IsNull(item["user"]);
});
}
public async Task Include()
{
LCQuery <LCObject> query = new LCQuery <LCObject>("Hello");
query.Include("objectValue");
LCObject hello = await query.Get("5e0d55aedd3c13006a53cd87");
LCObject world = hello["objectValue"] as LCObject;
TestContext.WriteLine(world["content"]);
Assert.AreEqual(world["content"], "7788");
}
public async Task Select()
{
LCQuery <LCObject> query = new LCQuery <LCObject>("Account");
query.Select("balance");
ReadOnlyCollection <LCObject> results = await query.Find();
foreach (LCObject item in results)
{
Assert.NotNull(item["balance"]);
Assert.IsNull(item["user"]);
}
}
public async Task FetchAll()
{
LCQuery <LCObject> query = new LCQuery <LCObject>("Hello");
IEnumerable <string> ids = (await query.Find()).Select(obj => obj.ObjectId);
IEnumerable <LCObject> list = ids.Select(id => LCObject.CreateWithoutData("Hello", id));
await LCObject.FetchAll(list);
Assert.Greater(list.Count(), 0);
foreach (LCObject obj in list)
{
Assert.NotNull(obj.CreatedAt);
}
}
