SynergyKit iOS SDK

Letsgood.com 运行 SynergyKit，一个 Backend as a Service 平台，用于 快速简单地进行移动/网络/桌面应用程序开发。SynergyKit 允许创业公司像 Lean Startup 一样快速、低成本地实现想法。

我们知道与未经测试的 API 一起工作可能有多么困难，因此我们为大多数使用的平台准备了 SDK。

其他 SDK

• Android SDK
• Node.js SDK
  
  

目录

示例应用程序

示例应用程序展示了 SynergyKit 几乎所有可能的功能，它是与 SDK 一起开发的，用于介绍其工作方式。

样本应用程序安装

• 克隆或下载仓库。
• 在终端中转到 SampleApp 文件夹。
• 运行 pod install。
• 打开 .xcworkspace 文件。

* 需要 Cocoapods

SDK 安装

SynergyKit-SDK 可通过 CocoaPods 获取。要安装它，只需将以下行添加到您的 Podfile 中：

pod 'SynergyKit-SDK'

架构

构建模型

构建数据模型是应用程序开发中最重要的一项活动。

如果您想使用 SynergyKit SDK 进行开发，您需要从数据模型中对 SynergykitObject 进行子类化开始。 SynergykitObject 包含与 SynergyKit 通信所必需的 必选 属性（如 _id、__v、createdAt 和 updatedAt）。它还符合 SynergykitProtocol、SBatchableProtocol 和 SCacheableProtocol，这些协议简化了与 SynergyKit 的协作。

SynergykitObject 的序列化和反序列化基于 JSONModel。JSONModel 的作者 Marin Todorov 在 GitHub 框架页面 上展示了神奇的建模框架的示例。

不要害怕在 Swift 中编写模型。Swift 并未完全支持 JSONModel。

示例

{
  "author": "Mr. Synergykit",
  "name": "Building model,
  "price": 9.5
}

@interface BookModel : SynergykitObject
@property (strong, nonatomic) NSString* author;
@property (strong, nonatomic) NSString* name;
@property (assign, nonatomic) float price;
@end

@implementation BookModel
@end

如果您的对象具有不与服务器同步的属性，只要说它符合协议 Optional 或 Ignore 即可。这些协议对于反序列化非常重要，因为包含这些协议的 json 字符串必须包含所有属性，但不能包含这些协议。有关 JSONModel 协议的更多信息。

{
  "author": "Mr. Synergykit",
  "name": "Building model,
  "price": 9.5
}

@interface BookModel : SynergykitObject
@property (strong, nonatomic) NSString* author;
@property (strong, nonatomic) NSString* name;
@property (assign, nonatomic) float price;
@property (strong, nonatomic) NSString<Optional>* category;
@property (strong, nonatomic) NSNumber<Ignore>* order;
@end

@implementation BookModel
@end

SynergyKit 初始化

如果安装过程已完成，那么现在就是进行基本设置的时候了。必需的选项包括租户和密钥，以及一个可选的选项 - 启用调试。

租户和密钥位于 Synergykit 网络应用程序中的 设置 > 应用密钥 > 租户 和 设置 > 应用密钥 > 值。

[Synergykit setTenant:@"tenant" key:@"key"];
[Synergykit enableDebugging:YES];

Synergykit.setTenant("tenant", key: "key")
Synergykit.enableDebugging(true)

处理响应

API 通信结束时，您可以收到许多选项。SDK 将这些 API 响应包装在 SResponse 或 SResponseWrapper 对象中，具体取决于请求类型。

只有单个对象返回响应的基本请求作为 SResponse 对象，可以通过这种方式进行处理。

^(SResponse *result) {
    if ([result succeeded])
    {
        YourType *successObject = (YourType *) result;
    }
    else
    {
        NSError *errorObject = result.error
    }
}

{
    (result : SResponse!) -> Void in
    if result.succeeded()
    {
        let successObject = result.result as YourType
    }
    else
    {
        let errorObject = result.error
    }
}

返回响应中包含多个对象的复杂请求作为 SResponseWrapper 对象。

