public object Encode()
{
return(new Dictionary <string, object> {
{ "__op", "AddUnique" },
{ "objects", LCEncoder.Encode(values.ToList()) }
});
}
/// <summary>
/// Deletes this status.
/// </summary>
/// <returns></returns>
public new async Task Delete()
{
LCUser user = await LCUser.GetCurrent();
if (user == null)
{
throw new ArgumentNullException("current user");
}
LCUser source = (Data[SourceKey] ?? this[SourceKey]) as LCUser;
if (source != null && source.ObjectId == user.ObjectId)
{
await LCCore.HttpClient.Delete($"statuses/{ObjectId}");
}
else
{
Dictionary <string, object> data = new Dictionary <string, object> {
{ OwnerKey, JsonConvert.SerializeObject(LCEncoder.Encode(user)) },
{ InboxTypeKey, InboxType },
{ MessageIdKey, MessageId }
};
await LCCore.HttpClient.Delete("subscribe/statuses/inbox", queryParams : data);
}
}
public object Encode()
{
return(new Dictionary <string, object> {
{ "__op", "Remove" },
{ "objects", LCEncoder.Encode(valueList) }
});
}
object ILCOperation.Encode()
{
return(new Dictionary <string, object> {
{ "__op", "Add" },
{ "objects", LCEncoder.Encode(valueList) }
});
}
/// <summary>
/// Gets the count of the status with inboxType.
/// </summary>
/// <param name="inboxType"></param>
/// <returns></returns>
public static async Task <LCStatusCount> GetCount(string inboxType)
{
LCUser user = await LCUser.GetCurrent();
if (user == null)
{
throw new ArgumentNullException("current user");
}
Dictionary <string, object> queryParams = new Dictionary <string, object> {
{ OwnerKey, JsonConvert.SerializeObject(LCEncoder.Encode(user)) }
};
if (!string.IsNullOrEmpty(inboxType))
{
queryParams[InboxTypeKey] = inboxType;
}
Dictionary <string, object> response = await LCCore.HttpClient.Get <Dictionary <string, object> >("subscribe/statuses/count",
queryParams : queryParams);
LCStatusCount statusCount = new LCStatusCount {
Total = (int)response["total"],
Unread = (int)response["unread"]
};
return(statusCount);
}
static async Task SaveBatches(Stack <LCBatch> batches)
{
while (batches.Count > 0)
{
LCBatch batch = batches.Pop();
// 特殊处理 File 依赖
IEnumerable <LCFile> dirtyFiles = batch.objects.Where(item => (item is LCFile) && item.IsDirty)
.Cast <LCFile>();
foreach (LCFile file in dirtyFiles)
{
await file.Save();
}
List <LCObject> dirtyObjects = batch.objects.Where(item => item.IsDirty)
.ToList();
if (dirtyObjects.Count == 0)
{
continue;
}
List <Dictionary <string, object> > requestList = dirtyObjects.Select(item => {
string path = item.ObjectId == null ?
$"/1.1/classes/{item.ClassName}" :
$"/1.1/classes/{item.ClassName}/{item.ClassName}";
string method = item.ObjectId == null ? "POST" : "PUT";
Dictionary <string, object> body = LCEncoder.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", LCEncoder.Encode(requestList) }
};
List <Dictionary <string, object> > results = await LCCore.HttpClient.Post <List <Dictionary <string, object> > >("batch", data : data);
List <LCObjectData> 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 LCException(code, message as string);
}
return(LCObjectData.Decode(item["success"] as IDictionary));
}).ToList();
for (int i = 0; i < dirtyObjects.Count; i++)
{
LCObject obj = dirtyObjects[i];
LCObjectData objData = resultList[i];
obj.Merge(objData);
}
}
}
public Dictionary <string, object> Encode()
{
return(new Dictionary <string, object> {
{ key, new Dictionary <string, object> {
{ op, LCEncoder.Encode(value) }
} }
});
}
public Dictionary <string, object> Encode()
{
return(new Dictionary <string, object> {
{ "$relatedTo", new Dictionary <string, object> {
{ "object", LCEncoder.Encode(parent) },
{ "key", key }
} }
});
}
/// <summary>
/// Invokes a cloud function.
/// </summary>
/// <param name="name">Cloud function name.</param>
/// <param name="parameters">Parameters of cloud function.</param>
/// <returns>Dictionary<string, object> or List<object>.</returns>
public static async Task <Dictionary <string, object> > Run(string name,
Dictionary <string, object> parameters = null)
{
string path = $"functions/{name}";
Dictionary <string, object> headers = new Dictionary <string, object> {
{ PRODUCTION_KEY, IsProduction ? 1 : 0 }
};
object encodeParams = LCEncoder.Encode(parameters ?? new Dictionary <string, object>());
Dictionary <string, object> response = await LCCore.HttpClient.Post <Dictionary <string, object> >(path,
headers : headers,
data : encodeParams);
return(response);
}
public Dictionary <string, object> Encode()
{
if (conditionList == null || conditionList.Count == 0)
{
return(null);
}
if (conditionList.Count == 1)
{
ILCQueryCondition cond = conditionList[0];
return(cond.Encode());
}
return(new Dictionary <string, object> {
{ composition, LCEncoder.Encode(conditionList) }
});
}
async Task <Dictionary <string, object> > GetUploadToken()
{
Dictionary <string, object> data = new Dictionary <string, object> {
{ "name", Name },
{ "__type", "File" },
{ "mime_type", MimeType },
{ "metaData", MetaData }
};
if (ACL != null)
{
data["ACL"] = LCEncoder.EncodeACL(ACL);
}
return(await LCCore.HttpClient.Post <Dictionary <string, object> >("fileTokens", data : data));
}
/// <summary>
/// Deletes each object in the provided list.
/// </summary>
/// <param name="objects"></param>
/// <returns></returns>
public static async Task DeleteAll(IEnumerable <LCObject> objects)
{
if (objects == null || objects.Count() == 0)
{
throw new ArgumentNullException(nameof(objects));
}
HashSet <LCObject> objectSet = new HashSet <LCObject>(objects.Where(item => item.ObjectId != null));
List <Dictionary <string, object> > requestList = objectSet.Select(item => {
string path = $"/{LCCore.APIVersion}/classes/{item.ClassName}/{item.ObjectId}";
return(new Dictionary <string, object> {
{ "path", path },
{ "method", "DELETE" }
});
}).ToList();
Dictionary <string, object> data = new Dictionary <string, object> {
{ "requests", LCEncoder.Encode(requestList) }
};
await LCCore.HttpClient.Post <List <object> >("batch", data : data);
}
/// <summary>
/// Fetches all of the objects in the provided list.
/// </summary>
/// <param name="objects">The objects for fetching.</param>
/// <returns></returns>
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 = $"/{LCCore.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 LCCore.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);
}
/// <summary>
/// Sends this status.
/// </summary>
/// <returns></returns>
public async Task <LCStatus> Send()
{
LCUser user = await LCUser.GetCurrent();
if (user == null)
{
throw new ArgumentNullException("current user");
}
Dictionary <string, object> formData = new Dictionary <string, object> {
{ InboxTypeKey, InboxType }
};
if (Data != null)
{
formData["data"] = LCEncoder.Encode(Data);
}
if (query != null)
{
Dictionary <string, object> queryData = new Dictionary <string, object> {
{ "className", query.ClassName }
};
Dictionary <string, object> ps = query.BuildParams();
if (ps.TryGetValue("where", out object whereObj) &&
whereObj is string where)
{
queryData["where"] = JsonConvert.DeserializeObject(where);
}
if (ps.TryGetValue("keys", out object keys))
{
queryData["keys"] = keys;
}
formData["query"] = queryData;
}
Dictionary <string, object> response = await LCCore.HttpClient.Post <Dictionary <string, object> >("statuses",
data : formData);
LCObjectData objectData = LCObjectData.Decode(response);
Merge(objectData);
return(this);
}
/// <summary>
/// Resets the count of the status to be zero.
/// </summary>
/// <param name="inboxType"></param>
/// <returns></returns>
public static async Task ResetUnreadCount(string inboxType = null)
{
LCUser user = await LCUser.GetCurrent();
if (user == null)
{
throw new ArgumentNullException("current user");
}
Dictionary <string, object> queryParams = new Dictionary <string, object> {
{ OwnerKey, JsonConvert.SerializeObject(LCEncoder.Encode(user)) }
};
if (!string.IsNullOrEmpty(inboxType))
{
queryParams[InboxTypeKey] = inboxType;
}
await LCCore.HttpClient.Post <Dictionary <string, object> >("subscribe/statuses/resetUnreadCount",
queryParams : queryParams);
}
/// <summary>
/// Requests to add a friend.
/// </summary>
/// <param name="userId">The user id to add.</param>
/// <param name="attributes">The additional attributes for the friendship.</param>
/// <returns></returns>
public static async Task Request(string userId, Dictionary <string, object> attributes = null)
{
LCUser user = await LCUser.GetCurrent();
if (user == null)
{
throw new ArgumentNullException("current user");
}
string path = "users/friendshipRequests";
LCObject friend = LCObject.CreateWithoutData("_User", userId);
Dictionary <string, object> data = new Dictionary <string, object> {
{ "user", LCEncoder.EncodeLCObject(user) },
{ "friend", LCEncoder.EncodeLCObject(friend) },
};
if (attributes != null)
{
data["friendship"] = attributes;
}
await LCCore.HttpClient.Post <Dictionary <string, object> >(path, data : data);
}
internal static Dictionary <string, object> Encode(LCObjectData objectData)
{
if (objectData == null)
{
return(null);
}
Dictionary <string, object> dict = new Dictionary <string, object> {
{ "className", objectData.ClassName },
{ "objectId", objectData.ObjectId },
{ "createdAt", objectData.CreatedAt },
{ "updatedAt", objectData.UpdatedAt },
};
if (objectData.CustomPropertyDict != null)
{
foreach (KeyValuePair <string, object> kv in objectData.CustomPropertyDict)
{
string key = kv.Key;
object value = kv.Value;
dict[key] = LCEncoder.Encode(value);
}
}
return(dict);
}
/// <summary>
/// Retrieves a list of LCStatus that satisfy the query from the cloud.
/// </summary>
/// <returns></returns>
public new async Task <ReadOnlyCollection <LCStatus> > Find()
{
LCUser user = await LCUser.GetCurrent();
if (user == null)
{
throw new ArgumentNullException("current user");
}
Dictionary <string, object> queryParams = new Dictionary <string, object> {
{ LCStatus.OwnerKey, JsonConvert.SerializeObject(LCEncoder.Encode(user)) },
{ LCStatus.InboxTypeKey, InboxType },
{ "where", BuildWhere() },
{ "sinceId", SinceId },
{ "maxId", MaxId },
{ "limit", Condition.Limit }
};
Dictionary <string, object> response = await LCCore.HttpClient.Get <Dictionary <string, object> >("subscribe/statuses",
queryParams : queryParams);
List <object> results = response["results"] as List <object>;
List <LCStatus> statuses = new List <LCStatus>();
foreach (object item in results)
{
LCObjectData objectData = LCObjectData.Decode(item as IDictionary);
LCStatus status = new LCStatus();
status.Merge(objectData);
status.MessageId = (int)objectData.CustomPropertyDict[LCStatus.MessageIdKey];
status.Data = objectData.CustomPropertyDict;
status.InboxType = objectData.CustomPropertyDict[LCStatus.InboxTypeKey] as string;
statuses.Add(status);
}
return(statuses.AsReadOnly());
}
internal async Task <LCIMConversation> CreateConv(
IEnumerable <string> members = null,
string name = null,
bool transient = false,
bool unique = true,
bool temporary = false,
int temporaryTtl = 86400,
Dictionary <string, object> properties = null)
{
GenericCommand request = NewCommand(CommandType.Conv, OpType.Start);
ConvCommand conv = new ConvCommand {
Transient = transient,
Unique = unique,
};
if (members != null)
{
conv.M.AddRange(members);
}
if (temporary)
{
conv.TempConv = temporary;
conv.TempConvTTL = temporaryTtl;
}
Dictionary <string, object> attrs = new Dictionary <string, object>();
if (!string.IsNullOrEmpty(name))
{
attrs["name"] = name;
}
if (properties != null)
{
attrs = properties.Union(attrs.Where(kv => !properties.ContainsKey(kv.Key)))
.ToDictionary(k => k.Key, v => v.Value);
}
conv.Attr = new JsonObjectMessage {
Data = JsonConvert.SerializeObject(LCEncoder.Encode(attrs))
};
if (Client.SignatureFactory != null)
{
LCIMSignature signature = await Client.SignatureFactory.CreateStartConversationSignature(Client.Id, members);
conv.S = signature.Signature;
conv.T = signature.Timestamp;
conv.N = signature.Nonce;
}
request.ConvMessage = conv;
GenericCommand response = await Connection.SendRequest(request);
string convId = response.ConvMessage.Cid;
if (!Client.ConversationDict.TryGetValue(convId, out LCIMConversation conversation))
{
if (transient)
{
conversation = new LCIMChatRoom(Client);
}
else if (temporary)
{
conversation = new LCIMTemporaryConversation(Client);
}
else if (properties != null && properties.ContainsKey("system"))
{
conversation = new LCIMServiceConversation(Client);
}
else
{
conversation = new LCIMConversation(Client);
}
Client.ConversationDict[convId] = conversation;
}
// 合并请求数据
conversation.Id = convId;
conversation.Unique = unique;
conversation.UniqueId = response.ConvMessage.UniqueId;
conversation.Name = name;
conversation.CreatorId = Client.Id;
conversation.ids = members != null ?
new HashSet <string>(members) : new HashSet <string>();
// 将自己加入
conversation.ids.Add(Client.Id);
conversation.CreatedAt = DateTime.Parse(response.ConvMessage.Cdate);
conversation.UpdatedAt = conversation.CreatedAt;
return(conversation);
}
/// <summary>
/// Serializes this LCObject to a JSON string.
/// </summary>
/// <returns></returns>
public override string ToString()
{
Dictionary <string, object> originalData = LCObjectData.Encode(data);
Dictionary <string, object> currentData = estimatedData.Union(originalData.Where(kv => !estimatedData.ContainsKey(kv.Key)))
.ToDictionary(k => k.Key, v => LCEncoder.Encode(v.Value));
return(JsonConvert.SerializeObject(currentData));
}
/// <summary>
/// Saves this object to the cloud.
/// </summary>
/// <param name="fetchWhenSave">Whether or not fetch data when saved.</param>
/// <param name="query">The condition for saving.</param>
/// <returns></returns>
public async Task <LCObject> Save(bool fetchWhenSave = false, LCQuery <LCObject> query = null)
{
if (LCBatch.HasCircleReference(this, new HashSet <LCObject>()))
{
throw new ArgumentException("Found a circle dependency when save.");
}
Stack <LCBatch> batches = LCBatch.BatchObjects(new List <LCObject> {
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 LCCore.HttpClient.Post <Dictionary <string, object> >(path, data : LCEncoder.Encode(operationDict) as Dictionary <string, object>, queryParams : queryParams) :
await LCCore.HttpClient.Put <Dictionary <string, object> >(path, data : LCEncoder.Encode(operationDict) as Dictionary <string, object>, queryParams : queryParams);
LCObjectData data = LCObjectData.Decode(response);
Merge(data);
return(this);
}
public object Encode()
{
return(LCEncoder.Encode(value));
}
