1 /*
2  * Copyright (c) 2021 Huawei Device Co., Ltd.
3  * Licensed under the Apache License, Version 2.0 (the "License");
4  * you may not use this file except in compliance with the License.
5  * You may obtain a copy of the License at
6  *
7  *     http://www.apache.org/licenses/LICENSE-2.0
8  *
9  * Unless required by applicable law or agreed to in writing, software
10  * distributed under the License is distributed on an "AS IS" BASIS,
11  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12  * See the License for the specific language governing permissions and
13  * limitations under the License.
14  */
15 #define LOG_TAG "DataAbilityPredicatesProxy"
16 #include "napi_data_ability_predicates.h"
17 
18 #include "js_utils.h"
19 #include "logger.h"
20 #include "napi_async_proxy.h"
21 #include "napi_predicates_utils.h"
22 
23 using namespace OHOS::Rdb;
24 using namespace OHOS::NativeRdb;
25 using namespace OHOS::AppDataMgrJsKit;
26 
27 namespace OHOS {
28 namespace DataAbilityJsKit {
29 static __thread napi_ref constructor_ = nullptr;
30 
Init(napi_env env,napi_value exports)31 void DataAbilityPredicatesProxy::Init(napi_env env, napi_value exports)
32 {
33     LOG_INFO("Init DataAbilityPredicatesProxy");
34     napi_property_descriptor descriptors[] = {
35         DECLARE_NAPI_FUNCTION("equalTo", EqualTo),
36         DECLARE_NAPI_FUNCTION("notEqualTo", NotEqualTo),
37         DECLARE_NAPI_FUNCTION("beginWrap", BeginWrap),
38         DECLARE_NAPI_FUNCTION("endWrap", EndWrap),
39         DECLARE_NAPI_FUNCTION("or", Or),
40         DECLARE_NAPI_FUNCTION("and", And),
41         DECLARE_NAPI_FUNCTION("contains", Contains),
42         DECLARE_NAPI_FUNCTION("beginsWith", BeginsWith),
43         DECLARE_NAPI_FUNCTION("endsWith", EndsWith),
44         DECLARE_NAPI_FUNCTION("isNull", IsNull),
45         DECLARE_NAPI_FUNCTION("isNotNull", IsNotNull),
46         DECLARE_NAPI_FUNCTION("like", Like),
47         DECLARE_NAPI_FUNCTION("glob", Glob),
48         DECLARE_NAPI_FUNCTION("between", Between),
49         DECLARE_NAPI_FUNCTION("notBetween", NotBetween),
50         DECLARE_NAPI_FUNCTION("greaterThan", GreaterThan),
51         DECLARE_NAPI_FUNCTION("lessThan", LessThan),
52         DECLARE_NAPI_FUNCTION("greaterThanOrEqualTo", GreaterThanOrEqualTo),
53         DECLARE_NAPI_FUNCTION("lessThanOrEqualTo", LessThanOrEqualTo),
54         DECLARE_NAPI_FUNCTION("orderByAsc", OrderByAsc),
55         DECLARE_NAPI_FUNCTION("orderByDesc", OrderByDesc),
56         DECLARE_NAPI_FUNCTION("distinct", Distinct),
57         DECLARE_NAPI_FUNCTION("limitAs", Limit),
58         DECLARE_NAPI_FUNCTION("offsetAs", Offset),
59         DECLARE_NAPI_FUNCTION("groupBy", GroupBy),
60         DECLARE_NAPI_FUNCTION("indexedBy", IndexedBy),
61         DECLARE_NAPI_FUNCTION("in", In),
62         DECLARE_NAPI_FUNCTION("notIn", NotIn),
63         DECLARE_NAPI_FUNCTION("clear", Clear),
64         DECLARE_NAPI_FUNCTION("isRawSelection", IsRawSelection),
65         DECLARE_NAPI_GETTER_SETTER("whereClause", GetWhereClause, SetWhereClause),
66         DECLARE_NAPI_GETTER_SETTER("whereArgs", GetWhereArgs, SetWhereArgs),
67         DECLARE_NAPI_GETTER_SETTER("order", GetOrder, SetOrder),
68         DECLARE_NAPI_GETTER("limit", GetLimit),
69         DECLARE_NAPI_GETTER("offset", GetOffset),
70         DECLARE_NAPI_GETTER("isDistinct", IsDistinct),
71         DECLARE_NAPI_GETTER("group", GetGroup),
72         DECLARE_NAPI_GETTER("index", GetIndex),
73         DECLARE_NAPI_GETTER("isNeedAnd", IsNeedAnd),
74         DECLARE_NAPI_GETTER("isSorted", IsSorted),
75     };
76 
77     napi_value cons = nullptr;
78     NAPI_CALL_RETURN_VOID(env, napi_define_class(env, "DataAbilityPredicates", NAPI_AUTO_LENGTH, New, nullptr,
79                                    sizeof(descriptors) / sizeof(napi_property_descriptor), descriptors, &cons));
80 
81     NAPI_CALL_RETURN_VOID(env, napi_create_reference(env, cons, 1, &constructor_));
82 
83     NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, exports, "DataAbilityPredicates", cons));
84 }
85 
New(napi_env env,napi_callback_info info)86 napi_value DataAbilityPredicatesProxy::New(napi_env env, napi_callback_info info)
87 {
88     napi_value new_target = nullptr;
89     NAPI_CALL(env, napi_get_new_target(env, info, &new_target));
90     bool is_constructor = (new_target != nullptr);
91 
92     napi_value thiz = nullptr;
93     NAPI_CALL(env, napi_get_cb_info(env, info, nullptr, nullptr, &thiz, nullptr));
94 
95     if (is_constructor) {
96         auto *proxy = new (std::nothrow) DataAbilityPredicatesProxy();
97         if (proxy == nullptr) {
98             LOG_ERROR("DataAbilityPredicatesProxy::New new failed, proxy is nullptr.");
99             return nullptr;
100         }
101         napi_status status = napi_wrap(env, thiz, proxy, DataAbilityPredicatesProxy::Destructor, nullptr, nullptr);
102         if (status != napi_ok) {
103             LOG_ERROR("DataAbilityPredicatesProxy::New napi_wrap failed! napi_status:%{public}d!", status);
104             delete proxy;
105             return nullptr;
106         }
107         return thiz;
108     }
109 
110     napi_value cons = nullptr;
111     NAPI_CALL(env, napi_get_reference_value(env, constructor_, &cons));
112 
113     napi_value output = nullptr;
114     NAPI_CALL(env, napi_new_instance(env, cons, 0, nullptr, &output));
115 
116     return output;
117 }
118 
NewInstance(napi_env env,std::shared_ptr<NativeRdb::DataAbilityPredicates> value)119 napi_value DataAbilityPredicatesProxy::NewInstance(
120     napi_env env, std::shared_ptr<NativeRdb::DataAbilityPredicates> value)
121 {
122     napi_value cons = nullptr;
123     napi_status status = napi_get_reference_value(env, constructor_, &cons);
124     if (status != napi_ok) {
125         LOG_ERROR("DataAbilityPredicatesProxy get constructor failed! napi_status:%{public}d!", status);
126         return nullptr;
127     }
128 
129     napi_value instance = nullptr;
130     status = napi_new_instance(env, cons, 0, nullptr, &instance);
131     if (status != napi_ok) {
132         LOG_ERROR("DataAbilityPredicatesProxy napi_new_instance failed! napi_status:%{public}d!", status);
133         return nullptr;
134     }
135 
136     DataAbilityPredicatesProxy *proxy = nullptr;
137     status = napi_unwrap(env, instance, reinterpret_cast<void **>(&proxy));
138     if (status != napi_ok) {
139         LOG_ERROR("DataAbilityPredicatesProxy native instance is nullptr! napi_status:%{public}d!", status);
140         return instance;
141     }
142     proxy->predicates_ = std::move(value);
143     return instance;
144 }
145 
GetNativePredicates(const napi_env env,const napi_value arg)146 std::shared_ptr<NativeRdb::DataAbilityPredicates> DataAbilityPredicatesProxy::GetNativePredicates(
147     const napi_env env, const napi_value arg)
148 {
149     if (arg == nullptr) {
150         LOG_ERROR("DataAbilityPredicatesProxy arg is null.");
151         return nullptr;
152     }
153     DataAbilityPredicatesProxy *proxy = nullptr;
154     napi_unwrap(env, arg, reinterpret_cast<void **>(&proxy));
155     if (proxy == nullptr) {
156         LOG_ERROR("DataAbilityPredicatesProxy proxy is null.");
157         return nullptr;
158     }
159     return proxy->predicates_;
160 }
161 
Destructor(napi_env env,void * nativeObject,void *)162 void DataAbilityPredicatesProxy::Destructor(napi_env env, void *nativeObject, void *)
163 {
164     DataAbilityPredicatesProxy *proxy = static_cast<DataAbilityPredicatesProxy *>(nativeObject);
165     delete proxy;
166 }
167 
~DataAbilityPredicatesProxy()168 DataAbilityPredicatesProxy::~DataAbilityPredicatesProxy()
169 {
170 }
171 
DataAbilityPredicatesProxy()172 DataAbilityPredicatesProxy::DataAbilityPredicatesProxy() : predicates_(new DataAbilityPredicates())
173 {
174 }
175 
GetNativePredicates(napi_env env,napi_callback_info info)176 std::shared_ptr<NativeRdb::DataAbilityPredicates> DataAbilityPredicatesProxy::GetNativePredicates(
177     napi_env env, napi_callback_info info)
178 {
179     DataAbilityPredicatesProxy *predicatesProxy = nullptr;
180     napi_value thiz = nullptr;
181     napi_get_cb_info(env, info, nullptr, nullptr, &thiz, nullptr);
182     napi_unwrap(env, thiz, reinterpret_cast<void **>(&predicatesProxy));
183     if (predicatesProxy == nullptr) {
184         return nullptr;
185     }
186     return predicatesProxy->predicates_;
187 }
188 
EqualTo(napi_env env,napi_callback_info info)189 napi_value DataAbilityPredicatesProxy::EqualTo(napi_env env, napi_callback_info info)
190 {
191     napi_value thiz = nullptr;
192     size_t argc = 2;
193     napi_value args[2] = { 0 };
194     napi_get_cb_info(env, info, &argc, args, &thiz, nullptr);
195     NAPI_ASSERT(env, argc > 0, "DataAbilityPredicatesProxy::EqualTo Invalid argvs!");
196     std::string field;
197     RDB_CHECK_RETURN_NULLPTR(JSUtils::Convert2Value(env, args[0], field) == napi_ok, "the field is invalid");
198     ValueObject value;
199     RDB_CHECK_RETURN_NULLPTR(JSUtils::Convert2Value(env, args[1], value) == napi_ok, "the value is invalid");
200     auto nativePredicates = GetNativePredicates(env, info);
201     RDB_CHECK_RETURN_NULLPTR(nativePredicates != nullptr, "GetNativePredicates return nullptr");
202     nativePredicates->EqualTo(field, value);
203     return thiz;
204 }
205 
NotEqualTo(napi_env env,napi_callback_info info)206 napi_value DataAbilityPredicatesProxy::NotEqualTo(napi_env env, napi_callback_info info)
207 {
208     napi_value thiz = nullptr;
209     size_t argc = 2;
210     napi_value args[2] = { 0 };
211     napi_get_cb_info(env, info, &argc, args, &thiz, nullptr);
212     NAPI_ASSERT(env, argc > 0, "DataAbilityPredicatesProxy::NotEqualTo Invalid argvs!");
213     std::string field;
214     RDB_CHECK_RETURN_NULLPTR(JSUtils::Convert2Value(env, args[0], field) == napi_ok, "the field is invalid");
215     ValueObject value;
216     RDB_CHECK_RETURN_NULLPTR(JSUtils::Convert2Value(env, args[1], value) == napi_ok, "the value is invalid");
217     auto nativePredicates = GetNativePredicates(env, info);
218     RDB_CHECK_RETURN_NULLPTR(nativePredicates != nullptr, "GetNativePredicates return nullptr");
219     nativePredicates->NotEqualTo(field, value);
220     return thiz;
221 }
222 
BeginWrap(napi_env env,napi_callback_info info)223 napi_value DataAbilityPredicatesProxy::BeginWrap(napi_env env, napi_callback_info info)
224 {
225     napi_value thiz = nullptr;
226     napi_get_cb_info(env, info, nullptr, nullptr, &thiz, nullptr);
227     auto nativePredicates = GetNativePredicates(env, info);
228     RDB_CHECK_RETURN_NULLPTR(nativePredicates != nullptr, "GetNativePredicates return nullptr");
229     nativePredicates->BeginWrap();
230     return thiz;
231 }
232 
EndWrap(napi_env env,napi_callback_info info)233 napi_value DataAbilityPredicatesProxy::EndWrap(napi_env env, napi_callback_info info)
234 {
235     napi_value thiz = nullptr;
236     napi_get_cb_info(env, info, nullptr, nullptr, &thiz, nullptr);
237     auto nativePredicates = GetNativePredicates(env, info);
238     RDB_CHECK_RETURN_NULLPTR(nativePredicates != nullptr, "GetNativePredicates return nullptr");
239     nativePredicates->EndWrap();
240     return thiz;
241 }
242 
Or(napi_env env,napi_callback_info info)243 napi_value DataAbilityPredicatesProxy::Or(napi_env env, napi_callback_info info)
244 {
245     napi_value thiz = nullptr;
246     napi_get_cb_info(env, info, nullptr, nullptr, &thiz, nullptr);
247     auto nativePredicates = GetNativePredicates(env, info);
248     RDB_CHECK_RETURN_NULLPTR(nativePredicates != nullptr, "GetNativePredicates return nullptr");
249     nativePredicates->Or();
250     return thiz;
251 }
252 
And(napi_env env,napi_callback_info info)253 napi_value DataAbilityPredicatesProxy::And(napi_env env, napi_callback_info info)
254 {
255     napi_value thiz = nullptr;
256     napi_get_cb_info(env, info, nullptr, nullptr, &thiz, nullptr);
257     auto nativePredicates = GetNativePredicates(env, info);
258     RDB_CHECK_RETURN_NULLPTR(nativePredicates != nullptr, "GetNativePredicates return nullptr");
259     nativePredicates->And();
260     return thiz;
261 }
262 
Contains(napi_env env,napi_callback_info info)263 napi_value DataAbilityPredicatesProxy::Contains(napi_env env, napi_callback_info info)
264 {
265     napi_value thiz = nullptr;
266     size_t argc = 2;
267     napi_value args[2] = { 0 };
268     napi_get_cb_info(env, info, &argc, args, &thiz, nullptr);
269     NAPI_ASSERT(env, argc > 0, "DataAbilityPredicatesProxy::Contains Invalid argvs!");
270     std::string field;
271     RDB_CHECK_RETURN_NULLPTR(JSUtils::Convert2Value(env, args[0], field) == napi_ok, "the field is invalid");
272     std::string value;
273     RDB_CHECK_RETURN_NULLPTR(JSUtils::Convert2Value(env, args[1], value) == napi_ok, "the value is invalid");
274     auto nativePredicates = GetNativePredicates(env, info);
275     RDB_CHECK_RETURN_NULLPTR(nativePredicates != nullptr, "GetNativePredicates return nullptr");
276     nativePredicates->Contains(field, value);
277     return thiz;
278 }
279 
BeginsWith(napi_env env,napi_callback_info info)280 napi_value DataAbilityPredicatesProxy::BeginsWith(napi_env env, napi_callback_info info)
281 {
282     napi_value thiz = nullptr;
283     size_t argc = 2;
284     napi_value args[2] = { 0 };
285     napi_get_cb_info(env, info, &argc, args, &thiz, nullptr);
286     NAPI_ASSERT(env, argc > 0, "DataAbilityPredicatesProxy::BeginsWith Invalid argvs!");
287     std::string field;
288     RDB_CHECK_RETURN_NULLPTR(JSUtils::Convert2Value(env, args[0], field) == napi_ok, "the field is invalid");
289     std::string value;
290     RDB_CHECK_RETURN_NULLPTR(JSUtils::Convert2Value(env, args[1], value) == napi_ok, "the value is invalid");
291     auto nativePredicates = GetNativePredicates(env, info);
292     RDB_CHECK_RETURN_NULLPTR(nativePredicates != nullptr, "GetNativePredicates return nullptr");
293     nativePredicates->BeginsWith(field, value);
294     return thiz;
295 }
296 
EndsWith(napi_env env,napi_callback_info info)297 napi_value DataAbilityPredicatesProxy::EndsWith(napi_env env, napi_callback_info info)
298 {
299     napi_value thiz = nullptr;
300     size_t argc = 2;
301     napi_value args[2] = { 0 };
302     napi_get_cb_info(env, info, &argc, args, &thiz, nullptr);
303     NAPI_ASSERT(env, argc > 0, "DataAbilityPredicatesProxy::EndsWith Invalid argvs!");
304     std::string field;
305     RDB_CHECK_RETURN_NULLPTR(JSUtils::Convert2Value(env, args[0], field) == napi_ok, "the field is invalid");
306     std::string value;
307     RDB_CHECK_RETURN_NULLPTR(JSUtils::Convert2Value(env, args[1], value) == napi_ok, "the value is invalid");
308     auto nativePredicates = GetNativePredicates(env, info);
309     RDB_CHECK_RETURN_NULLPTR(nativePredicates != nullptr, "GetNativePredicates return nullptr");
310     nativePredicates->EndsWith(field, value);
311     return thiz;
312 }
313 
IsNull(napi_env env,napi_callback_info info)314 napi_value DataAbilityPredicatesProxy::IsNull(napi_env env, napi_callback_info info)
315 {
316     napi_value thiz = nullptr;
317     size_t argc = 1;
318     napi_value args[1] = { 0 };
319     napi_get_cb_info(env, info, &argc, args, &thiz, nullptr);
320     NAPI_ASSERT(env, argc > 0, "DataAbilityPredicatesProxy::IsNull Invalid argvs!");
321     std::string field;
322     RDB_CHECK_RETURN_NULLPTR(JSUtils::Convert2Value(env, args[0], field) == napi_ok, "the field is invalid");
323     auto nativePredicates = GetNativePredicates(env, info);
324     RDB_CHECK_RETURN_NULLPTR(nativePredicates != nullptr, "GetNativePredicates return nullptr");
325     nativePredicates->IsNull(field);
326     return thiz;
327 }
328 
IsNotNull(napi_env env,napi_callback_info info)329 napi_value DataAbilityPredicatesProxy::IsNotNull(napi_env env, napi_callback_info info)
330 {
331     napi_value thiz = nullptr;
332     size_t argc = 1;
333     napi_value args[1] = { 0 };
334     napi_get_cb_info(env, info, &argc, args, &thiz, nullptr);
335     NAPI_ASSERT(env, argc > 0, "DataAbilityPredicatesProxy::IsNotNull Invalid argvs!");
336     std::string field;
337     RDB_CHECK_RETURN_NULLPTR(JSUtils::Convert2Value(env, args[0], field) == napi_ok, "the field is invalid");
338     auto nativePredicates = GetNativePredicates(env, info);
339     RDB_CHECK_RETURN_NULLPTR(nativePredicates != nullptr, "GetNativePredicates return nullptr");
340     nativePredicates->IsNotNull(field);
341     return thiz;
342 }
343 
Like(napi_env env,napi_callback_info info)344 napi_value DataAbilityPredicatesProxy::Like(napi_env env, napi_callback_info info)
345 {
346     napi_value thiz = nullptr;
347     size_t argc = 2;
348     napi_value args[2] = { 0 };
349     napi_get_cb_info(env, info, &argc, args, &thiz, nullptr);
350     NAPI_ASSERT(env, argc > 0, "DataAbilityPredicatesProxy::Like Invalid argvs!");
351     std::string field;
352     RDB_CHECK_RETURN_NULLPTR(JSUtils::Convert2Value(env, args[0], field) == napi_ok, "the field is invalid");
353     std::string value;
354     RDB_CHECK_RETURN_NULLPTR(JSUtils::Convert2Value(env, args[1], value) == napi_ok, "the value is invalid");
355     auto nativePredicates = GetNativePredicates(env, info);
356     RDB_CHECK_RETURN_NULLPTR(nativePredicates != nullptr, "GetNativePredicates return nullptr");
357     nativePredicates->Like(field, value);
358     return thiz;
359 }
360 
Glob(napi_env env,napi_callback_info info)361 napi_value DataAbilityPredicatesProxy::Glob(napi_env env, napi_callback_info info)
362 {
363     napi_value thiz = nullptr;
364     size_t argc = 2;
365     napi_value args[2] = { 0 };
366     napi_get_cb_info(env, info, &argc, args, &thiz, nullptr);
367     NAPI_ASSERT(env, argc > 0, "DataAbilityPredicatesProxy::Glob Invalid argvs!");
368     std::string field;
369     RDB_CHECK_RETURN_NULLPTR(JSUtils::Convert2Value(env, args[0], field) == napi_ok, "the field is invalid");
370     std::string value;
371     RDB_CHECK_RETURN_NULLPTR(JSUtils::Convert2Value(env, args[1], value) == napi_ok, "the value is invalid");
372     auto nativePredicates = GetNativePredicates(env, info);
373     RDB_CHECK_RETURN_NULLPTR(nativePredicates != nullptr, "GetNativePredicates return nullptr");
374     nativePredicates->Glob(field, value);
375     return thiz;
376 }
377 
Between(napi_env env,napi_callback_info info)378 napi_value DataAbilityPredicatesProxy::Between(napi_env env, napi_callback_info info)
379 {
380     napi_value thiz = nullptr;
381     size_t argc = 3;
382     // 3 represents the number of parameters
383     napi_value args[3] = { 0 };
384     napi_get_cb_info(env, info, &argc, args, &thiz, nullptr);
385     NAPI_ASSERT(env, argc > 0, "DataAbilityPredicatesProxy::Between Invalid argvs!");
386     std::string field;
387     // args[0] represents the first parameter
388     RDB_CHECK_RETURN_NULLPTR(JSUtils::Convert2Value(env, args[0], field) == napi_ok, "the field is invalid");
389     ValueObject low;
390     // args[1] represents the second parameter
391     JSUtils::Convert2Value(env, args[1], low);
392     ValueObject high;
393     // args[2] represents the third parameter
394     JSUtils::Convert2Value(env, args[2], high);
395     auto nativePredicates = GetNativePredicates(env, info);
396     RDB_CHECK_RETURN_NULLPTR(nativePredicates != nullptr, "GetNativePredicates return nullptr");
397     nativePredicates->Between(field, low, high);
398     return thiz;
399 }
400 
NotBetween(napi_env env,napi_callback_info info)401 napi_value DataAbilityPredicatesProxy::NotBetween(napi_env env, napi_callback_info info)
402 {
403     napi_value thiz = nullptr;
404     size_t argc = 3;
405     // 3 represents the number of parameters
406     napi_value args[3] = { 0 };
407     napi_get_cb_info(env, info, &argc, args, &thiz, nullptr);
408     NAPI_ASSERT(env, argc > 0, "DataAbilityPredicatesProxy::NotBetween Invalid argvs!");
409     std::string field;
410     // args[0] represents the first parameter
411     RDB_CHECK_RETURN_NULLPTR(JSUtils::Convert2Value(env, args[0], field) == napi_ok, "the field is invalid");
412     ValueObject low;
413     // args[1] represents the second parameter
414     JSUtils::Convert2Value(env, args[1], low);
415     ValueObject high;
416     // args[2] represents the third parameter
417     JSUtils::Convert2Value(env, args[2], high);
418     auto nativePredicates = GetNativePredicates(env, info);
419     RDB_CHECK_RETURN_NULLPTR(nativePredicates != nullptr, "GetNativePredicates return nullptr");
420     nativePredicates->NotBetween(field, low, high);
421     return thiz;
422 }
423 
GreaterThan(napi_env env,napi_callback_info info)424 napi_value DataAbilityPredicatesProxy::GreaterThan(napi_env env, napi_callback_info info)
425 {
426     napi_value thiz = nullptr;
427     size_t argc = 2;
428     napi_value args[2] = { 0 };
429     napi_get_cb_info(env, info, &argc, args, &thiz, nullptr);
430     NAPI_ASSERT(env, argc > 0, "DataAbilityPredicatesProxy::GreaterThan Invalid argvs!");
431     std::string field;
432     RDB_CHECK_RETURN_NULLPTR(JSUtils::Convert2Value(env, args[0], field) == napi_ok, "the field is invalid");
433     ValueObject value;
434     RDB_CHECK_RETURN_NULLPTR(JSUtils::Convert2Value(env, args[1], value) == napi_ok, "the value is invalid");
435     auto nativePredicates = GetNativePredicates(env, info);
436     RDB_CHECK_RETURN_NULLPTR(nativePredicates != nullptr, "GetNativePredicates return nullptr");
437     nativePredicates->GreaterThan(field, value);
438     return thiz;
439 }
440 
LessThan(napi_env env,napi_callback_info info)441 napi_value DataAbilityPredicatesProxy::LessThan(napi_env env, napi_callback_info info)
442 {
443     napi_value thiz = nullptr;
444     size_t argc = 2;
445     napi_value args[2] = { 0 };
446     napi_get_cb_info(env, info, &argc, args, &thiz, nullptr);
447     NAPI_ASSERT(env, argc > 0, "DataAbilityPredicatesProxy::LessThan Invalid argvs!");
448     std::string field;
449     RDB_CHECK_RETURN_NULLPTR(JSUtils::Convert2Value(env, args[0], field) == napi_ok, "the field is invalid");
450     ValueObject value;
451     RDB_CHECK_RETURN_NULLPTR(JSUtils::Convert2Value(env, args[1], value) == napi_ok, "the value is invalid");
452     auto nativePredicates = GetNativePredicates(env, info);
453     RDB_CHECK_RETURN_NULLPTR(nativePredicates != nullptr, "GetNativePredicates return nullptr");
454     nativePredicates->LessThan(field, value);
455     return thiz;
456 }
457 
GreaterThanOrEqualTo(napi_env env,napi_callback_info info)458 napi_value DataAbilityPredicatesProxy::GreaterThanOrEqualTo(napi_env env, napi_callback_info info)
459 {
460     napi_value thiz = nullptr;
461     size_t argc = 2;
462     napi_value args[2] = { 0 };
463     napi_get_cb_info(env, info, &argc, args, &thiz, nullptr);
464     NAPI_ASSERT(env, argc > 0, "DataAbilityPredicatesProxy::GreaterThanOrEqualTo Invalid argvs!");
465     std::string field;
466     RDB_CHECK_RETURN_NULLPTR(JSUtils::Convert2Value(env, args[0], field) == napi_ok, "the field is invalid");
467     ValueObject value;
468     RDB_CHECK_RETURN_NULLPTR(JSUtils::Convert2Value(env, args[1], value) == napi_ok, "the value is invalid");
469     auto nativePredicates = GetNativePredicates(env, info);
470     RDB_CHECK_RETURN_NULLPTR(nativePredicates != nullptr, "GetNativePredicates return nullptr");
471     nativePredicates->GreaterThanOrEqualTo(field, value);
472     return thiz;
473 }
474 
LessThanOrEqualTo(napi_env env,napi_callback_info info)475 napi_value DataAbilityPredicatesProxy::LessThanOrEqualTo(napi_env env, napi_callback_info info)
476 {
477     napi_value thiz = nullptr;
478     size_t argc = 2;
479     napi_value args[2] = { 0 };
480     napi_get_cb_info(env, info, &argc, args, &thiz, nullptr);
481     NAPI_ASSERT(env, argc > 0, "DataAbilityPredicatesProxy::LessThanOrEqualTo Invalid argvs!");
482     std::string field;
483     RDB_CHECK_RETURN_NULLPTR(JSUtils::Convert2Value(env, args[0], field) == napi_ok, "the field is invalid");
484     ValueObject value;
485     RDB_CHECK_RETURN_NULLPTR(JSUtils::Convert2Value(env, args[1], value) == napi_ok, "the value is invalid");
486     auto nativePredicates = GetNativePredicates(env, info);
487     RDB_CHECK_RETURN_NULLPTR(nativePredicates != nullptr, "GetNativePredicates return nullptr");
488     nativePredicates->LessThanOrEqualTo(field, value);
489     return thiz;
490 }
491 
OrderByAsc(napi_env env,napi_callback_info info)492 napi_value DataAbilityPredicatesProxy::OrderByAsc(napi_env env, napi_callback_info info)
493 {
494     napi_value thiz = nullptr;
495     size_t argc = 1;
496     napi_value args[1] = { 0 };
497     napi_get_cb_info(env, info, &argc, args, &thiz, nullptr);
498     NAPI_ASSERT(env, argc > 0, "DataAbilityPredicatesProxy::OrderByAsc Invalid argvs!");
499 
500     std::string field;
501     RDB_CHECK_RETURN_NULLPTR(JSUtils::Convert2Value(env, args[0], field) == napi_ok, "the field is invalid");
502 
503     auto nativePredicates = GetNativePredicates(env, info);
504     RDB_CHECK_RETURN_NULLPTR(nativePredicates != nullptr, "GetNativePredicates return nullptr");
505     nativePredicates->OrderByAsc(field);
506     return thiz;
507 }
508 
OrderByDesc(napi_env env,napi_callback_info info)509 napi_value DataAbilityPredicatesProxy::OrderByDesc(napi_env env, napi_callback_info info)
510 {
511     napi_value thiz = nullptr;
512     size_t argc = 1;
513     napi_value args[1] = { 0 };
514     napi_get_cb_info(env, info, &argc, args, &thiz, nullptr);
515     NAPI_ASSERT(env, argc > 0, "DataAbilityPredicatesProxy::OrderByDesc Invalid argvs!");
516 
517     std::string field;
518     RDB_CHECK_RETURN_NULLPTR(JSUtils::Convert2Value(env, args[0], field) == napi_ok, "the field is invalid");
519 
520     auto nativePredicates = GetNativePredicates(env, info);
521     RDB_CHECK_RETURN_NULLPTR(nativePredicates != nullptr, "GetNativePredicates return nullptr");
522     nativePredicates->OrderByDesc(field);
523     return thiz;
524 }
525 
Distinct(napi_env env,napi_callback_info info)526 napi_value DataAbilityPredicatesProxy::Distinct(napi_env env, napi_callback_info info)
527 {
528     napi_value thiz = nullptr;
529     napi_get_cb_info(env, info, nullptr, nullptr, &thiz, nullptr);
530     auto nativePredicates = GetNativePredicates(env, info);
531     RDB_CHECK_RETURN_NULLPTR(nativePredicates != nullptr, "GetNativePredicates return nullptr");
532     nativePredicates->Distinct();
533     return thiz;
534 }
535 
Limit(napi_env env,napi_callback_info info)536 napi_value DataAbilityPredicatesProxy::Limit(napi_env env, napi_callback_info info)
537 {
538     napi_value thiz = nullptr;
539     size_t argc = 1;
540     napi_value args[1] = { 0 };
541     napi_get_cb_info(env, info, &argc, args, &thiz, nullptr);
542     NAPI_ASSERT(env, argc > 0, "DataAbilityPredicatesProxy::Limit Invalid argvs!");
543 
544     int32_t limit = 0;
545     RDB_CHECK_RETURN_NULLPTR(JSUtils::Convert2ValueExt(env, args[0], limit) == napi_ok, "the limit is invalid");
546 
547     auto nativePredicates = GetNativePredicates(env, info);
548     RDB_CHECK_RETURN_NULLPTR(nativePredicates != nullptr, "GetNativePredicates return nullptr");
549     nativePredicates->Limit(limit);
550     return thiz;
551 }
552 
Offset(napi_env env,napi_callback_info info)553 napi_value DataAbilityPredicatesProxy::Offset(napi_env env, napi_callback_info info)
554 {
555     napi_value thiz = nullptr;
556     size_t argc = 1;
557     napi_value args[1] = { 0 };
558     napi_get_cb_info(env, info, &argc, args, &thiz, nullptr);
559     NAPI_ASSERT(env, argc > 0, "DataAbilityPredicatesProxy::Offset Invalid argvs!");
560 
561     int32_t offset = 0;
562     RDB_CHECK_RETURN_NULLPTR(JSUtils::Convert2ValueExt(env, args[0], offset) == napi_ok, "the offset is invalid");
563 
564     auto nativePredicates = GetNativePredicates(env, info);
565     RDB_CHECK_RETURN_NULLPTR(nativePredicates != nullptr, "GetNativePredicates return nullptr");
566     nativePredicates->Offset(offset);
567     return thiz;
568 }
569 
GroupBy(napi_env env,napi_callback_info info)570 napi_value DataAbilityPredicatesProxy::GroupBy(napi_env env, napi_callback_info info)
571 {
572     napi_value thiz = nullptr;
573     size_t argc = 1;
574     napi_value args[1] = { 0 };
575     napi_get_cb_info(env, info, &argc, args, &thiz, nullptr);
576     NAPI_ASSERT(env, argc > 0, "DataAbilityPredicatesProxy::GroupBy Invalid argvs!");
577 
578     std::vector<std::string> fields = {};
579     RDB_CHECK_RETURN_NULLPTR(JSUtils::Convert2Value(env, args[0], fields) == napi_ok, "the fields is invalid");
580 
581     auto nativePredicates = GetNativePredicates(env, info);
582     RDB_CHECK_RETURN_NULLPTR(nativePredicates != nullptr, "GetNativePredicates return nullptr");
583     nativePredicates->GroupBy(fields);
584     return thiz;
585 }
586 
IndexedBy(napi_env env,napi_callback_info info)587 napi_value DataAbilityPredicatesProxy::IndexedBy(napi_env env, napi_callback_info info)
588 {
589     napi_value thiz = nullptr;
590     size_t argc = 1;
591     napi_value args[1] = { 0 };
592     napi_get_cb_info(env, info, &argc, args, &thiz, nullptr);
593     NAPI_ASSERT(env, argc > 0, "DataAbilityPredicatesProxy::IndexedBy Invalid argvs!");
594 
595     std::string indexName;
596     RDB_CHECK_RETURN_NULLPTR(JSUtils::Convert2Value(env, args[0], indexName) == napi_ok, "the indexName is invalid");
597 
598     auto nativePredicates = GetNativePredicates(env, info);
599     RDB_CHECK_RETURN_NULLPTR(nativePredicates != nullptr, "GetNativePredicates return nullptr");
600     nativePredicates->IndexedBy(indexName);
601     return thiz;
602 }
603 
In(napi_env env,napi_callback_info info)604 napi_value DataAbilityPredicatesProxy::In(napi_env env, napi_callback_info info)
605 {
606     napi_value thiz = nullptr;
607     size_t argc = 2;
608     napi_value args[2] = { 0 };
609     napi_get_cb_info(env, info, &argc, args, &thiz, nullptr);
610     NAPI_ASSERT(env, argc > 0, "DataAbilityPredicatesProxy::In Invalid argvs!");
611 
612     std::string field;
613     RDB_CHECK_RETURN_NULLPTR(JSUtils::Convert2Value(env, args[0], field) == napi_ok, "the field is invalid");
614 
615     std::vector<ValueObject> values;
616     NAPI_ASSERT(env, JSUtils::Convert2Value(env, args[1], values) == napi_ok, "Invalid values!");
617 
618     auto nativePredicates = GetNativePredicates(env, info);
619     RDB_CHECK_RETURN_NULLPTR(nativePredicates != nullptr, "GetNativePredicates return nullptr");
620     nativePredicates->In(field, values);
621     return thiz;
622 }
623 
NotIn(napi_env env,napi_callback_info info)624 napi_value DataAbilityPredicatesProxy::NotIn(napi_env env, napi_callback_info info)
625 {
626     napi_value thiz = nullptr;
627     size_t argc = 2;
628     napi_value args[2] = { 0 };
629     napi_get_cb_info(env, info, &argc, args, &thiz, nullptr);
630     NAPI_ASSERT(env, argc > 0, "DataAbilityPredicatesProxy::NotIn Invalid argvs!");
631 
632     std::string field;
633     RDB_CHECK_RETURN_NULLPTR(JSUtils::Convert2Value(env, args[0], field) == napi_ok, "the field is invalid");
634 
635     std::vector<ValueObject> values;
636     NAPI_ASSERT(env, JSUtils::Convert2Value(env, args[1], values) == napi_ok, "Invalid values");
637 
638     auto nativePredicates = GetNativePredicates(env, info);
639     RDB_CHECK_RETURN_NULLPTR(nativePredicates != nullptr, "GetNativePredicates return nullptr");
640     nativePredicates->NotIn(field, values);
641     return thiz;
642 }
643 
Clear(napi_env env,napi_callback_info info)644 napi_value DataAbilityPredicatesProxy::Clear(napi_env env, napi_callback_info info)
645 {
646     napi_value thiz = nullptr;
647     napi_get_cb_info(env, info, nullptr, nullptr, &thiz, nullptr);
648     auto nativePredicates = GetNativePredicates(env, info);
649     RDB_CHECK_RETURN_NULLPTR(nativePredicates != nullptr, "GetNativePredicates return nullptr");
650     nativePredicates->Clear();
651     return thiz;
652 }
653 
IsRawSelection(napi_env env,napi_callback_info info)654 napi_value DataAbilityPredicatesProxy::IsRawSelection(napi_env env, napi_callback_info info)
655 {
656     napi_value thiz = nullptr;
657     napi_get_cb_info(env, info, nullptr, nullptr, &thiz, nullptr);
658     auto nativePredicates = GetNativePredicates(env, info);
659     RDB_CHECK_RETURN_NULLPTR(nativePredicates != nullptr, "GetNativePredicates return nullptr");
660     bool out = nativePredicates->IsRawSelection();
661     return JSUtils::Convert2JSValue(env, out);
662 }
663 
GetPredicates() const664 std::shared_ptr<NativeRdb::DataAbilityPredicates> DataAbilityPredicatesProxy::GetPredicates() const
665 {
666     return this->predicates_;
667 }
668 
GetWhereClause(napi_env env,napi_callback_info info)669 napi_value DataAbilityPredicatesProxy::GetWhereClause(napi_env env, napi_callback_info info)
670 {
671     auto nativePredicates = GetNativePredicates(env, info);
672     RDB_CHECK_RETURN_NULLPTR(nativePredicates != nullptr, "GetNativePredicates return nullptr");
673     auto ret = nativePredicates->GetWhereClause();
674     return JSUtils::Convert2JSValue(env, ret);
675 }
676 
SetWhereClause(napi_env env,napi_callback_info info)677 napi_value DataAbilityPredicatesProxy::SetWhereClause(napi_env env, napi_callback_info info)
678 {
679     napi_value thiz = nullptr;
680     size_t argc = 1;
681     napi_value args[1] = { 0 };
682     napi_get_cb_info(env, info, &argc, args, &thiz, nullptr);
683     NAPI_ASSERT(env, argc > 0, "DataAbilityPredicatesProxy::SetWhereClause Invalid argvs!");
684 
685     std::string whereClause;
686     RDB_CHECK_RETURN_NULLPTR(JSUtils::Convert2Value(env, args[0], whereClause) == napi_ok, "whereClause is invalid");
687 
688     auto nativePredicates = GetNativePredicates(env, info);
689     RDB_CHECK_RETURN_NULLPTR(nativePredicates != nullptr, "GetNativePredicates return nullptr");
690     nativePredicates->SetWhereClause(whereClause);
691 
692     return thiz;
693 }
694 
GetWhereArgs(napi_env env,napi_callback_info info)695 napi_value DataAbilityPredicatesProxy::GetWhereArgs(napi_env env, napi_callback_info info)
696 {
697     auto nativePredicates = GetNativePredicates(env, info);
698     RDB_CHECK_RETURN_NULLPTR(nativePredicates != nullptr, "GetNativePredicates return nullptr");
699     auto ret = nativePredicates->GetWhereArgs();
700     return JSUtils::Convert2JSValue(env, ret);
701 }
702 
SetWhereArgs(napi_env env,napi_callback_info info)703 napi_value DataAbilityPredicatesProxy::SetWhereArgs(napi_env env, napi_callback_info info)
704 {
705     napi_value thiz = nullptr;
706     size_t argc = 1;
707     napi_value args[1] = { 0 };
708     napi_get_cb_info(env, info, &argc, args, &thiz, nullptr);
709     NAPI_ASSERT(env, argc > 0, "DataAbilityPredicatesProxy::SetWhereArgs Invalid argvs!");
710 
711     std::vector<std::string> whereArgs;
712     NAPI_ASSERT(env, JSUtils::Convert2Value(env, args[0], whereArgs) == napi_ok, "Invalid whereArgs!");
713 
714     auto nativePredicates = GetNativePredicates(env, info);
715     RDB_CHECK_RETURN_NULLPTR(nativePredicates != nullptr, "GetNativePredicates return nullptr");
716     nativePredicates->SetWhereArgs(whereArgs);
717 
718     return thiz;
719 }
720 
GetOrder(napi_env env,napi_callback_info info)721 napi_value DataAbilityPredicatesProxy::GetOrder(napi_env env, napi_callback_info info)
722 {
723     auto nativePredicates = GetNativePredicates(env, info);
724     RDB_CHECK_RETURN_NULLPTR(nativePredicates != nullptr, "GetNativePredicates return nullptr");
725     auto ret = nativePredicates->GetOrder();
726     return JSUtils::Convert2JSValue(env, ret);
727 }
728 
SetOrder(napi_env env,napi_callback_info info)729 napi_value DataAbilityPredicatesProxy::SetOrder(napi_env env, napi_callback_info info)
730 {
731     napi_value thiz = nullptr;
732     size_t argc = 1;
733     napi_value args[1] = { 0 };
734     napi_get_cb_info(env, info, &argc, args, &thiz, nullptr);
735     NAPI_ASSERT(env, argc > 0, "DataAbilityPredicatesProxy::SetOrder Invalid argvs!");
736 
737     std::string order;
738     RDB_CHECK_RETURN_NULLPTR(JSUtils::Convert2Value(env, args[0], order) != napi_ok, "the order is invalid");
739 
740     auto nativePredicates = GetNativePredicates(env, info);
741     RDB_CHECK_RETURN_NULLPTR(nativePredicates != nullptr, "GetNativePredicates return nullptr");
742     nativePredicates->SetOrder(order);
743 
744     return thiz;
745 }
746 
GetLimit(napi_env env,napi_callback_info info)747 napi_value DataAbilityPredicatesProxy::GetLimit(napi_env env, napi_callback_info info)
748 {
749     auto nativePredicates = GetNativePredicates(env, info);
750     RDB_CHECK_RETURN_NULLPTR(nativePredicates != nullptr, "GetNativePredicates return nullptr");
751     return JSUtils::Convert2JSValue(env, nativePredicates->GetLimit());
752 }
753 
GetOffset(napi_env env,napi_callback_info info)754 napi_value DataAbilityPredicatesProxy::GetOffset(napi_env env, napi_callback_info info)
755 {
756     auto nativePredicates = GetNativePredicates(env, info);
757     RDB_CHECK_RETURN_NULLPTR(nativePredicates != nullptr, "GetNativePredicates return nullptr");
758     return JSUtils::Convert2JSValue(env, nativePredicates->GetOffset());
759 }
760 
IsDistinct(napi_env env,napi_callback_info info)761 napi_value DataAbilityPredicatesProxy::IsDistinct(napi_env env, napi_callback_info info)
762 {
763     auto nativePredicates = GetNativePredicates(env, info);
764     RDB_CHECK_RETURN_NULLPTR(nativePredicates != nullptr, "GetNativePredicates return nullptr");
765     return JSUtils::Convert2JSValue(env, nativePredicates->IsDistinct());
766 }
767 
GetGroup(napi_env env,napi_callback_info info)768 napi_value DataAbilityPredicatesProxy::GetGroup(napi_env env, napi_callback_info info)
769 {
770     auto nativePredicates = GetNativePredicates(env, info);
771     RDB_CHECK_RETURN_NULLPTR(nativePredicates != nullptr, "GetNativePredicates return nullptr");
772     auto ret = nativePredicates->GetGroup();
773     return JSUtils::Convert2JSValue(env, ret);
774 }
775 
GetIndex(napi_env env,napi_callback_info info)776 napi_value DataAbilityPredicatesProxy::GetIndex(napi_env env, napi_callback_info info)
777 {
778     auto nativePredicates = GetNativePredicates(env, info);
779     RDB_CHECK_RETURN_NULLPTR(nativePredicates != nullptr, "GetNativePredicates return nullptr");
780     auto ret = nativePredicates->GetIndex();
781     return JSUtils::Convert2JSValue(env, ret);
782 }
783 
IsNeedAnd(napi_env env,napi_callback_info info)784 napi_value DataAbilityPredicatesProxy::IsNeedAnd(napi_env env, napi_callback_info info)
785 {
786     auto nativePredicates = GetNativePredicates(env, info);
787     RDB_CHECK_RETURN_NULLPTR(nativePredicates != nullptr, "GetNativePredicates return nullptr");
788     return JSUtils::Convert2JSValue(env, nativePredicates->IsNeedAnd());
789 }
790 
IsSorted(napi_env env,napi_callback_info info)791 napi_value DataAbilityPredicatesProxy::IsSorted(napi_env env, napi_callback_info info)
792 {
793     auto nativePredicates = GetNativePredicates(env, info);
794     RDB_CHECK_RETURN_NULLPTR(nativePredicates != nullptr, "GetNativePredicates return nullptr");
795     return JSUtils::Convert2JSValue(env, nativePredicates->IsSorted());
796 }
797 } // namespace DataAbilityJsKit
798 } // namespace OHOS
799 
800 EXTERN_C_START
801 __attribute__((visibility("default")))
NAPI_OHOS_Data_DataAbilityJsKit_DataAbilityPredicatesProxy_NewInstance(napi_env env,OHOS::NativeRdb::DataAbilityPredicates * predicates)802     napi_value NAPI_OHOS_Data_DataAbilityJsKit_DataAbilityPredicatesProxy_NewInstance(
803         napi_env env, OHOS::NativeRdb::DataAbilityPredicates *predicates)
804 {
805     return OHOS::DataAbilityJsKit::DataAbilityPredicatesProxy::NewInstance(
806         env, std::shared_ptr<OHOS::NativeRdb::DataAbilityPredicates>(predicates));
807 }
808 
809 __attribute__((visibility("default"))) OHOS::NativeRdb::DataAbilityPredicates *
NAPI_OHOS_Data_DataAbilityJsKit_DataAbilityPredicatesProxy_GetNativeObject(const napi_env env,const napi_value arg)810 NAPI_OHOS_Data_DataAbilityJsKit_DataAbilityPredicatesProxy_GetNativeObject(const napi_env env, const napi_value arg)
811 {
812     auto predicates = OHOS::DataAbilityJsKit::DataAbilityPredicatesProxy::GetNativePredicates(env, arg);
813     return predicates.get();
814 }
815 EXTERN_C_END