^(SResponseWrapper *results) {
    if ([results succeeded])
    {
        for (YourType *response in results.results)
        {
            // Handle response
        }
    }
    else
    {
        for (NSError *response in results.results)
        {
            // Handle error
        }
    }
}

{
    (results : SResponseWrapper!) -> Void in
    if results.succeeded()
    {
        for response in results.results() as [YourType]
        {
            // Handle response
        }
    }
    else
    {
        for error in results.errors()
        {
            // Handle error
        }
    }
}

文档

文档是保存在集合中的数据。集合基本上是数据库中的表，您可以在这里存储您的数据。通过向文档端点发送请求，您可以列出、创建、更新或删除文档。

创建新文档

SynergykitObject *data = [[SynergykitObject alloc] initWithCollection:@"target-collection"];

[data save:^(SResponse *result) {
   // Handle result
}];

let data = SynergykitObject(collection: "target-collection")

data.save {
    (result : SResponse!) -> Void in
    // Handle result
}

通过 ID 检索现有文档

SynergykitObject *data = [[SynergykitObject alloc] initWithCollection:@"target-collection" _id:@"data-id"];

[data fetch:^(SResponse *result) {
    // Handle result
}];

let data = SynergykitObject(collection: "target-collection", _id: "data-id")

data.fetch {
    (result : SResponse!) -> Void in
    // Handle result
}

更新文档

如果设置了 _id，则保存方法会执行 PUT 请求。

SynergykitObject *data = [[SynergykitObject alloc] initWithCollection:@"target-collection" _id:@"data-id"];

[data save:^(SResponse *result) {
   // Handle result
}];

let data = SynergykitObject(collection: "target-collection", _id: "data-id")

data.save {
    (result : SResponse!) -> Void in
    // Handle result
}

删除文档

SynergykitObject *data = [[SynergykitObject alloc] initWithCollection:@"target-collection" _id:@"data-id"];

[data destroy:^(SResponse *result) {
   // Handle result
}];

let data = SynergykitObject(collection: "target-collection", _id: "data-id")

data.destroy {
    (result : SResponse!) -> Void in
    // Handle result
}

实时数据监控

SDK 支持通过套接字进行实时通信。您可以观察以下类型的更改。

• 作为 SMethodTypePOST 使用 POST
• 作为 SMethodTypePUT 使用 PUT
• 作为 SMethodTypePATCH 使用 PATCH
• 作为 SMethodTypeDELETE 使用 DELETE

SObserver 可以监听整个集合或筛选区域中的更改。

检查连接状态

实时连接状态可以通过代理方法 observingConnectionDidChangeState 来处理。

[SObserver connectionDelegate:self];

SObserver.connectionDelegate(self)

开始监控整个集合

SynergykitObject *object = [[SynergykitObject alloc] initWithCollection:@"target-collection"];

SObserver *observer = [[SObserver alloc] initWithObject:object event:SMethodTypePOST];

[observer startObservingWithObjectHandler:^(id result) {
    // Handle received object
} stateHandler:^(SObserverState state, NSArray *errors) {
    // Handle changed state
}];

let object = SynergykitObject(collection: "target-collection")

let observer = SObserver(object: object, event: SMethodType.POST)

observer.startObservingWithObjectHandler({
    (result : AnyObject!) -> Void in
    // Handle received object
}, stateHandler: {
    (state : SObserverState, args : [AnyObject]!) -> Void in
    // Handle changed state
})

带有筛选器的监控集合

SynergykitObject *object = [[SynergykitObject alloc] initWithCollection:@"target-collection"];

SQuery *query = [[SQuery alloc] initWithObject:object];
[query filterField:@"player" relationOperator:@"==" value:@"knight"];

SObserver *observer = [[SObserver alloc] initWithObject:query queryName:@"knight" event:SMethodTypePOST];

[observer startObservingWithObjectHandler:^(id result) {
    // Handle received object
} stateHandler:^(SObserverState state, NSArray *errors) {
    // Handle changed state
}];

let object = SynergykitObject(collection: "target-collection")

let query = SQuery(object: object)
query.filterField("player", relationOperator: "==", value: "knight")

