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 #include "napi_data_ability_operation.h"
16
17 #include <cstring>
18 #include <map>
19
20 #include "data_ability_predicates.h"
21 #include "hilog_wrapper.h"
22 #include "napi_common_want.h"
23 #include "napi_data_ability_helper.h"
24 #include "values_bucket.h"
25
26 namespace OHOS {
27 namespace AppExecFwk {
DataAbilityOperationInit(napi_env env,napi_value exports)28 napi_value DataAbilityOperationInit(napi_env env, napi_value exports)
29 {
30 const int INSERT = 1;
31 const int UPDATE = 2;
32 const int DELETE = 3;
33 const int ASSERT = 4;
34 HILOG_INFO("%{public}s called.", __func__);
35
36 napi_value dataAbilityOperationType = nullptr;
37 napi_create_object(env, &dataAbilityOperationType);
38 SetNamedProperty(env, dataAbilityOperationType, "TYPE_INSERT", INSERT);
39 SetNamedProperty(env, dataAbilityOperationType, "TYPE_UPDATE", UPDATE);
40 SetNamedProperty(env, dataAbilityOperationType, "TYPE_DELETE", DELETE);
41 SetNamedProperty(env, dataAbilityOperationType, "TYPE_ASSERT", ASSERT);
42
43 napi_property_descriptor properties[] = {
44 DECLARE_NAPI_PROPERTY("DataAbilityOperationType", dataAbilityOperationType),
45 };
46 NAPI_CALL(env, napi_define_properties(env, exports, sizeof(properties) / sizeof(properties[0]), properties));
47
48 return exports;
49 }
50
UnwrapDataAbilityOperation(std::shared_ptr<DataAbilityOperation> & dataAbilityOperation,napi_env env,napi_value param)51 napi_value UnwrapDataAbilityOperation(
52 std::shared_ptr<DataAbilityOperation> &dataAbilityOperation, napi_env env, napi_value param)
53 {
54 HILOG_INFO("%{public}s called.", __func__);
55 if (!IsTypeForNapiValue(env, param, napi_object)) {
56 HILOG_ERROR("%{public}s, Params is invalid.", __func__);
57 return nullptr;
58 }
59
60 napi_value result = BuildDataAbilityOperation(dataAbilityOperation, env, param);
61 return result;
62 }
63
BuildDataAbilityOperation(std::shared_ptr<DataAbilityOperation> & dataAbilityOperation,napi_env env,napi_value param)64 napi_value BuildDataAbilityOperation(
65 std::shared_ptr<DataAbilityOperation> &dataAbilityOperation, napi_env env, napi_value param)
66 {
67 HILOG_INFO("%{public}s start.", __func__);
68
69 // get uri property
70 std::string uriStr("");
71 if (!UnwrapStringByPropertyName(env, param, "uri", uriStr)) {
72 HILOG_ERROR("%{public}s, uri is not exist.", __func__);
73 return nullptr;
74 }
75 HILOG_INFO("%{public}s, uri:%{public}s", __func__, uriStr.c_str());
76 std::shared_ptr<Uri> uri = std::make_shared<Uri>(uriStr);
77
78 // get type property
79 int type = 0;
80 if (!UnwrapInt32ByPropertyName(env, param, "type", type)) {
81 HILOG_ERROR("%{public}s, type:%{public}d is not exist.", __func__, type);
82 return nullptr;
83 }
84 HILOG_INFO("%{public}s, type:%{public}d", __func__, type);
85
86 std::shared_ptr<DataAbilityOperationBuilder> builder = nullptr;
87 if (!GetDataAbilityOperationBuilder(builder, type, uri)) {
88 HILOG_ERROR("%{public}s, GetDataAbilityOperationBuilder failed.", __func__);
89 return nullptr;
90 }
91
92 // get valuesBucket property
93 std::shared_ptr<NativeRdb::ValuesBucket> valuesBucket = std::make_shared<NativeRdb::ValuesBucket>();
94 valuesBucket->Clear();
95 napi_value jsValueBucket = GetPropertyValueByPropertyName(env, param, "valuesBucket", napi_object);
96 UnwrapValuesBucket(valuesBucket, env, jsValueBucket);
97 builder->WithValuesBucket(valuesBucket);
98
99 // get dataAbilityPredicates property
100 std::shared_ptr<NativeRdb::DataAbilityPredicates> predicates = std::make_shared<NativeRdb::DataAbilityPredicates>();
101 napi_value jsPredicates = GetPropertyValueByPropertyName(env, param, "predicates", napi_object);
102 UnwrapDataAbilityPredicates(*predicates, env, jsPredicates);
103 builder->WithPredicates(predicates);
104
105 // get expectedcount property
106 int expectedCount = 0;
107 UnwrapInt32ByPropertyName(env, param, "expectedCount", expectedCount);
108 HILOG_INFO("%{public}s, expectedCount:%{public}d", __func__, expectedCount);
109 if (expectedCount > 0) {
110 builder->WithExpectedCount(expectedCount);
111 }
112
113 // get PredicatesBackReferences property
114 napi_value jsPredicatesBackReferences =
115 GetPropertyValueByPropertyName(env, param, "PredicatesBackReferences", napi_object);
116 UnwrapDataAbilityPredicatesBackReferences(builder, env, jsPredicatesBackReferences);
117
118 // get interrupted property
119 bool interrupted = false;
120 UnwrapBooleanByPropertyName(env, param, "interrupted", interrupted);
121 builder->WithInterruptionAllowed(interrupted);
122
123 // get backReferences
124 std::shared_ptr<NativeRdb::ValuesBucket> backReferences = std::make_shared<NativeRdb::ValuesBucket>();
125 backReferences->Clear();
126 napi_value jsBackReferences = GetPropertyValueByPropertyName(env, param, "valueBackReferences", napi_object);
127 UnwrapValuesBucket(backReferences, env, jsBackReferences);
128 builder->WithValueBackReferences(backReferences);
129
130 if (builder != nullptr) {
131 HILOG_INFO("%{public}s, builder is not nullptr", __func__);
132 dataAbilityOperation = builder->Build();
133 }
134 napi_value result;
135 NAPI_CALL(env, napi_create_int32(env, 1, &result));
136 HILOG_INFO("%{public}s end.", __func__);
137 return result;
138 }
139
GetDataAbilityOperationBuilder(std::shared_ptr<DataAbilityOperationBuilder> & builder,const int type,const std::shared_ptr<Uri> & uri)140 bool GetDataAbilityOperationBuilder(
141 std::shared_ptr<DataAbilityOperationBuilder> &builder, const int type, const std::shared_ptr<Uri> &uri)
142 {
143 HILOG_INFO("%{public}s called.", __func__);
144 switch (type) {
145 case DataAbilityOperation::TYPE_INSERT:
146 builder = DataAbilityOperation::NewInsertBuilder(uri);
147 break;
148 case DataAbilityOperation::TYPE_UPDATE:
149 builder = DataAbilityOperation::NewUpdateBuilder(uri);
150 break;
151 case DataAbilityOperation::TYPE_DELETE:
152 builder = DataAbilityOperation::NewDeleteBuilder(uri);
153 break;
154 case DataAbilityOperation::TYPE_ASSERT:
155 builder = DataAbilityOperation::NewAssertBuilder(uri);
156 break;
157 default:
158 HILOG_ERROR("%{public}s, type:%{public}d is invalid.", __func__, type);
159 return false;
160 }
161 return true;
162 }
163
UnwrapValuesBucket(const std::shared_ptr<NativeRdb::ValuesBucket> & param,napi_env env,napi_value valueBucketParam)164 napi_value UnwrapValuesBucket(const std::shared_ptr<NativeRdb::ValuesBucket> ¶m, napi_env env,
165 napi_value valueBucketParam)
166 {
167 HILOG_INFO("%{public}s called.", __func__);
168 napi_value result;
169
170 if (param == nullptr) {
171 HILOG_INFO("%{public}s input param is nullptr.", __func__);
172 NAPI_CALL(env, napi_create_int32(env, 0, &result));
173 return result;
174 }
175 AnalysisValuesBucket(*param, env, valueBucketParam);
176
177 NAPI_CALL(env, napi_create_int32(env, 1, &result));
178 return result;
179 }
180
UnwrapDataAbilityPredicatesBackReferences(std::shared_ptr<DataAbilityOperationBuilder> & builder,napi_env env,napi_value predicatesBackReferencesParam)181 napi_value UnwrapDataAbilityPredicatesBackReferences(
182 std::shared_ptr<DataAbilityOperationBuilder> &builder, napi_env env, napi_value predicatesBackReferencesParam)
183 {
184 HILOG_INFO("%{public}s called.", __func__);
185
186 if (!IsTypeForNapiValue(env, predicatesBackReferencesParam, napi_object)) {
187 HILOG_ERROR("%{public}s, predicatesBackReferencesParam is invalid.", __func__);
188 return nullptr;
189 }
190
191 napi_valuetype jsValueType = napi_undefined;
192 napi_value jsProNameList = nullptr;
193 uint32_t jsProCount = 0;
194
195 NAPI_CALL(env, napi_get_property_names(env, predicatesBackReferencesParam, &jsProNameList));
196 NAPI_CALL(env, napi_get_array_length(env, jsProNameList, &jsProCount));
197 HILOG_INFO("%{public}s, Property size=%{public}d.", __func__, jsProCount);
198
199 napi_value jsProName = nullptr;
200 napi_value jsProValue = nullptr;
201 for (uint32_t index = 0; index < jsProCount; index++) {
202 NAPI_CALL(env, napi_get_element(env, jsProNameList, index, &jsProName));
203 std::string strProName = UnwrapStringFromJS(env, jsProName);
204 int intProName = std::atoi(strProName.c_str());
205 HILOG_INFO("%{public}s, Property name=%{public}d.", __func__, intProName);
206 NAPI_CALL(env, napi_get_property(env, predicatesBackReferencesParam, jsProName, &jsProValue));
207 NAPI_CALL(env, napi_typeof(env, jsProValue, &jsValueType));
208 int32_t natValue32 = 0;
209 if (napi_get_value_int32(env, jsProValue, &natValue32) == napi_ok) {
210 HILOG_INFO("%{public}s, Property value=%{public}d.", __func__, natValue32);
211 builder->WithPredicatesBackReference(intProName, natValue32);
212 }
213 }
214 napi_value result;
215 NAPI_CALL(env, napi_create_int32(env, 1, &result));
216 return result;
217 }
218
SetNamedProperty(napi_env env,napi_value obj,const char * propName,int propValue)219 void SetNamedProperty(napi_env env, napi_value obj, const char *propName, int propValue)
220 {
221 napi_value prop = nullptr;
222 napi_create_int32(env, propValue, &prop);
223 napi_set_named_property(env, obj, propName, prop);
224 }
225 } // namespace AppExecFwk
226 } // namespace OHOS
227