2 * Copyright (c) 2015 Samsung Electronics Co., Ltd All Rights Reserved
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
8 * http://www.apache.org/licenses/LICENSE-2.0
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
17 #include "calendar/calendar_instance.h"
19 #include "common/converter.h"
21 #include "calendar/calendar.h"
22 #include "calendar/calendar_manager.h"
23 #include "common/task-queue.h"
24 #include "common/tools.h"
26 #include <calendar-service2/calendar.h>
29 #include "calendar_record.h"
35 const std::string kPrivilegeCalendarRead = "http://tizen.org/privilege/calendar.read";
36 const std::string kPrivilegeCalendarWrite = "http://tizen.org/privilege/calendar.write";
39 using namespace common;
40 using namespace extension::calendar;
42 CalendarInstance::CalendarInstance() : calendar_(*this) {
44 using std::placeholders::_1;
45 using std::placeholders::_2;
47 #define REGISTER_METHOD(M) \
48 RegisterSyncHandler(#M, std::bind(&CalendarInstance::M, this, _1, _2))
50 REGISTER_METHOD(CalendarGet);
51 REGISTER_METHOD(CalendarAdd);
52 REGISTER_METHOD(CalendarUpdate);
53 REGISTER_METHOD(CalendarRemove);
54 REGISTER_METHOD(CalendarAddChangeListener);
55 REGISTER_METHOD(CalendarRemoveChangeListener);
57 REGISTER_METHOD(CalendarManagerAddCalendar);
58 REGISTER_METHOD(CalendarManagerGetCalendar);
59 REGISTER_METHOD(CalendarManagerRemoveCalendar);
61 REGISTER_METHOD(CalendarAddBatch);
62 REGISTER_METHOD(CalendarUpdateBatch);
63 REGISTER_METHOD(CalendarRemoveBatch);
64 REGISTER_METHOD(CalendarUpdateBatch);
65 REGISTER_METHOD(CalendarManagerGetCalendars);
66 REGISTER_METHOD(CalendarFind);
68 #undef REGISTER_METHOD
71 CalendarInstance::~CalendarInstance() {
75 void CalendarInstance::CalendarGet(const JsonValue& args, JsonObject& out) {
77 CHECK_PRIVILEGE_ACCESS(kPrivilegeCalendarRead, &out);
79 JsonValue val{JsonObject{}};
81 PlatformResult status = calendar_.Get(common::JsonCast<JsonObject>(args), val.get<JsonObject>());
83 if (status.IsSuccess()) {
84 ReportSuccess(val, out);
86 LogAndReportError(status, &out);
90 void CalendarInstance::CalendarAdd(const JsonValue& args, JsonObject& out) {
92 CHECK_PRIVILEGE_ACCESS(kPrivilegeCalendarWrite, &out);
94 JsonValue val{JsonObject{}};
96 PlatformResult status = calendar_.Add(common::JsonCast<JsonObject>(args), val.get<JsonObject>());
98 if (status.IsSuccess()) {
99 ReportSuccess(val, out);
101 LogAndReportError(status, &out);
105 void CalendarInstance::CalendarAddBatch(const JsonValue& args, JsonObject& out) {
107 CHECK_PRIVILEGE_ACCESS(kPrivilegeCalendarWrite, &out);
109 const double callback_id = args.get("callbackId").get<double>();
110 auto get = [=](const std::shared_ptr<JsonValue>& response) -> void {
111 LoggerD("CalendarAddBatch->get");
112 JsonValue result = JsonValue(JsonArray());
113 PlatformResult status =
114 calendar_.AddBatch(common::JsonCast<JsonObject>(args), result.get<JsonArray>());
116 if (status.IsSuccess()) {
117 ReportSuccess(result, response->get<picojson::object>());
119 LogAndReportError(status, &response->get<picojson::object>());
123 auto get_response = [callback_id, this](const std::shared_ptr<JsonValue>& response) -> void {
124 ScopeLogger("Entered into asynchronous function, CalendarAddBatch->get_response");
125 picojson::object& obj = response->get<picojson::object>();
126 obj.insert(std::make_pair("callbackId", picojson::value(callback_id)));
127 LoggerD("callback is %s", response->serialize().c_str());
128 Instance::PostMessage(this, response->serialize().c_str());
131 auto data = std::shared_ptr<JsonValue>(new JsonValue(JsonObject()));
133 TaskQueue::GetInstance().Queue<JsonValue>(get, get_response, data);
136 void CalendarInstance::CalendarUpdate(const JsonValue& args, JsonObject& out) {
138 CHECK_PRIVILEGE_ACCESS(kPrivilegeCalendarWrite, &out);
140 JsonValue val{JsonObject{}};
142 PlatformResult status =
143 calendar_.Update(common::JsonCast<JsonObject>(args), val.get<JsonObject>());
145 if (status.IsSuccess()) {
146 ReportSuccess(val, out);
148 LogAndReportError(status, &out);
152 void CalendarInstance::CalendarUpdateBatch(const JsonValue& args, JsonObject& out) {
154 CHECK_PRIVILEGE_ACCESS(kPrivilegeCalendarWrite, &out);
156 const double callback_id = args.get("callbackId").get<double>();
157 auto get = [=](const std::shared_ptr<JsonValue>& response) -> void {
158 ScopeLogger("Entered into asynchronous function, CalendarUpdateBatch->get");
160 JsonValue result = JsonValue(JsonArray());
161 PlatformResult status =
162 calendar_.UpdateBatch(common::JsonCast<JsonObject>(args), result.get<JsonArray>());
164 if (status.IsSuccess()) {
165 ReportSuccess(result, response->get<picojson::object>());
167 LogAndReportError(status, &response->get<picojson::object>());
171 auto get_response = [callback_id, this](const std::shared_ptr<JsonValue>& response) -> void {
172 ScopeLogger("Entered into asynchronous function, CalendarUpdateBatch->get_response");
174 picojson::object& obj = response->get<picojson::object>();
175 obj.insert(std::make_pair("callbackId", picojson::value(callback_id)));
176 LoggerD("callback is %s", response->serialize().c_str());
177 Instance::PostMessage(this, response->serialize().c_str());
180 auto data = std::shared_ptr<JsonValue>(new JsonValue(JsonObject()));
182 TaskQueue::GetInstance().Queue<JsonValue>(get, get_response, data);
185 void CalendarInstance::CalendarRemove(const JsonValue& args, JsonObject& out) {
187 CHECK_PRIVILEGE_ACCESS(kPrivilegeCalendarWrite, &out);
189 JsonValue val{JsonObject{}};
191 PlatformResult status =
192 calendar_.Remove(common::JsonCast<JsonObject>(args), val.get<JsonObject>());
194 if (status.IsSuccess()) {
197 LogAndReportError(status, &val.get<JsonObject>());
201 void CalendarInstance::CalendarRemoveBatch(const JsonValue& args, JsonObject& out) {
203 CHECK_PRIVILEGE_ACCESS(kPrivilegeCalendarWrite, &out);
205 const double callback_id = args.get("callbackId").get<double>();
206 auto get = [=](const std::shared_ptr<JsonValue>& response) -> void {
207 ScopeLogger("Entered into asynchronous function, CalendarRemoveBatch->get");
209 JsonValue result = JsonValue(JsonArray());
210 PlatformResult status =
211 calendar_.RemoveBatch(common::JsonCast<JsonObject>(args), result.get<JsonArray>());
213 if (status.IsSuccess()) {
214 ReportSuccess(result, response->get<picojson::object>());
216 LogAndReportError(status, &response->get<picojson::object>());
220 auto get_response = [callback_id, this](const std::shared_ptr<JsonValue>& response) -> void {
221 ScopeLogger("Entered into asynchronous function, CalendarRemoveBatch->get_response");
223 picojson::object& obj = response->get<picojson::object>();
224 obj.insert(std::make_pair("callbackId", picojson::value(callback_id)));
225 LoggerD("callback is %s", response->serialize().c_str());
226 Instance::PostMessage(this, response->serialize().c_str());
229 auto data = std::shared_ptr<JsonValue>(new JsonValue(JsonObject()));
231 TaskQueue::GetInstance().Queue<JsonValue>(get, get_response, data);
234 void CalendarInstance::CalendarFind(const JsonValue& args, JsonObject& out) {
236 CHECK_PRIVILEGE_ACCESS(kPrivilegeCalendarRead, &out);
238 const double callback_id = args.get("callbackId").get<double>();
239 auto get = [=](const std::shared_ptr<JsonValue>& response) -> void {
240 ScopeLogger("Entered into asynchronous function, CalendarFind->get");
242 JsonValue result = JsonValue(JsonArray());
243 PlatformResult status =
244 calendar_.Find(common::JsonCast<JsonObject>(args), result.get<JsonArray>());
246 if (status.IsSuccess()) {
247 ReportSuccess(result, response->get<picojson::object>());
249 LogAndReportError(status, &response->get<picojson::object>());
253 auto get_response = [callback_id, this](const std::shared_ptr<JsonValue>& response) -> void {
254 ScopeLogger("Entered into asynchronous function, CalendarFind->get_response");
256 picojson::object& obj = response->get<picojson::object>();
257 obj.insert(std::make_pair("callbackId", picojson::value(callback_id)));
258 LoggerD("callback is %s", response->serialize().c_str());
259 Instance::PostMessage(this, response->serialize().c_str());
262 auto data = std::shared_ptr<JsonValue>(new JsonValue(JsonObject()));
264 TaskQueue::GetInstance().Queue<JsonValue>(get, get_response, data);
267 void CalendarInstance::CalendarAddChangeListener(const JsonValue& args, JsonObject& out) {
269 CHECK_PRIVILEGE_ACCESS(kPrivilegeCalendarRead, &out);
271 JsonValue val{JsonObject{}};
273 PlatformResult status =
274 calendar_.AddChangeListener(common::JsonCast<JsonObject>(args), val.get<JsonObject>());
276 if (status.IsSuccess()) {
279 LogAndReportError(status, &val.get<JsonObject>());
283 void CalendarInstance::CalendarRemoveChangeListener(const JsonValue& args, JsonObject& out) {
285 CHECK_PRIVILEGE_ACCESS(kPrivilegeCalendarRead, &out);
287 JsonValue val{JsonObject{}};
289 PlatformResult status =
290 calendar_.RemoveChangeListener(common::JsonCast<JsonObject>(args), val.get<JsonObject>());
292 if (status.IsSuccess()) {
295 LogAndReportError(status, &val.get<JsonObject>());
300 void CalendarInstance::CalendarManagerAddCalendar(const JsonValue& args, JsonObject& out) {
302 CHECK_PRIVILEGE_ACCESS(kPrivilegeCalendarWrite, &out);
304 JsonValue val{JsonObject{}};
305 PlatformResult status = CalendarManager::GetInstance().AddCalendar(
306 common::JsonCast<JsonObject>(args), val.get<JsonObject>());
308 if (status.IsSuccess()) {
309 ReportSuccess(val, out);
311 LogAndReportError(status, &out);
315 void CalendarInstance::CalendarManagerGetCalendar(const JsonValue& args, JsonObject& out) {
317 CHECK_PRIVILEGE_ACCESS(kPrivilegeCalendarRead, &out);
319 JsonValue val{JsonObject{}};
320 PlatformResult status = CalendarManager::GetInstance().GetCalendar(
321 common::JsonCast<JsonObject>(args), val.get<JsonObject>());
323 if (status.IsSuccess()) {
324 ReportSuccess(val, out);
326 LogAndReportError(status, &out);
330 void CalendarInstance::CalendarManagerGetCalendars(const JsonValue& args, JsonObject& out) {
332 CHECK_PRIVILEGE_ACCESS(kPrivilegeCalendarRead, &out);
334 const double callback_id = args.get("callbackId").get<double>();
335 auto get = [=](const std::shared_ptr<JsonValue>& response) -> void {
336 ScopeLogger("Entered into asynchronous function, CalendarManagerGetCalendars->get");
338 JsonValue result = JsonValue(JsonArray());
340 PlatformResult status = CalendarManager::GetInstance().GetCalendars(
341 common::JsonCast<JsonObject>(args), result.get<JsonArray>());
343 if (status.IsSuccess()) {
344 ReportSuccess(result, response->get<picojson::object>());
346 LogAndReportError(status, &response->get<JsonObject>());
350 auto get_response = [callback_id, this](const std::shared_ptr<JsonValue>& response) -> void {
351 ScopeLogger("Entered into asynchronous function, CalendarManagerGetCalendars->get_response");
353 picojson::object& obj = response->get<picojson::object>();
354 obj.insert(std::make_pair("callbackId", picojson::value(callback_id)));
355 LoggerD("callback is %s", response->serialize().c_str());
356 Instance::PostMessage(this, response->serialize().c_str());
359 auto data = std::shared_ptr<JsonValue>(new JsonValue(JsonObject()));
361 TaskQueue::GetInstance().Queue<JsonValue>(get, get_response, data);
364 void CalendarInstance::CalendarManagerRemoveCalendar(const JsonValue& args, JsonObject& out) {
366 CHECK_PRIVILEGE_ACCESS(kPrivilegeCalendarWrite, &out);
368 JsonValue val{JsonObject{}};
369 PlatformResult status = CalendarManager::GetInstance().RemoveCalendar(
370 common::JsonCast<JsonObject>(args), val.get<JsonObject>());
372 if (status.IsSuccess()) {
373 ReportSuccess(val, out);
375 LogAndReportError(status, &out);
379 } // namespace calendar
380 } // namespace extension