let observer = SObserver(object: query, queryName: "knight", event: SMethodType.POST)

observer.startObservingWithObjectHandler({
    (result : AnyObject!) -> Void in
    // Handle received object
}, stateHandler: {
    (state : SObserverState, args : [AnyObject]!) -> Void in
    // Handle changed state
})

停止监听

[observer stopObserving];

observer.stopObserving()

或者，如果您没有实例引用，可以通过调用一个方法来停止所有观察者。

[SObserver stopAllObservers];

SObserver.stopAllObservers()

语音通信

设备到设备之间无数据存储的通信。

发送语音

SObserver *observer = [[SObserver alloc] initWithSpeakName:@"typing"];

SynergykitUser *user = [SynergykitUser new];
user.email = @"[email protected]";

[observer speakWithObject:user];

let observer = SObserver(speakName: "typing")

let user = SynergykitUser()
user.email = "[email protected]"

observer.speakWithObject(user)

接收语音

SObserver *observer = [[SObserver alloc] initWithSpeakName:@"typing"];

[observer startObservingWithObjectHandler:^(id result) {
    // Handle received object
} stateHandler:^(SObserverState state, NSArray *errors) {
    // Handle changed state
}];

let observer = SObserver(speakName: "typing")

observer.startObservingWithObjectHandler({
    (result : AnyObject!) -> Void in
    // Handle received object
}, stateHandler: {
    (state : SObserverState, args : [AnyObject]!) -> Void in
    // Handle changed state
})

查询

您可以通过发送带查询的请求一次性检索多个对象。如果没有条件，则查询返回整个集合中所有对象列表的简单列表。

对于更复杂的筛选和排序，SynergyKit 接受 OData 标准。这些查询可以与数据、用户和文件一起使用。

可用条件

查询字符串按照 OData 协议 构建，并附加到 URL 的末尾。

OData 协议规范定义了如何通过提供必须包含所需元素的条目集合来标准化以数据为中心的 CRUD 接口。

筛选器

等同于 if (field == "value" && secondField >= 33 || thirdField < 132000)。

[query filterField:@"field" relationOperator:@"==" value:@"value"];
[query filterAnd];
[query filterField:@"secondField" relationOperator:@">=" value:[NSNumber numberWithInt:33]];
[query filterOr];
[query filterField:@"thirdField" relationOperator:@"<" value:[NSNumber numberWithInt:132000]];

query.filterField("field", relationOperator: "==", value: "value")
query.filterAnd()
query.filterField("secondField", relationOperator: ">=", value: NSNumber(int: 33))
query.filterOr()
query.filterField("thirdField", relationOperator: "<", value: NSNumber(int: 132000))

可用关系运算符

• == 或 eq
• != 或 ne
• >= 或 ge
• <= 或 le
• > 或 gt
• < 或 lt

startswith

[query startsWith:@"a" field:@"name"];

query.startsWith("a", field:"name")

endswith

[query endsWith:@"z" field:@"name"];

query.endsWith("z", field:"name")

substringof

[query substringOf:@"bc" field:@"name"];

query.substringOf("bc", field:"name")

in

[query filterIn:@"name" values:@"Lucas,Thomas"];

query.filterIn("name", values:"Lucas,Thomas")

nin

[query filterNin:@"name" values:@"John,Mark"];

query.filterNin("name", values:"John,Mark")

select

[query select:@"firstName,lastName"];

query.select("firstName,lastName")

top

[query top:5];

query.top(5)

orderby

[query orderBy:"name" direction:OrderByDirectionAsc];

query.orderBy("name", direction:.Asc)

inlinecount

[query inlineCount:YES];

query.inlineCount(true)

skip

[query skip:32];

query.skip(32)

查询对象

如果查询已准备，则只需调用find方法。

[query find:^(SResponseWrapper *result) {
    // Handle result
}]

query.find {
    (result : SResponseWrapper!) -> Void in
    // Handle result
}

列出所有用户

SQuery 与 SynergykitUser 对象（无条件）。

SynergykitUser *user = [SynergykitUser new];

SQuery *query = [[SQuery alloc] initWithObject:user];

