1 /*
2 * Copyright (c) 2025 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 MLOG_TAG "Media_Client"
16
17 #include "mdk_record_field.h"
18 #include "mdk_database.h"
19 #include "json_helper.h"
20
21 namespace OHOS::Media::CloudSync {
22 // LCOV_EXCL_START
MDKRecordField()23 MDKRecordField::MDKRecordField() : type_(MDKRecordFieldType::FIELD_TYPE_NULL)
24 {}
~MDKRecordField()25 MDKRecordField::~MDKRecordField()
26 {}
MDKRecordField(MDKFieldValue fieldValue)27 MDKRecordField::MDKRecordField(MDKFieldValue fieldValue) noexcept : value_(std::move(fieldValue))
28 {
29 type_ = MDKRecordFieldType(value_.index());
30 }
MDKRecordField(const MDKRecordField & recordField)31 MDKRecordField::MDKRecordField(const MDKRecordField &recordField)
32 {
33 if (this == &recordField) {
34 return;
35 }
36 type_ = recordField.type_;
37 value_ = recordField.value_;
38 }
39
MDKRecordField(int val)40 MDKRecordField::MDKRecordField(int val) : type_(MDKRecordFieldType::FIELD_TYPE_INT)
41 {
42 value_ = static_cast<int64_t>(val);
43 }
MDKRecordField(int64_t val)44 MDKRecordField::MDKRecordField(int64_t val) : type_(MDKRecordFieldType::FIELD_TYPE_INT)
45 {
46 value_ = val;
47 }
MDKRecordField(double val)48 MDKRecordField::MDKRecordField(double val) : type_(MDKRecordFieldType::FIELD_TYPE_DOUBLE)
49 {
50 value_ = val;
51 }
MDKRecordField(bool val)52 MDKRecordField::MDKRecordField(bool val) : type_(MDKRecordFieldType::FIELD_TYPE_BOOL)
53 {
54 value_ = val;
55 }
MDKRecordField(const char * val)56 MDKRecordField::MDKRecordField(const char *val) : type_(MDKRecordFieldType::FIELD_TYPE_STRING)
57 {
58 value_ = std::string(val);
59 }
MDKRecordField(const std::string & val)60 MDKRecordField::MDKRecordField(const std::string &val) : type_(MDKRecordFieldType::FIELD_TYPE_STRING)
61 {
62 value_ = val;
63 }
MDKRecordField(const std::vector<uint8_t> & val)64 MDKRecordField::MDKRecordField(const std::vector<uint8_t> &val) : type_(MDKRecordFieldType::FIELD_TYPE_BLOB)
65 {
66 std::vector<uint8_t> blob = val;
67 value_ = blob;
68 }
MDKRecordField(std::map<std::string,MDKRecordField> & val)69 MDKRecordField::MDKRecordField(std::map<std::string, MDKRecordField> &val) : type_(MDKRecordFieldType::FIELD_TYPE_MAP)
70 {
71 value_ = val;
72 }
MDKRecordField(std::vector<MDKRecordField> & val)73 MDKRecordField::MDKRecordField(std::vector<MDKRecordField> &val) : type_(MDKRecordFieldType::FIELD_TYPE_LIST)
74 {
75 value_ = val;
76 }
MDKRecordField(MDKAsset & val)77 MDKRecordField::MDKRecordField(MDKAsset &val) : type_(MDKRecordFieldType::FIELD_TYPE_ASSET)
78 {
79 value_ = val;
80 }
MDKRecordField(MDKReference & val)81 MDKRecordField::MDKRecordField(MDKReference &val) : type_(MDKRecordFieldType::FIELD_TYPE_REFERENCE)
82 {
83 value_ = val;
84 }
operator =(const MDKRecordField & recordField)85 MDKRecordField &MDKRecordField::operator=(const MDKRecordField &recordField)
86 {
87 if (this == &recordField) {
88 return *this;
89 }
90 type_ = recordField.type_;
91 value_ = recordField.value_;
92 return *this;
93 }
94
GetType() const95 MDKRecordFieldType MDKRecordField::GetType() const
96 {
97 return type_;
98 }
GetFieldValue() const99 MDKFieldValue MDKRecordField::GetFieldValue() const
100 {
101 return value_;
102 }
GetInt(int & val) const103 MDKLocalErrorCode MDKRecordField::GetInt(int &val) const
104 {
105 if (type_ != MDKRecordFieldType::FIELD_TYPE_INT) {
106 return MDKLocalErrorCode::DATA_TYPE_ERROR;
107 }
108
109 int64_t v = std::get<int64_t>(value_);
110 val = static_cast<int>(v);
111 return MDKLocalErrorCode::NO_ERROR;
112 }
GetLong(int64_t & val) const113 MDKLocalErrorCode MDKRecordField::GetLong(int64_t &val) const
114 {
115 if (type_ != MDKRecordFieldType::FIELD_TYPE_INT) {
116 return MDKLocalErrorCode::DATA_TYPE_ERROR;
117 }
118
119 val = std::get<int64_t>(value_);
120 return MDKLocalErrorCode::NO_ERROR;
121 }
GetDouble(double & val) const122 MDKLocalErrorCode MDKRecordField::GetDouble(double &val) const
123 {
124 if (type_ != MDKRecordFieldType::FIELD_TYPE_DOUBLE) {
125 return MDKLocalErrorCode::DATA_TYPE_ERROR;
126 }
127
128 val = std::get<double>(value_);
129 return MDKLocalErrorCode::NO_ERROR;
130 }
GetBool(bool & val) const131 MDKLocalErrorCode MDKRecordField::GetBool(bool &val) const
132 {
133 if (type_ != MDKRecordFieldType::FIELD_TYPE_BOOL) {
134 return MDKLocalErrorCode::DATA_TYPE_ERROR;
135 }
136
137 val = std::get<bool>(value_);
138 return MDKLocalErrorCode::NO_ERROR;
139 }
GetString(std::string & val) const140 MDKLocalErrorCode MDKRecordField::GetString(std::string &val) const
141 {
142 if (type_ != MDKRecordFieldType::FIELD_TYPE_STRING) {
143 return MDKLocalErrorCode::DATA_TYPE_ERROR;
144 }
145
146 val = std::get<std::string>(value_);
147 return MDKLocalErrorCode::NO_ERROR;
148 }
GetBlob(std::vector<uint8_t> & val) const149 MDKLocalErrorCode MDKRecordField::GetBlob(std::vector<uint8_t> &val) const
150 {
151 if (type_ != MDKRecordFieldType::FIELD_TYPE_BLOB) {
152 return MDKLocalErrorCode::DATA_TYPE_ERROR;
153 }
154
155 val = std::get<std::vector<uint8_t>>(value_);
156 return MDKLocalErrorCode::NO_ERROR;
157 }
GetRecordList(std::vector<MDKRecordField> & val) const158 MDKLocalErrorCode MDKRecordField::GetRecordList(std::vector<MDKRecordField> &val) const
159 {
160 if (type_ != MDKRecordFieldType::FIELD_TYPE_LIST) {
161 return MDKLocalErrorCode::DATA_TYPE_ERROR;
162 }
163 val = std::get<std::vector<MDKRecordField>>(value_);
164 return MDKLocalErrorCode::NO_ERROR;
165 }
GetRecordMap(std::map<std::string,MDKRecordField> & val) const166 MDKLocalErrorCode MDKRecordField::GetRecordMap(std::map<std::string, MDKRecordField> &val) const
167 {
168 if (type_ != MDKRecordFieldType::FIELD_TYPE_MAP) {
169 return MDKLocalErrorCode::DATA_TYPE_ERROR;
170 }
171 val = std::get<std::map<std::string, MDKRecordField>>(value_);
172 return MDKLocalErrorCode::NO_ERROR;
173 }
GetAsset(MDKAsset & val) const174 MDKLocalErrorCode MDKRecordField::GetAsset(MDKAsset &val) const
175 {
176 if (type_ != MDKRecordFieldType::FIELD_TYPE_ASSET) {
177 return MDKLocalErrorCode::DATA_TYPE_ERROR;
178 }
179 val = std::get<MDKAsset>(value_);
180 return MDKLocalErrorCode::NO_ERROR;
181 }
GetReference(MDKReference & val) const182 MDKLocalErrorCode MDKRecordField::GetReference(MDKReference &val) const
183 {
184 if (type_ != MDKRecordFieldType::FIELD_TYPE_REFERENCE) {
185 return MDKLocalErrorCode::DATA_TYPE_ERROR;
186 }
187 val = std::get<MDKReference>(value_);
188 return MDKLocalErrorCode::NO_ERROR;
189 }
190
FieldListToJsonValue()191 Json::Value MDKRecordField::FieldListToJsonValue()
192 {
193 Json::Value jvData;
194 std::vector<MDKRecordField> recordLst;
195 GetRecordList(recordLst);
196 for (auto &record : recordLst) {
197 jvData.append(record.ToJsonValue());
198 }
199 return jvData;
200 }
201
FieldMapToJsonValue()202 Json::Value MDKRecordField::FieldMapToJsonValue()
203 {
204 Json::Value jvData;
205 std::map<std::string, MDKRecordField> recordMap;
206 GetRecordMap(recordMap);
207 for (auto it = recordMap.begin(); it != recordMap.end(); it++) {
208 jvData[it->first.c_str()] = it->second.ToJsonValue();
209 }
210 return jvData;
211 }
AssetToJsonValue(const MDKAsset & asset)212 Json::Value MDKRecordField::AssetToJsonValue(const MDKAsset &asset)
213 {
214 Json::Value jvAsset;
215 jvAsset["uri"] = asset.uri;
216 jvAsset["assetName"] = asset.assetName;
217 jvAsset["assetOperType"] = static_cast<int>(asset.operationType);
218 jvAsset["sha256"] = asset.hash;
219 jvAsset["version"] = asset.version;
220 jvAsset["assetId"] = asset.assetId;
221 jvAsset["subPath"] = asset.subPath;
222 jvAsset["exCheckInfo"] = asset.exCheckInfo;
223 jvAsset["size"] = asset.size;
224 return jvAsset;
225 }
FieldAssetToJsonValue()226 Json::Value MDKRecordField::FieldAssetToJsonValue()
227 {
228 MDKAsset asset = std::get<MDKAsset>(value_);
229 return AssetToJsonValue(asset);
230 }
231
FieldReferenceToJsonValue()232 Json::Value MDKRecordField::FieldReferenceToJsonValue()
233 {
234 MDKReference ref = std::get<MDKReference>(value_);
235 Json::Value jvReference;
236 jvReference["recordId"] = ref.recordId;
237 jvReference["recordType"] = ref.recordType;
238 return jvReference;
239 }
240
ToJsonValue()241 Json::Value MDKRecordField::ToJsonValue()
242 {
243 Json::Value jvData;
244 switch (type_) {
245 case MDKRecordFieldType::FIELD_TYPE_NULL: {
246 jvData = Json::nullValue;
247 break;
248 }
249 case MDKRecordFieldType::FIELD_TYPE_INT: {
250 jvData = std::get<int64_t>(value_);
251 break;
252 }
253 case MDKRecordFieldType::FIELD_TYPE_DOUBLE: {
254 jvData = std::get<double>(value_);
255 break;
256 }
257 case MDKRecordFieldType::FIELD_TYPE_STRING: {
258 jvData = std::get<std::string>(value_);
259 break;
260 }
261 case MDKRecordFieldType::FIELD_TYPE_BOOL: {
262 jvData = std::get<bool>(value_);
263 break;
264 }
265 case MDKRecordFieldType::FIELD_TYPE_BLOB: {
266 // do not support blob to json in MDKRecordField
267 break;
268 }
269 case MDKRecordFieldType::FIELD_TYPE_LIST: {
270 jvData = FieldListToJsonValue();
271 break;
272 }
273 case MDKRecordFieldType::FIELD_TYPE_MAP: {
274 jvData = FieldMapToJsonValue();
275 break;
276 }
277 case MDKRecordFieldType::FIELD_TYPE_ASSET: {
278 jvData = FieldAssetToJsonValue();
279 break;
280 }
281 case MDKRecordFieldType::FIELD_TYPE_REFERENCE: {
282 jvData = FieldReferenceToJsonValue();
283 break;
284 }
285 default:
286 break;
287 }
288 return jvData;
289 }
290
ParseIntFromJson(const Json::Value & jvData)291 bool MDKRecordField::ParseIntFromJson(const Json::Value &jvData)
292 {
293 auto ret = jvData.isInt64() ? true : false;
294 if (ret) {
295 value_ = jvData.asInt64();
296 }
297 return ret;
298 }
299
ParseDoubleFromJson(const Json::Value & jvData)300 bool MDKRecordField::ParseDoubleFromJson(const Json::Value &jvData)
301 {
302 auto ret = jvData.isDouble() ? true : false;
303 if (ret) {
304 value_ = jvData.asDouble();
305 }
306 return ret;
307 }
308
ParseStringFromJson(const Json::Value & jvData)309 bool MDKRecordField::ParseStringFromJson(const Json::Value &jvData)
310 {
311 auto ret = jvData.isString() ? true : false;
312 if (ret) {
313 value_ = jvData.asString();
314 }
315 return ret;
316 }
317
ParseBoolFromJson(const Json::Value & jvData)318 bool MDKRecordField::ParseBoolFromJson(const Json::Value &jvData)
319 {
320 auto ret = jvData.isBool() ? true : false;
321 if (ret) {
322 value_ = jvData.asBool();
323 }
324 return ret;
325 }
326
ParseBlobFromJson(const Json::Value & jvData)327 bool MDKRecordField::ParseBlobFromJson(const Json::Value &jvData)
328 {
329 return false;
330 }
331
ParseListFromJson(MDKRecordFieldType listType,const Json::Value & jvData)332 bool MDKRecordField::ParseListFromJson(MDKRecordFieldType listType, const Json::Value &jvData)
333 {
334 bool ret = true;
335 if (!jvData.isArray()) {
336 return false;
337 }
338 std::vector<MDKRecordField> lst;
339 MDKSchemaField schemaField;
340 schemaField.type = listType;
341 for (Json::ArrayIndex i = 0; i < jvData.size(); i++) {
342 MDKRecordField field;
343 if (field.ParseFromJsonValue(schemaField, jvData[i])) {
344 lst.push_back(field);
345 } else {
346 ret = false;
347 }
348 }
349 value_ = lst;
350 return ret;
351 }
352
ParseMapFromJson(const Json::Value & jvData)353 bool MDKRecordField::ParseMapFromJson(const Json::Value &jvData)
354 {
355 bool ret = true;
356 if (!jvData.isObject()) {
357 return false;
358 }
359 std::map<std::string, MDKRecordField> fieldMap;
360 auto mem = jvData.getMemberNames();
361 for (auto &key : mem) {
362 MDKRecordField field;
363 const Json::Value &jvValue = jvData[key];
364 if (jvValue.isInt64()) {
365 field.type_ = MDKRecordFieldType::FIELD_TYPE_INT;
366 field.value_ = jvValue.asInt64();
367 } else if (jvValue.isDouble()) {
368 field.type_ = MDKRecordFieldType::FIELD_TYPE_DOUBLE;
369 field.value_ = jvValue.asDouble();
370 } else if (jvValue.isString()) {
371 field.type_ = MDKRecordFieldType::FIELD_TYPE_STRING;
372 field.value_ = jvValue.asString();
373 } else if (jvValue.isBool()) {
374 field.type_ = MDKRecordFieldType::FIELD_TYPE_BOOL;
375 field.value_ = jvValue.asBool();
376 } else {
377 ret = false;
378 continue;
379 }
380 fieldMap[key] = field;
381 }
382 value_ = fieldMap;
383 return ret;
384 }
385
ParseAssetFromJson(const Json::Value & jvData)386 bool MDKRecordField::ParseAssetFromJson(const Json::Value &jvData)
387 {
388 if (!jvData.isObject()) {
389 return false;
390 }
391 MDKAsset asset = ParseAssetFromJsonValue(jvData);
392 value_ = asset;
393 return true;
394 }
395
ParseReferenceFromJson(const Json::Value & jvData)396 bool MDKRecordField::ParseReferenceFromJson(const Json::Value &jvData)
397 {
398 if (!jvData.isObject()) {
399 return false;
400 }
401 MDKReference reference;
402 reference.recordId = JsonHelper::GetStringFromJson(jvData, "recordId");
403 reference.recordType = JsonHelper::GetStringFromJson(jvData, "recordType");
404 value_ = reference;
405 return true;
406 }
407
ParseFromJsonValue(const MDKSchemaField & schemaField,const Json::Value & jvData)408 bool MDKRecordField::ParseFromJsonValue(const MDKSchemaField &schemaField, const Json::Value &jvData)
409 {
410 bool ret = true;
411 this->type_ = schemaField.type;
412 switch (type_) {
413 case MDKRecordFieldType::FIELD_TYPE_NULL:
414 break;
415 case MDKRecordFieldType::FIELD_TYPE_INT:
416 ret = ParseIntFromJson(jvData);
417 break;
418 case MDKRecordFieldType::FIELD_TYPE_DOUBLE:
419 ret = ParseDoubleFromJson(jvData);
420 break;
421 case MDKRecordFieldType::FIELD_TYPE_STRING:
422 ret = ParseStringFromJson(jvData);
423 break;
424 case MDKRecordFieldType::FIELD_TYPE_BOOL:
425 ret = ParseBoolFromJson(jvData);
426 break;
427 case MDKRecordFieldType::FIELD_TYPE_BLOB:
428 ret = ParseBlobFromJson(jvData);
429 break;
430 case MDKRecordFieldType::FIELD_TYPE_LIST:
431 ret = ParseListFromJson(schemaField.listType, jvData);
432 break;
433 case MDKRecordFieldType::FIELD_TYPE_MAP:
434 ret = ParseMapFromJson(jvData);
435 break;
436 case MDKRecordFieldType::FIELD_TYPE_ASSET:
437 ret = ParseAssetFromJson(jvData);
438 break;
439 case MDKRecordFieldType::FIELD_TYPE_REFERENCE:
440 ret = ParseReferenceFromJson(jvData);
441 break;
442 default: {
443 ret = false;
444 break;
445 }
446 }
447 return ret;
448 }
449
ParseAssetFromJsonValue(const Json::Value & jvData)450 MDKAsset MDKRecordField::ParseAssetFromJsonValue(const Json::Value &jvData)
451 {
452 MDKAsset asset;
453 asset.uri = JsonHelper::GetStringFromJson(jvData, "uri");
454 asset.assetName = JsonHelper::GetStringFromJson(jvData, "assetName");
455 int value = JsonHelper::GetIntFromJson(jvData, "assetOperType", -1);
456 if (value >= static_cast<int> (MDKAssetOperType::DK_ASSET_NONE) &&
457 value < static_cast<int> (MDKAssetOperType::DK_ASSET_MAX)) {
458 asset.operationType = static_cast<MDKAssetOperType>(value);
459 }
460 asset.hash = JsonHelper::GetStringFromJson(jvData, "sha256");
461 asset.version = JsonHelper::GetInt64FromJson(jvData, "version");
462 asset.assetId = JsonHelper::GetStringFromJson(jvData, "assetId");
463 asset.subPath = JsonHelper::GetStringFromJson(jvData, "subPath");
464 asset.exCheckInfo = JsonHelper::GetStringFromJson(jvData, "exCheckInfo");
465 asset.size = JsonHelper::GetUInt64FromJson(jvData, "size");
466 asset.fd = JsonHelper::GetIntFromJson(jvData, "fd", -1);
467 return asset;
468 }
469 // LCOV_EXCL_STOP
470 } // namespace OHOS::Media::CloudSync