[query find:^(SResponseWrapper *result) {
    // Handle received objects
}];

let user = SynergykitUser()

let query = SQuery(object: user)

query.find {
    (result : SResponseWrapper!) -> Void in
    // Handle received objects
}

列出所有文档

SQuery 与 SynergykitObject 对象（无条件）。

SynergykitObject *data = [[SynergykitObject alloc] initWithCollection:@"target-collection"];

SQuery *query = [[SQuery alloc] initWithObject:data];

[query find:^(SResponseWrapper *result) {
    // Handle received objects
}];

let data = SynergykitObject(collection: "target-collection")

let query = SQuery(object: data)

query.find {
    (result : SResponseWrapper!) -> Void in
    // Handle received objects
}

列出所有文件

SQuery 与 SFile 对象（无条件）。

SFile *file = [SFile new];

SQuery *query = [[SQuery alloc] initWithObject:file];

[query find:^(SResponseWrapper *result) {
    // Handle received objects
}];

let data = SFile()

let query = SQuery(object: file)

query.find {
    (result : SResponseWrapper!) -> Void in
    // Handle received objects
}

用户

用户是每个应用程序的起点和终点。在SynergyKit中，您可以通过以下方法轻松地与用户一起工作。

创建新用户

SynergykitUser *user = [SynergykitUser new];

[user save:^(SResponse *result) {
    // Handle result
}];

let user = SynergykitUser()

user.save {
    (result : SResponse!) -> Void in
    // Handle result
}

通过ID检索现有用户

SynergykitUser *user = [[SynergykitUser alloc] initWithId:@"object-id"];

[user fetch:^(SResponse *result) {
    // Handle result
}];

let user = SynergykitUser(id: "object-id")

user.fetch {
    (result : SResponse!) -> Void in
    // Handle result
}

更新用户

如果设置了 _id，则保存方法会执行 PUT 请求。

SynergykitUser *user = [[SynergykitUser alloc] initWithId:@"object-id"];

[user save:^(SResponse *result) {
    // Handle result
}];

let user = SynergykitUser(id: "object-id")

user.save {
    (result : SResponse!) -> Void in
    // Handle result
}

删除用户

SynergykitUser *user = [[SynergykitUser alloc] initWithId:@"object-id"];

[user destroy:^(SResponse *result) {
    // Handle result
}];

let user = SynergykitUser(id: "object-id")

user.destroy {
    (result : SResponse!) -> Void in
    // Handle result
}

添加角色

SynergykitUser *user = [[SynergykitUser alloc] initWithId:@"object-id"];

[user addRole:@"master" handler:^(SResponse *result) {
    // Handle result
}];

let user = SynergykitUser(id: "object-id")

user.addRole("master", handler: {
    (result : SResponse!) -> Void in
    // Handle result
})

删除角色

SynergykitUser *user = [[SynergykitUser alloc] initWithId:@"object-id"];

[user removeRole:@"master" handler:^(SResponse *result) {
    // Handle result
}];

let user = SynergykitUser(id: "object-id")

user.removeRole("master", handler: {
    (result : SResponse!) -> Void in
    // Handle result
})

向用户添加平台

平台通过注册ID将单个移动设备或Web应用程序与用户配对很有用。将平台分配给用户后，您将能够向设备或应用程序发送推送通知。

在开始使用 用户平台之前，需要首先登录。登录成功后，SDK会接收用户的sessionToken进行身份验证。令牌由SDK持有，并自动插入到Headers中。

SPlatform *platform = [SPlatform new];
platform.registrationId = @"device-token";
platform.development = [NSNumber numberWithBool:YES];

[platform save:^(SResponse *result) {
    // Handle result
}];

let platform = SPlatform()
platform.registrationId = "device-token"
platform.development = NSNumber(bool: true)

platform.save {
    (result : SResponse!) -> Void in
    // Handle result
}

检索平台

SPlatform *platform = [[SPlatform alloc] initWithId:@"platform-id"];

[platform fetch:^(SResponse *result) {
    // Handle result
}];

let platform = SPlatform(id: "platform-id")

platform.fetch {
    (result : SResponse!) -> Void in
    // Handle result
}

更新平台

平台包含一些参数，但只有两个是可以更新的。如果设置了_id，save方法会执行PUT请求，可以更改development和registrationId。

SPlatform *platform = [[SPlatform alloc] initWithId:@"platform-id"];
platform.registrationId = @"new-device-token";
platform.development = [NSNumber numberWithBool:NO];

[platform save:^(SResponse *result) {
    // Handle result
}];

let platform = SPlatform(id: "platform-id")
platform.registrationId = "new-device-token"
platform.development = NSNumber(bool: false)

platform.save {
    (result : SResponse!) -> Void in
    // Handle result
}

删除平台

SPlatform *platform = [[SPlatform alloc] initWithId:@"platform-id"];

[platform destroy:^(SResponse *result) {
    // Handle result
}];

let platform = SPlatform(id: "platform-id")

platform.destroy {
    (result : SResponse!) -> Void in
    // Handle result
}

激活用户

默认情况下，用户未激活。这意味着您可以使用此状态通过发送激活链接来验证用户的电子邮件地址。

要激活用户，请发送带有此激活链接的电子邮件 /v2/users/activation/[ACTIVATION_HASH]。您可以提供参数callback，其中包含您希望用户激活后重定向的url地址。

或者，如果您**知道电子邮件地址是有效的**，您可以使用SDK来激活用户。

SynergykitUser *user = [[SynergykitUser alloc] initWithId:@"object-id"];

[user activate:^(SResponse *result) {
    // Handle result
}];

let user = SynergykitUser(id: "object-id")

user.activate {
    (result : SResponse!) -> Void in
    // Handle result
}

登录用户

如果用户是通过常规方式注册的，即通过电子邮件和密码，您可以使用登录方法对他进行认证。

SynergykitUser *user = [SynergykitUser new];
user.email = @"[email protected]";
user.password = @"my-password";

[user login:^(SResponse *result) {
    // Handle result
}];

let user = SynergykitUser()
user.email = "[email protected]";
user.password = "my-password";

user.login {
    (result : SResponse!) -> Void in
    // Handle result
}

通信

在SynergyKit中，您可以以不同的方式与您的用户通信。下面这节列出了一些方法。

其中一种方式是向用户的设备发送推送通知。这一行动需要在设置中的Android部分填写您的API密钥。对于iOS设备的推送通知，您需要在设置中的Apple部分填写您的密码和证书。

另一种方式是将电子邮件发送给您的用户。为此，您需要在与邮件部分的管理中创建电子邮件模板。

发送通知

SynergykitUser *user = [[SynergykitUser alloc] initWithId:@"user-id"];

SNotification *notification = [[SNotification alloc] initWithRecipient:user];
notification.alert = @"Hello Lucas";

[notification send:^(SResponse *result) {
    // Handle result
}];

let user = SynergykitUser(id: "user-id")

let notification = SNotification(recipient: user)
notification.alert = "Hello Lucas"

notification.send {
    (result : SResponse!) -> Void in
    // Handle result
}

发送电子邮件

SynergykitUser *user = [SynergykitUser new];
user.email = @"[email protected]";

SEmail *email = [SEmail new];
email.to = user;
email.subject = @"Email Example";
email.templateName = @"email-example";
email.args = @{@"name": @"Lucas"}; // according template

[email send:^(SResponse *result) {
    // Handle result
}];

let user = SynergykitUser()
user.email = "[email protected]"

let email = SEmail()
email.to = user
email.subject = "Email Example"
email.templateName = "email-example"
email.args = ["name": "Lucas"] // according template

email.send {
    (result : SResponse!) -> Void in
    // Handle result
}

简短形式

let user = SynergykitUser()
user.email = "[email protected]"

SEmail().to(user).subject("Email Example").templateName("email-example").args(["name": "Lucas"]).send {
    (result : SResponse!) -> Void in
    // Handle result
}

电子邮件模板应类似于以下示例。

<p>Hello %name%,</p>
<br>
<p>this e-mail was send from Synergykit Sample Application.</p>
<br>
<p>Synergykit Team</p>

文件

上传文件

SynergyKit SDK支持多种文件类型的上传。以下是一个图像上传的示例。如果文件成功上传，代表刚刚创建的文件对象的SFile将被返回。SFile包含文件的可访问路径。

SFile *file = [SFile new];

UIImage *imageToUpload = [UIImage imageNamed:@"synergykit-logo"];
NSData *imageData = UIImageJPEGRepresentation(imageToUpload, 1.0);

[file uploadJPEGImage:imageData handler:^(SResponse *result) {
    // Handle result
}];

let file = SFile()

let imageToUpload = UIImage(named:"synergykit-logo")
let imageData = UIImageJPEGRepresentation(imageToUpload, 1.0)

file.uploadJPEGImage(imageData handler: {
    (result : SResponse!) -> Void in
    // Handle result
})

通过ID检索文件

[[SFile alloc] initWithId:@"file-id"] fetch:^(SResponse *result) {
    // Handle result
}];

SFile(id: "file-id").fetch {
    (result : SResponse!) -> Void in
    // Handle result
}

删除文件

[[SFile alloc] initWithId:@"file-id"] destroy:^(SResponse *result) {
    // Handle result
}];

SFile(id: "file-id").destroy {
    (result : SResponse!) -> Void in
    // Handle result
}

云代码

我们的愿景是让开发者在不处理服务器的情况下构建任何应用。对于复杂的应用，有时您只需要一些不在移动设备上运行的逻辑。云代码使这成为可能。

云代码在Node.js监禁沙盒中运行，并使用严格的JavaScript语言和一些准备好的模块和变量，您可以使用它们进行开发。
mac

运行云代码

SCloudCode *cloudCode = [[SCloudCode alloc] initWithName:@"example" args:@{@"name": @"Lucas"} resultType:nil];

[cloudCode invoke:^(SResponse *result) {
    // Handle result
}];

let cloudCode = SCloudCode(name: "example", args: ["name": "Lucas"], resultType: nil)

cloudCode.invoke {
    (result : SResponse!) -> Void in
    // Handle result
}

示例云代码函数应类似于以下。

callback("Hello " + parameters.name + "!")

批量请求

我们知道互联网连接有时可能不稳定，我们也知道这对需要无错误执行数十个请求的同步算法来说并不好。批量请求将连接失败的风险降到最低——要么全部在一起，要么什么都没有，不是前五个请求成功，然后两个失败（过桥），最后三个成功。

SBatchItem

您可以使用SBatchItem对象批量处理任何您想象得到的请求。首先创建一个批量项，说明在哪里以及如何执行它。

SBatchItem *item = [[SBatchItem alloc] initWithId:[NSNumber numberWithInt:1] method:SMethodTypeGET endpoint:@"/data/target-collection" body:nil];

let batchItem = SBatchItem(id: NSNumber(int: 1), method: .GET, endpoint: "/data/target-collection", body: nil)

SBatchItemWrapper

每个批次项都需要包裹在 SBatchItemWrapper 中，你可以在回调中说明期望的内容。如果未设置类型，请求返回的结果为 NSDictionary。包装器为您提供处理请求响应的显式处理器。如果没有设置处理器，则不会发生任何事情，每个请求都在批次执行回调中隐式处理。

SBatchItemWrapper *wrapper = [[SBatchItemWrapper alloc] initWithItem:item type: DemoObject.class handler:nil];

let wrapper = SBatchItemWrapper(item, type: DemoObject.self, handler:nil)

SBatch

项目执行在 SBatch 对象中。批次按添加顺序执行每个请求。

SBatch *batch = [SBatch new];
[batch addItem:wrapper];

[batch executeWithCompletion:^(SResponseWrapper *result) {
   // Handle all results implicitly
}];

let batch = SBatch()
batch.addItem(wrapper)

batch.executeWithCompletion {
    (results : SResponseWrapper!) -> Void in
    // Handle all results implicitly
}

使用批次

SDK 允许将所有可用的请求作为一个单独的请求进行批次处理。如果有 SynergykitObject 方法的 save，那么有对应的 saveInBatch 方法为您创建 SBatchItemWrapper。生成包装器后，您只需将其添加到 SBatch 中即可。

// Prepares requests
SynergykitUser *user = [[SynergykitUser alloc] initWithId:@"user-id"];
SBatchItemWrapper *userWrapper = [user fetchInBatch:^(SResponse *result) {
    // Handle result explicitly
}];

SynergykitObject *object = [[SynergykitObject alloc] initWithCollection:@"target-collection"];
SBatchItemWrapper *objectWrapper = [object saveInBatch:nil];

SQuery *query = [[SQuery alloc] initWithObject:[SFile new]];
[[query orderBy:@"size" direction:OrderByDirectionDesc] top:10];
SBatchItemWrapper *queryWrapper = [query findInBatch:nil];

SBatch *batch = [SBatch new];

// Fills batch with requests
[batch addItem:userWrapper];
[batch addItems:@[objectWrapper, queryWrapper]];

[batch executeWithCompletion:^(SResponseWrapper *result) {
   // Handle all results implicitly
}];

// Prepares requests
let user = SynergykitUser(id: "user-id")
let userWrapper = user .fetchInBatch {
    (result : SResponse!) -> Void in
    // Handle result explicitly
}

let object = SynergykitObject(collection: "target-collection")
let objectWrapper = object .saveInBatch(nil)

let query = SQuery(object: SFile())
query.orderBy("size", direction: .Desc).top(10)
let queryWrapper = query.findInBatch(nil)

let batch = SBatch()

// Fills batch with requets
batch.addItem(userWrapper)
batch.addItems([objectWrapper, queryWrapper])

batch.executeWithCompletion {
    (results : SResponseWrapper!) -> Void in
    // Handle all results implicitly
}

缓存

SynergyKit iOS SDK 实现了 NSURLRequestCachePolicy 支持的新高级缓存策略。如果您想开始使用 API 通信中的缓存，只需在对象上设置缓存参数。

SCacheTypeCacheElseLoad

如果存在，则返回缓存数据。

SCache *cache = [[SCache alloc] initWithType:SCacheTypeCacheElseLoad];

SynergykitObject *object = [[SynergykitObject alloc] initWithCollection:@"target-collection" _id:@"object-id"];
object.cache = cache;

[object fetch:^(SResponse *result) {
    // Handle result
}];

let cache = SKCache(type: .CacheElseLoad)

let object = SynergykitObject(collection: "target-collection", _id: "object-id")
object.cache = cache

object.fetch {
    (result : SResponse!) -> Void in
    // Handle result
}

SCacheTypeLoadElseCache

如果存在缓存数据并且网络连接不可用，则返回缓存数据。

SCache *cache = [[SCache alloc] initWithType:SCacheTypeLoadElseCache];

SynergykitObject *object = [[SynergykitObject alloc] initWithCollection:@"target-collection" _id:@"object-id"];
object.cache = cache;

[object fetch:^(SResponse *result) {
    // Handle result
}];

let cache = SKCache(type: .LoadElseCache)

let object = SynergykitObject(collection: "target-collection", _id: "object-id")
object.cache = cache

object.fetch {
    (result : SResponse!) -> Void in
    // Handle result
}

缓存数据的过期

SCacheTypeCacheElseLoad 和 SCacheTypeLoadElseCache 支持过期间隔。过期后，缓存数据将失效。

// One hour expiration
SCache *cache = [[SCache alloc] initWithType:SCacheTypeCacheElseLoad expiration:60*60]; 

// One hour expiration
let cache = SKCache(type: .CacheElseLoad, expiration: 60*60)

变更日志

版本 2.1.0 (22. 4. 2015)

• SynergyKit v2.1 支持
• 文档
• 实时数据观察
• 查询
• 用户
• 平台
• 角色
• 通讯
• 文件
• 云代码
• 请求分批处理
• 高级缓存策略

作者

Letsgood.com s.r.o., 捷克共和国，欧洲心脏地区 — Etnetera 集团的一部分。

[email protected]，http://letsgood.com/en

许可证

Synergykit iOS SDK 适用于 MIT 许可证。有关更多信息，请参阅 LICENSE 文件。