1 /*
2 * Copyright (c) 2023 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
16 #include "c_request_database.h"
17
18 #include <securec.h>
19
20 #include <algorithm>
21 #include <cstdint>
22
23 #include "log.h"
24
25 namespace OHOS::Request {
RequestDataBase()26 RequestDataBase::RequestDataBase()
27 {
28 int errCode = OHOS::NativeRdb::E_OK;
29 OHOS::NativeRdb::RdbStoreConfig config(DB_NAME);
30 config.SetSecurityLevel(NativeRdb::SecurityLevel::S1);
31 config.SetEncryptStatus(true);
32 RequestDBOpenCallback requestDBOpenCallback;
33 store_ = OHOS::NativeRdb::RdbHelper::GetRdbStore(config, DATABASE_OPEN_VERSION, requestDBOpenCallback, errCode);
34 REQUEST_HILOGI("Gets request database, ret: %{public}d", errCode);
35 }
36
GetInstance()37 RequestDataBase &RequestDataBase::GetInstance()
38 {
39 static RequestDataBase requestDataBase;
40 return requestDataBase;
41 }
42
Insert(const std::string & table,const OHOS::NativeRdb::ValuesBucket & insertValues)43 bool RequestDataBase::Insert(const std::string &table, const OHOS::NativeRdb::ValuesBucket &insertValues)
44 {
45 if (store_ == nullptr) {
46 REQUEST_HILOGE("store_ is nullptr");
47 return false;
48 }
49
50 int64_t outRowId = 0;
51 int ret = store_->Insert(outRowId, table, insertValues);
52 REQUEST_HILOGD("Request databases insert values, ret: %{public}d", ret);
53 return ret == OHOS::NativeRdb::E_OK;
54 }
55
Update(const OHOS::NativeRdb::ValuesBucket values,const OHOS::NativeRdb::AbsRdbPredicates & predicates)56 bool RequestDataBase::Update(
57 const OHOS::NativeRdb::ValuesBucket values, const OHOS::NativeRdb::AbsRdbPredicates &predicates)
58 {
59 if (store_ == nullptr) {
60 REQUEST_HILOGE("store_ is nullptr");
61 return false;
62 }
63
64 int changedRows = 0;
65 int ret = store_->Update(changedRows, values, predicates);
66 REQUEST_HILOGD("Request databases update, changedRows: %{public}d, ret: %{public}d", changedRows, ret);
67 return ret == OHOS::NativeRdb::E_OK;
68 }
69
Query(const OHOS::NativeRdb::AbsRdbPredicates & predicates,const std::vector<std::string> & columns)70 std::shared_ptr<OHOS::NativeRdb::ResultSet> RequestDataBase::Query(
71 const OHOS::NativeRdb::AbsRdbPredicates &predicates, const std::vector<std::string> &columns)
72 {
73 if (store_ == nullptr) {
74 REQUEST_HILOGE("store_ is nullptr");
75 return nullptr;
76 }
77 return store_->Query(predicates, columns);
78 }
79
Delete(const OHOS::NativeRdb::AbsRdbPredicates & predicates)80 bool RequestDataBase::Delete(const OHOS::NativeRdb::AbsRdbPredicates &predicates)
81 {
82 if (store_ == nullptr) {
83 REQUEST_HILOGE("store_ is nullptr");
84 return false;
85 }
86
87 int deletedRows = 0;
88 int ret = store_->Delete(deletedRows, predicates);
89 REQUEST_HILOGD("Request databases delete rows, rows: %{public}d, ret: %{public}d", ret, deletedRows);
90 return ret == OHOS::NativeRdb::E_OK;
91 }
92
OnCreate(OHOS::NativeRdb::RdbStore & store)93 int RequestDBOpenCallback::OnCreate(OHOS::NativeRdb::RdbStore &store)
94 {
95 return OHOS::NativeRdb::E_OK;
96 }
97
RequestDBInitVersionTable(OHOS::NativeRdb::RdbStore & store)98 void RequestDBInitVersionTable(OHOS::NativeRdb::RdbStore &store)
99 {
100 REQUEST_HILOGD("Inits version_table");
101 // Clears `request_version` table first.
102 int ret = store.ExecuteSql("DELETE FROM request_version");
103 if (ret != OHOS::NativeRdb::E_OK) {
104 REQUEST_HILOGE("Clears request_version table failed");
105 return;
106 }
107
108 int64_t outRowId = 0;
109 OHOS::NativeRdb::ValuesBucket insertValues;
110 insertValues.PutString("version", std::string(REQUEST_DATABASE_VERSION));
111 insertValues.PutString("task_table", std::string(REQUEST_TASK_TABLE_NAME));
112 ret = store.Insert(outRowId, std::string("request_version"), insertValues);
113 if (ret != OHOS::NativeRdb::E_OK) {
114 REQUEST_HILOGE("Inits request_version table failed");
115 return;
116 }
117 REQUEST_HILOGD("Inits version_table success");
118 return;
119 }
120
RequestDBDropTable(OHOS::NativeRdb::RdbStore & store,const char * name)121 int RequestDBDropTable(OHOS::NativeRdb::RdbStore &store, const char *name)
122 {
123 return store.ExecuteSql(std::string("DROP TABLE IF EXISTS ") + name);
124 }
125
RequestDBRemoveOldTables(OHOS::NativeRdb::RdbStore & store)126 void RequestDBRemoveOldTables(OHOS::NativeRdb::RdbStore &store)
127 {
128 REQUEST_HILOGD("Begins removing old tables");
129
130 // These two tables followed was defined in 4.0-release.
131 if (RequestDBDropTable(store, "request_task_info") != OHOS::NativeRdb::E_OK) {
132 REQUEST_HILOGE("Removes request_task_info table failed");
133 }
134
135 if (RequestDBDropTable(store, "task_info_attachment") != OHOS::NativeRdb::E_OK) {
136 REQUEST_HILOGE("Removes task_info_attachment table failed");
137 }
138
139 // These four tables followed was defined in 4.1-beta.
140 if (RequestDBDropTable(store, "request_task_config") != OHOS::NativeRdb::E_OK) {
141 REQUEST_HILOGE("Removes request_task_config table failed");
142 }
143
144 if (RequestDBDropTable(store, "task_config_attachment") != OHOS::NativeRdb::E_OK) {
145 REQUEST_HILOGE("Removes task_config_attachment table failed");
146 }
147
148 if (RequestDBDropTable(store, "priority_table") != OHOS::NativeRdb::E_OK) {
149 REQUEST_HILOGE("Removes priority_table table failed");
150 }
151
152 if (RequestDBDropTable(store, "certs_table") != OHOS::NativeRdb::E_OK) {
153 REQUEST_HILOGE("Removes certs_table table failed");
154 }
155
156 REQUEST_HILOGD("Removes old tables end");
157 }
158
RequestDBUpgrade(OHOS::NativeRdb::RdbStore & store)159 void RequestDBUpgrade(OHOS::NativeRdb::RdbStore &store)
160 {
161 REQUEST_HILOGD("Begins upgrading database");
162 OHOS::NativeRdb::RdbPredicates rdbPredicates("request_version");
163 auto resultSet = store.Query(rdbPredicates, { "version", "task_table" });
164 if (resultSet == nullptr) {
165 REQUEST_HILOGE("ResultSet is nullptr");
166 return;
167 }
168
169 int rowCount = 0;
170 if (resultSet->GetRowCount(rowCount) != OHOS::NativeRdb::E_OK) {
171 REQUEST_HILOGE("Gets rowCount failed");
172 return;
173 }
174
175 // `rowCount` is 0 indicates that the table has just been created.
176 // `rowCount` is greater than 1, indicates that the historical data is incorrect.
177 if (rowCount == 0 || rowCount > 1) {
178 REQUEST_HILOGD("RowCount is 0 or more than 1, upgrades version_table");
179 RequestDBRemoveOldTables(store);
180 RequestDBInitVersionTable(store);
181 return;
182 }
183
184 if (resultSet->GoToRow(0) != OHOS::NativeRdb::E_OK) {
185 REQUEST_HILOGE("ResultSet goes to first row failed");
186 return;
187 }
188
189 std::string version = "";
190 if (resultSet->GetString(0, version) != OHOS::NativeRdb::E_OK) {
191 REQUEST_HILOGE("ResultSet gets version failed");
192 return;
193 }
194
195 REQUEST_HILOGI("request database version: %{public}s", version.c_str());
196
197 // If `version` is invalid, upgrades all tables.
198 if (version != REQUEST_DATABASE_VERSION) {
199 REQUEST_HILOGD("RowCount is 1, upgrades from invalid situation");
200 RequestDBRemoveOldTables(store);
201 RequestDBInitVersionTable(store);
202 return;
203 }
204
205 REQUEST_HILOGI("Updates request database success");
206 return;
207 }
208
RequestDBUpdateInvalidRecords(OHOS::NativeRdb::RdbStore & store)209 void RequestDBUpdateInvalidRecords(OHOS::NativeRdb::RdbStore &store)
210 {
211 REQUEST_HILOGI("Updates all invalid task to failed");
212
213 OHOS::NativeRdb::ValuesBucket values;
214 values.PutInt("state", static_cast<uint8_t>(State::FAILED));
215
216 // Tasks in `WAITING` and `PAUSED` states need to be resumed,
217 // so they are not processed.
218 int changedRows = 0;
219 OHOS::NativeRdb::RdbPredicates rdbPredicates("request_task");
220 rdbPredicates.EqualTo("state", static_cast<uint8_t>(State::INITIALIZED))
221 ->Or()
222 ->EqualTo("state", static_cast<uint8_t>(State::RUNNING))
223 ->Or()
224 ->EqualTo("state", static_cast<uint8_t>(State::RETRYING))
225 ->Or()
226 ->EqualTo("state", static_cast<uint8_t>(State::DEFAULT));
227
228 if (store.Update(changedRows, values, rdbPredicates) != OHOS::NativeRdb::E_OK) {
229 REQUEST_HILOGE("Updates all invalid task to `FAILED` state failed");
230 return;
231 }
232 REQUEST_HILOGI("Updates all invalid task to `FAILED` state success");
233 return;
234 }
235
OnOpen(OHOS::NativeRdb::RdbStore & store)236 int RequestDBOpenCallback::OnOpen(OHOS::NativeRdb::RdbStore &store)
237 {
238 // Creates request_version table first.
239 int ret = store.ExecuteSql(CREATE_REQUEST_VERSION_TABLE);
240 if (ret != OHOS::NativeRdb::E_OK) {
241 REQUEST_HILOGE("Creates request_version table failed, ret: %{public}d", ret);
242 return ret;
243 }
244 REQUEST_HILOGI("Creates request_version table success");
245
246 // ..then creates request_task table.
247 ret = store.ExecuteSql(CREATE_REQUEST_TASK_TABLE);
248 if (ret != OHOS::NativeRdb::E_OK) {
249 REQUEST_HILOGE("Creates request_task table failed, ret: %{public}d", ret);
250 return ret;
251 }
252 REQUEST_HILOGI("Creates request_task table success");
253
254 RequestDBUpgrade(store);
255 RequestDBUpdateInvalidRecords(store);
256
257 return ret;
258 }
259
OnUpgrade(OHOS::NativeRdb::RdbStore & store,int oldVersion,int newVersion)260 int RequestDBOpenCallback::OnUpgrade(OHOS::NativeRdb::RdbStore &store, int oldVersion, int newVersion)
261 {
262 return OHOS::NativeRdb::E_OK;
263 }
264
OnDowngrade(OHOS::NativeRdb::RdbStore & store,int oldVersion,int newVersion)265 int RequestDBOpenCallback::OnDowngrade(OHOS::NativeRdb::RdbStore &store, int oldVersion, int newVersion)
266 {
267 return OHOS::NativeRdb::E_OK;
268 }
269 } // namespace OHOS::Request
270
271 namespace {
CFormItemToBlob(const CFormItem * cpointer,uint32_t length)272 std::vector<uint8_t> CFormItemToBlob(const CFormItem *cpointer, uint32_t length)
273 {
274 std::vector<uint8_t> blob;
275 for (uint32_t i = 0; i < length; ++i) {
276 const CFormItem &obj = cpointer[i];
277 const uint8_t *objBytes = reinterpret_cast<const uint8_t *>(&obj);
278 blob.insert(blob.end(), objBytes, objBytes + sizeof(CFormItem));
279 blob.insert(blob.end(), obj.name.cStr, obj.name.cStr + obj.name.len);
280 blob.insert(blob.end(), obj.value.cStr, obj.value.cStr + obj.value.len);
281 }
282 return blob;
283 }
284
BlobToCFormItem(const std::vector<uint8_t> & blob)285 std::vector<CFormItem> BlobToCFormItem(const std::vector<uint8_t> &blob)
286 {
287 std::vector<CFormItem> vec;
288 size_t position = 0;
289 while (position < blob.size()) {
290 CFormItem obj;
291 memcpy_s(&obj, sizeof(CFormItem), blob.data() + position, sizeof(CFormItem));
292 position += sizeof(CFormItem);
293
294 obj.name.cStr = new char[obj.name.len];
295 memcpy_s(obj.name.cStr, obj.name.len, blob.data() + position, obj.name.len);
296 position += obj.name.len;
297
298 obj.value.cStr = new char[obj.value.len];
299 memcpy_s(obj.value.cStr, obj.value.len, blob.data() + position, obj.value.len);
300 position += obj.value.len;
301
302 vec.push_back(obj);
303 }
304 return vec;
305 }
306
CFileSpecToBlob(const CFileSpec * cpointer,uint32_t length)307 std::vector<uint8_t> CFileSpecToBlob(const CFileSpec *cpointer, uint32_t length)
308 {
309 std::vector<uint8_t> blob;
310 for (uint32_t i = 0; i < length; ++i) {
311 const CFileSpec &obj = cpointer[i];
312 const uint8_t *objBytes = reinterpret_cast<const uint8_t *>(&obj);
313 blob.insert(blob.end(), objBytes, objBytes + sizeof(CFileSpec));
314 blob.insert(blob.end(), obj.name.cStr, obj.name.cStr + obj.name.len);
315 blob.insert(blob.end(), obj.path.cStr, obj.path.cStr + obj.path.len);
316 blob.insert(blob.end(), obj.fileName.cStr, obj.fileName.cStr + obj.fileName.len);
317 blob.insert(blob.end(), obj.mimeType.cStr, obj.mimeType.cStr + obj.mimeType.len);
318 }
319 return blob;
320 }
321
BlobToCFileSpec(const std::vector<uint8_t> & blob)322 std::vector<CFileSpec> BlobToCFileSpec(const std::vector<uint8_t> &blob)
323 {
324 std::vector<CFileSpec> vec;
325 size_t position = 0;
326 while (position < blob.size()) {
327 CFileSpec obj;
328 memcpy_s(&obj, sizeof(CFileSpec), blob.data() + position, sizeof(CFileSpec));
329 position += sizeof(CFileSpec);
330
331 obj.name.cStr = new char[obj.name.len];
332 memcpy_s(obj.name.cStr, obj.name.len, blob.data() + position, obj.name.len);
333 position += obj.name.len;
334
335 obj.path.cStr = new char[obj.path.len];
336 memcpy_s(obj.path.cStr, obj.path.len, blob.data() + position, obj.path.len);
337 position += obj.path.len;
338
339 obj.fileName.cStr = new char[obj.fileName.len];
340 memcpy_s(obj.fileName.cStr, obj.fileName.len, blob.data() + position, obj.fileName.len);
341 position += obj.fileName.len;
342
343 obj.mimeType.cStr = new char[obj.mimeType.len];
344 memcpy_s(obj.mimeType.cStr, obj.mimeType.len, blob.data() + position, obj.mimeType.len);
345 position += obj.mimeType.len;
346
347 vec.push_back(obj);
348 }
349 return vec;
350 }
351
CEachFileStatusToBlob(const CEachFileStatus * cpointer,uint32_t length)352 std::vector<uint8_t> CEachFileStatusToBlob(const CEachFileStatus *cpointer, uint32_t length)
353 {
354 std::vector<uint8_t> blob;
355 for (uint32_t i = 0; i < length; ++i) {
356 const CEachFileStatus &obj = cpointer[i];
357 const uint8_t *objBytes = reinterpret_cast<const uint8_t *>(&obj);
358 blob.insert(blob.end(), objBytes, objBytes + sizeof(CEachFileStatus));
359 blob.insert(blob.end(), obj.path.cStr, obj.path.cStr + obj.path.len);
360 blob.insert(blob.end(), &obj.reason, &obj.reason + sizeof(uint8_t));
361 blob.insert(blob.end(), obj.message.cStr, obj.message.cStr + obj.message.len);
362 }
363 return blob;
364 }
365
BlobToCEachFileStatus(const std::vector<uint8_t> & blob)366 std::vector<CEachFileStatus> BlobToCEachFileStatus(const std::vector<uint8_t> &blob)
367 {
368 std::vector<CEachFileStatus> vec;
369 size_t position = 0;
370 while (position < blob.size()) {
371 CEachFileStatus obj;
372 memcpy_s(&obj, sizeof(CEachFileStatus), blob.data() + position, sizeof(CEachFileStatus));
373 position += sizeof(CEachFileStatus);
374
375 obj.path.cStr = new char[obj.path.len];
376 memcpy_s(obj.path.cStr, obj.path.len, blob.data() + position, obj.path.len);
377 position += obj.path.len;
378
379 memcpy_s(&obj.reason, sizeof(uint8_t), blob.data() + position, sizeof(uint8_t));
380 position += sizeof(uint8_t);
381
382 obj.message.cStr = new char[obj.message.len];
383 memcpy_s(obj.message.cStr, obj.message.len, blob.data() + position, obj.message.len);
384 position += obj.message.len;
385
386 vec.push_back(obj);
387 }
388 return vec;
389 }
390
CStringToBlob(const CStringWrapper * cpointer,uint32_t length)391 std::vector<uint8_t> CStringToBlob(const CStringWrapper *cpointer, uint32_t length)
392 {
393 std::vector<uint8_t> blob;
394 for (uint32_t i = 0; i < length; ++i) {
395 const CStringWrapper &obj = cpointer[i];
396 blob.push_back(static_cast<uint8_t>(obj.len));
397 blob.insert(blob.end(), obj.cStr, obj.cStr + obj.len);
398 }
399 return blob;
400 }
401
BlobToStringVec(const std::vector<uint8_t> & blob)402 std::vector<std::string> BlobToStringVec(const std::vector<uint8_t> &blob)
403 {
404 std::vector<std::string> vec;
405 uint32_t position = 0;
406 while (position < blob.size()) {
407 uint32_t len = static_cast<uint32_t>(blob[position++]);
408 std::string str(blob.begin() + position, blob.begin() + position + len);
409 position += len;
410
411 vec.push_back(std::move(str));
412 }
413
414 return vec;
415 }
416
417 // convert vector<CFormItem> to vector<FormItem>
VecToFormItem(const std::vector<CFormItem> & cvec)418 std::vector<FormItem> VecToFormItem(const std::vector<CFormItem> &cvec)
419 {
420 std::vector<FormItem> vec;
421 for (const CFormItem &obj : cvec) {
422 FormItem formItem;
423 formItem.name = std::string(obj.name.cStr, obj.name.len);
424 formItem.value = std::string(obj.value.cStr, obj.value.len);
425 vec.push_back(std::move(formItem));
426 }
427 return vec;
428 }
429
430 // convert vector<CFileSpec> to vector<FileSpec>
VecToFileSpec(const std::vector<CFileSpec> & cvec)431 std::vector<FileSpec> VecToFileSpec(const std::vector<CFileSpec> &cvec)
432 {
433 std::vector<FileSpec> vec;
434 for (const CFileSpec &obj : cvec) {
435 FileSpec fileSpec;
436 fileSpec.name = std::string(obj.name.cStr, obj.name.len);
437 fileSpec.path = std::string(obj.path.cStr, obj.path.len);
438 fileSpec.fileName = std::string(obj.fileName.cStr, obj.fileName.len);
439 fileSpec.mimeType = std::string(obj.mimeType.cStr, obj.mimeType.len);
440 vec.push_back(std::move(fileSpec));
441 }
442 return vec;
443 }
444
445 // convert vector<CEachFileStatus> to vector<EachFileStatus>
VecToEachFileStatus(const std::vector<CEachFileStatus> & cvec)446 std::vector<EachFileStatus> VecToEachFileStatus(const std::vector<CEachFileStatus> &cvec)
447 {
448 std::vector<EachFileStatus> vec;
449 for (const CEachFileStatus &obj : cvec) {
450 EachFileStatus eachFileStatus;
451 eachFileStatus.path = std::string(obj.path.cStr, obj.path.len);
452 eachFileStatus.reason = obj.reason;
453 eachFileStatus.message = std::string(obj.message.cStr, obj.message.len);
454 vec.push_back(std::move(eachFileStatus));
455 }
456 return vec;
457 }
458
WriteUpdateData(OHOS::NativeRdb::ValuesBucket & insertValues,T * info)459 template<typename T> bool WriteUpdateData(OHOS::NativeRdb::ValuesBucket &insertValues, T *info)
460 {
461 std::vector<uint8_t> eachFileStatusBlob = CEachFileStatusToBlob(info->eachFileStatusPtr, info->eachFileStatusLen);
462 // write to insertValues
463 insertValues.PutString("mime_type", std::string(info->mimeType.cStr, info->mimeType.len));
464 insertValues.PutInt("state", info->progress.commonData.state);
465 insertValues.PutLong("idx", info->progress.commonData.index);
466 insertValues.PutLong("total_processed", info->progress.commonData.totalProcessed);
467 insertValues.PutString("sizes", std::string(info->progress.sizes.cStr, info->progress.sizes.len));
468 insertValues.PutString("processed", std::string(info->progress.processed.cStr, info->progress.processed.len));
469 insertValues.PutString("extras", std::string(info->progress.extras.cStr, info->progress.extras.len));
470 insertValues.PutBlob("each_file_status", eachFileStatusBlob);
471 return true;
472 }
473
WriteMutableData(OHOS::NativeRdb::ValuesBucket & insertValues,CTaskInfo * taskInfo,CTaskConfig * taskConfig)474 bool WriteMutableData(OHOS::NativeRdb::ValuesBucket &insertValues, CTaskInfo *taskInfo, CTaskConfig *taskConfig)
475 {
476 insertValues.PutLong("mtime", taskInfo->commonData.mtime);
477 insertValues.PutInt("reason", taskInfo->commonData.reason);
478 insertValues.PutLong("tries", taskInfo->commonData.tries);
479 if (!WriteUpdateData(insertValues, taskInfo)) {
480 return false;
481 }
482 // write vectors
483 insertValues.PutBlob("form_items", CFormItemToBlob(taskConfig->formItemsPtr, taskConfig->formItemsLen));
484 insertValues.PutBlob("file_specs", CFileSpecToBlob(taskConfig->fileSpecsPtr, taskConfig->fileSpecsLen));
485 insertValues.PutBlob("body_file_names", CStringToBlob(taskConfig->bodyFileNamesPtr, taskConfig->bodyFileNamesLen));
486 insertValues.PutBlob("certs_paths", CStringToBlob(taskConfig->certsPathPtr, taskConfig->certsPathLen));
487 return true;
488 }
489
GetLong(std::shared_ptr<OHOS::NativeRdb::ResultSet> resultSet,int line)490 inline int64_t GetLong(std::shared_ptr<OHOS::NativeRdb::ResultSet> resultSet, int line)
491 {
492 int64_t value = 0;
493 resultSet->GetLong(line, value);
494 return value;
495 }
496
GetInt(std::shared_ptr<OHOS::NativeRdb::ResultSet> resultSet,int line)497 inline int GetInt(std::shared_ptr<OHOS::NativeRdb::ResultSet> resultSet, int line)
498 {
499 int value = 0;
500 resultSet->GetInt(line, value);
501 return value;
502 }
503
GetRequestTaskInfoByTouch(std::shared_ptr<OHOS::NativeRdb::ResultSet> set,TaskInfo & info)504 void GetRequestTaskInfoByTouch(std::shared_ptr<OHOS::NativeRdb::ResultSet> set, TaskInfo &info)
505 {
506 info.commonData.priority = static_cast<uint32_t>(GetLong(set, 11)); // Line 11 is 'priority'
507 info.progress.commonData.state = static_cast<uint8_t>(GetInt(set, 17)); // Line 17 here is 'state'
508 info.progress.commonData.index = static_cast<uint8_t>(GetLong(set, 18)); // Line 18 here is 'idx'
509 uintptr_t totalProcessed = static_cast<uintptr_t>(GetLong(set, 19)); // Line 19 is 'totalProcessed'
510 info.progress.commonData.totalProcessed = totalProcessed;
511
512 set->GetString(12, info.url); // Line 12 is 'url'
513 set->GetString(13, info.data); // Line 13 is 'data'
514 set->GetString(14, info.title); // Line 14 is 'title'
515 set->GetString(15, info.description); // Line 15 is 'description'
516 set->GetString(16, info.mimeType); // Line 16 is 'mime_type'
517 set->GetString(20, info.progress.sizes); // Line 20 here is 'sizes'
518 set->GetString(21, info.progress.processed); // Line 21 here is 'processed'
519 set->GetString(22, info.progress.extras); // Line 22 here is 'extras'
520
521 std::vector<uint8_t> formItemsBlob;
522 std::vector<uint8_t> formSpecsBlob;
523 std::vector<uint8_t> eachFileStatusBlob;
524
525 set->GetBlob(23, formItemsBlob); // Line 23 is 'form_items'
526 info.formItems = VecToFormItem(BlobToCFormItem(formItemsBlob));
527 set->GetBlob(24, formSpecsBlob); // Line 24 is 'file_specs'
528 info.fileSpecs = VecToFileSpec(BlobToCFileSpec(formSpecsBlob));
529 set->GetBlob(25, eachFileStatusBlob); // Line 25 is 'each_file_status'
530 info.eachFileStatus = VecToEachFileStatus(BlobToCEachFileStatus(eachFileStatusBlob));
531 }
532
GetRequestTaskInfoByQuery(std::shared_ptr<OHOS::NativeRdb::ResultSet> set,TaskInfo & info)533 void GetRequestTaskInfoByQuery(std::shared_ptr<OHOS::NativeRdb::ResultSet> set, TaskInfo &info)
534 {
535 info.progress.commonData.state = static_cast<uint8_t>(GetInt(set, 15)); // Line 15 is 'state'
536 info.progress.commonData.index = static_cast<uint8_t>(GetLong(set, 16)); // Line 16 is 'idx'
537 uintptr_t totalProcessed = static_cast<uintptr_t>(GetLong(set, 17)); // Line 17 is 'totalProcessed'
538 info.progress.commonData.totalProcessed = totalProcessed;
539
540 set->GetString(11, info.bundle); // Line 11 is 'bundle'
541 set->GetString(12, info.title); // Line 12 is 'title'
542 set->GetString(13, info.description); // Line 13 is 'description'
543 set->GetString(14, info.mimeType); // Line 14 is 'mime_type'
544
545 set->GetString(18, info.progress.sizes); // Line 18 is 'sizes'
546 set->GetString(19, info.progress.processed); // Line 19 is 'processed'
547 set->GetString(20, info.progress.extras); // Line 20 is 'extras'
548
549 std::vector<uint8_t> formItemsBlob;
550 std::vector<uint8_t> formSpecsBlob;
551 std::vector<uint8_t> eachFileStatusBlob;
552
553 set->GetBlob(21, formItemsBlob); // Line 21 is 'form_items'
554 info.formItems = VecToFormItem(BlobToCFormItem(formItemsBlob));
555 set->GetBlob(22, formSpecsBlob); // Line 22 is 'file_specs'
556 info.fileSpecs = VecToFileSpec(BlobToCFileSpec(formSpecsBlob));
557 set->GetBlob(23, eachFileStatusBlob); // Line 23 is 'each_file_status'
558 info.eachFileStatus = VecToEachFileStatus(BlobToCEachFileStatus(eachFileStatusBlob));
559 }
560
BuildRequestTaskConfigWithLong(std::shared_ptr<OHOS::NativeRdb::ResultSet> set,TaskConfig & config)561 void BuildRequestTaskConfigWithLong(std::shared_ptr<OHOS::NativeRdb::ResultSet> set, TaskConfig &config)
562 {
563 config.commonData.taskId = static_cast<uint32_t>(GetLong(set, 0)); // Line 0 is 'task_id'
564 config.commonData.uid = static_cast<uint64_t>(GetLong(set, 1)); // Line 1 is 'uid'
565 config.commonData.tokenId = static_cast<uint64_t>(GetLong(set, 2)); // Line 2 is 'token_id'
566 config.commonData.index = static_cast<uint32_t>(GetLong(set, 11)); // Line 11 is 'config_idx'
567 config.commonData.begins = static_cast<uint64_t>(GetLong(set, 12)); // Line 12 is 'begins'
568 config.commonData.ends = static_cast<int64_t>(GetLong(set, 13)); // Line 13 is 'ends'
569 config.commonData.priority = static_cast<uint32_t>(GetLong(set, 16)); // Line 16 is 'priority'
570 }
571
BuildRequestTaskConfigWithInt(std::shared_ptr<OHOS::NativeRdb::ResultSet> set,TaskConfig & config)572 void BuildRequestTaskConfigWithInt(std::shared_ptr<OHOS::NativeRdb::ResultSet> set, TaskConfig &config)
573 {
574 config.commonData.action = static_cast<uint8_t>(GetInt(set, 3)); // Line 3 is 'action'
575 config.commonData.mode = static_cast<uint8_t>(GetInt(set, 4)); // Line 4 is 'mode'
576 config.commonData.cover = static_cast<bool>(GetInt(set, 5)); // Line 5 is 'cover'
577 config.commonData.network = static_cast<uint8_t>(GetInt(set, 6)); // Line 6 is 'network'
578 config.commonData.metered = static_cast<bool>(GetInt(set, 7)); // Line 7 is 'metered'
579 config.commonData.roaming = static_cast<bool>(GetInt(set, 8)); // Line 8 is 'roaming'
580 config.commonData.retry = static_cast<bool>(GetInt(set, 9)); // Line 9 is 'retry'
581 config.commonData.redirect = static_cast<bool>(GetInt(set, 10)); // Line 10 is 'redirect'
582 config.commonData.gauge = static_cast<bool>(GetInt(set, 14)); // Line 14 is 'gauge'
583 config.commonData.precise = static_cast<bool>(GetInt(set, 15)); // Line 15 is 'precise'
584 config.commonData.background = static_cast<bool>(GetInt(set, 17)); // Line 17 is 'background'
585 config.version = static_cast<uint8_t>(GetInt(set, 27)); // Line 27 here is 'version'
586 }
587
BuildRequestTaskConfigWithString(std::shared_ptr<OHOS::NativeRdb::ResultSet> set,TaskConfig & config)588 void BuildRequestTaskConfigWithString(std::shared_ptr<OHOS::NativeRdb::ResultSet> set, TaskConfig &config)
589 {
590 set->GetString(18, config.bundle); // Line 18 is 'bundle'
591 set->GetString(19, config.url); // Line 19 is 'url'
592 set->GetString(20, config.title); // Line 20 is 'title'
593 set->GetString(21, config.description); // Line 21 is 'description'
594 set->GetString(22, config.method); // Line 22 is 'method'
595 set->GetString(23, config.headers); // Line 23 is 'headers'
596 set->GetString(24, config.data); // Line 24 is 'data'
597 set->GetString(25, config.token); // Line 25 is 'token'
598 set->GetString(26, config.extras); // Line 26 is 'config_extras'
599 }
600
BuildRequestTaskConfigWithBlob(std::shared_ptr<OHOS::NativeRdb::ResultSet> set,TaskConfig & config)601 void BuildRequestTaskConfigWithBlob(std::shared_ptr<OHOS::NativeRdb::ResultSet> set, TaskConfig &config)
602 {
603 std::vector<uint8_t> formItemsBlob;
604 std::vector<uint8_t> formSpecsBlob;
605 std::vector<uint8_t> bodyFileNamesBlob;
606 std::vector<uint8_t> certsPathsBlob;
607
608 set->GetBlob(28, formItemsBlob); // Line 28 is 'form_items'
609 config.formItems = VecToFormItem(BlobToCFormItem(formItemsBlob));
610 set->GetBlob(29, formSpecsBlob); // Line 29 is 'file_specs'
611 config.fileSpecs = VecToFileSpec(BlobToCFileSpec(formSpecsBlob));
612 set->GetBlob(30, bodyFileNamesBlob); // Line 30 is 'body_file_names'
613 config.bodyFileNames = BlobToStringVec(bodyFileNamesBlob);
614 set->GetBlob(31, certsPathsBlob); // Line 31 is 'certs_paths'
615 config.certsPath = BlobToStringVec(certsPathsBlob);
616 }
617
BuildRequestTaskConfig(std::shared_ptr<OHOS::NativeRdb::ResultSet> resultSet)618 TaskConfig BuildRequestTaskConfig(std::shared_ptr<OHOS::NativeRdb::ResultSet> resultSet)
619 {
620 TaskConfig taskConfig;
621 BuildRequestTaskConfigWithLong(resultSet, taskConfig);
622 BuildRequestTaskConfigWithInt(resultSet, taskConfig);
623 BuildRequestTaskConfigWithString(resultSet, taskConfig);
624 BuildRequestTaskConfigWithBlob(resultSet, taskConfig);
625 return taskConfig;
626 }
627 } // anonymous namespace
628
HasRequestTaskRecord(uint32_t taskId)629 bool HasRequestTaskRecord(uint32_t taskId)
630 {
631 OHOS::NativeRdb::RdbPredicates rdbPredicates("request_task");
632 rdbPredicates.EqualTo("task_id", std::to_string(taskId));
633 auto resultSet = OHOS::Request::RequestDataBase::GetInstance().Query(rdbPredicates, { "task_id" });
634 if (resultSet == nullptr) {
635 REQUEST_HILOGE("result set is nullptr");
636 return false;
637 }
638 int rowCount = 0;
639 resultSet->GetRowCount(rowCount);
640 if (rowCount == 0) {
641 return false;
642 }
643 REQUEST_HILOGD("has the task record in database");
644 return true;
645 }
646
RecordRequestTask(CTaskInfo * taskInfo,CTaskConfig * taskConfig)647 bool RecordRequestTask(CTaskInfo *taskInfo, CTaskConfig *taskConfig)
648 {
649 REQUEST_HILOGD("write to request_task");
650 OHOS::NativeRdb::ValuesBucket insertValues;
651 insertValues.PutLong("task_id", taskConfig->commonData.taskId);
652 insertValues.PutLong("uid", taskConfig->commonData.uid);
653 insertValues.PutLong("token_id", taskConfig->commonData.tokenId);
654 insertValues.PutInt("action", taskConfig->commonData.action);
655 insertValues.PutInt("mode", taskConfig->commonData.mode);
656 insertValues.PutInt("cover", taskConfig->commonData.cover);
657 insertValues.PutInt("network", taskConfig->commonData.network);
658 insertValues.PutInt("metered", taskConfig->commonData.metered);
659 insertValues.PutInt("roaming", taskConfig->commonData.roaming);
660 insertValues.PutLong("ctime", taskInfo->commonData.ctime);
661 insertValues.PutInt("gauge", taskConfig->commonData.gauge);
662 insertValues.PutInt("retry", taskConfig->commonData.retry);
663 insertValues.PutInt("redirect", taskConfig->commonData.redirect);
664 insertValues.PutInt("version", taskConfig->version);
665 insertValues.PutLong("config_idx", taskConfig->commonData.index);
666 insertValues.PutLong("begins", taskConfig->commonData.begins);
667 insertValues.PutLong("ends", taskConfig->commonData.ends);
668 insertValues.PutInt("precise", taskConfig->commonData.precise);
669 insertValues.PutLong("priority", taskConfig->commonData.priority);
670 insertValues.PutInt("background", taskConfig->commonData.background);
671 insertValues.PutString("bundle", std::string(taskConfig->bundle.cStr, taskConfig->bundle.len));
672 insertValues.PutString("url", std::string(taskConfig->url.cStr, taskConfig->url.len));
673 insertValues.PutString("data", std::string(taskConfig->data.cStr, taskConfig->data.len));
674 insertValues.PutString("token", std::string(taskConfig->token.cStr, taskConfig->token.len));
675 insertValues.PutString("title", std::string(taskConfig->title.cStr, taskConfig->title.len));
676 insertValues.PutString("description", std::string(taskConfig->description.cStr, taskConfig->description.len));
677 insertValues.PutString("method", std::string(taskConfig->method.cStr, taskConfig->method.len));
678 insertValues.PutString("headers", std::string(taskConfig->headers.cStr, taskConfig->headers.len));
679 insertValues.PutString("config_extras", std::string(taskConfig->extras.cStr, taskConfig->extras.len));
680 if (!WriteMutableData(insertValues, taskInfo, taskConfig)) {
681 REQUEST_HILOGE("write blob data failed");
682 return false;
683 }
684 if (!OHOS::Request::RequestDataBase::GetInstance().Insert(std::string("request_task"), insertValues)) {
685 REQUEST_HILOGE("insert to request_task failed");
686 return false;
687 }
688 REQUEST_HILOGD("insert to request_task success");
689 return true;
690 }
691
UpdateRequestTask(uint32_t taskId,CUpdateInfo * updateInfo)692 bool UpdateRequestTask(uint32_t taskId, CUpdateInfo *updateInfo)
693 {
694 REQUEST_HILOGD("update request_task");
695 OHOS::NativeRdb::ValuesBucket values;
696 values.PutLong("mtime", updateInfo->mtime);
697 values.PutInt("reason", updateInfo->reason);
698 values.PutLong("tries", updateInfo->tries);
699 if (!WriteUpdateData(values, updateInfo)) {
700 REQUEST_HILOGE("update blob data failed");
701 return false;
702 }
703
704 OHOS::NativeRdb::RdbPredicates rdbPredicates("request_task");
705 rdbPredicates.EqualTo("task_id", std::to_string(taskId));
706 if (!OHOS::Request::RequestDataBase::GetInstance().Update(values, rdbPredicates)) {
707 REQUEST_HILOGE("update table1 failed");
708 return false;
709 }
710 return true;
711 }
712
ChangeRequestTaskState(uint32_t taskId,uint64_t uid,State state)713 bool ChangeRequestTaskState(uint32_t taskId, uint64_t uid, State state)
714 {
715 REQUEST_HILOGI("Change Request Task State");
716
717 OHOS::NativeRdb::ValuesBucket values;
718 values.PutInt("state", static_cast<uint8_t>(state));
719
720 OHOS::NativeRdb::RdbPredicates rdbPredicates("request_task");
721 rdbPredicates.EqualTo("task_id", std::to_string(taskId))->And()->EqualTo("uid", std::to_string(uid));
722 if (!OHOS::Request::RequestDataBase::GetInstance().Update(values, rdbPredicates)) {
723 REQUEST_HILOGE("Change request_task state failed");
724 return false;
725 }
726 return true;
727 }
728
Show(uint32_t taskId,uint64_t uid)729 CTaskInfo *Show(uint32_t taskId, uint64_t uid)
730 {
731 OHOS::NativeRdb::RdbPredicates rdbPredicates1("request_task");
732 rdbPredicates1.EqualTo("task_id", std::to_string(taskId))->And()->EqualTo("uid", std::to_string(uid));
733 TaskInfo taskInfo;
734 if (TouchRequestTaskInfo(rdbPredicates1, taskInfo) == OHOS::Request::QUERY_ERR) {
735 return nullptr;
736 }
737
738 return BuildCTaskInfo(taskInfo);
739 }
740
Touch(uint32_t taskId,uint64_t uid,CStringWrapper token)741 CTaskInfo *Touch(uint32_t taskId, uint64_t uid, CStringWrapper token)
742 {
743 OHOS::NativeRdb::RdbPredicates rdbPredicates1("request_task");
744 rdbPredicates1.EqualTo("task_id", std::to_string(taskId))
745 ->And()
746 ->EqualTo("uid", std::to_string(uid))
747 ->And()
748 ->EqualTo("token", std::string(token.cStr, token.len));
749 TaskInfo taskInfo;
750 if (TouchRequestTaskInfo(rdbPredicates1, taskInfo) == OHOS::Request::QUERY_ERR) {
751 return nullptr;
752 }
753
754 return BuildCTaskInfo(taskInfo);
755 }
756
Query(uint32_t taskId,Action queryAction)757 CTaskInfo *Query(uint32_t taskId, Action queryAction)
758 {
759 OHOS::NativeRdb::RdbPredicates rdbPredicates1("request_task");
760 rdbPredicates1.EqualTo("task_id", std::to_string(taskId));
761 if (queryAction != Action::ANY) {
762 rdbPredicates1.EqualTo("action", std::to_string(static_cast<uint8_t>(queryAction)));
763 }
764 TaskInfo taskInfo;
765 if (QueryRequestTaskInfo(rdbPredicates1, taskInfo) == OHOS::Request::QUERY_ERR) {
766 return nullptr;
767 }
768
769 return BuildCTaskInfo(taskInfo);
770 }
771
Search(CFilter filter)772 CVectorWrapper Search(CFilter filter)
773 {
774 CVectorWrapper cVectorWrapper;
775 cVectorWrapper.ptr = nullptr;
776 cVectorWrapper.len = 0;
777 OHOS::NativeRdb::RdbPredicates rdbPredicates("request_task");
778 std::string bundle = std::string(filter.bundle.cStr, filter.bundle.len);
779 rdbPredicates.Between("ctime", std::to_string(filter.commonData.after), std::to_string(filter.commonData.before));
780 if (filter.commonData.state != static_cast<uint8_t>(State::ANY)) {
781 rdbPredicates.EqualTo("state", std::to_string(filter.commonData.state));
782 }
783 if (filter.commonData.action != static_cast<uint8_t>(Action::ANY)) {
784 rdbPredicates.EqualTo("action", std::to_string(filter.commonData.action));
785 }
786 if (filter.commonData.mode != static_cast<uint8_t>(Mode::ANY)) {
787 rdbPredicates.EqualTo("mode", std::to_string(filter.commonData.mode));
788 }
789 if (bundle != "*") {
790 rdbPredicates.EqualTo("bundle", bundle);
791 }
792 auto resultSet = OHOS::Request::RequestDataBase::GetInstance().Query(rdbPredicates, { "task_id" });
793 if (resultSet == nullptr) {
794 REQUEST_HILOGE("result set is nullptr");
795 return cVectorWrapper;
796 }
797 int rowCount = 0;
798 resultSet->GetRowCount(rowCount);
799 cVectorWrapper.ptr = new uint32_t[rowCount];
800 cVectorWrapper.len = static_cast<uint64_t>(rowCount);
801 for (int i = 0; i < rowCount; i++) {
802 if (resultSet->GoToRow(i) != OHOS::NativeRdb::E_OK) {
803 REQUEST_HILOGE("result set go to %{public}d row failed", i);
804 cVectorWrapper.ptr = nullptr;
805 return cVectorWrapper;
806 }
807 int64_t taskId = 0;
808 resultSet->GetLong(0, taskId);
809 cVectorWrapper.ptr[i] = static_cast<uint32_t>(taskId);
810 }
811 return cVectorWrapper;
812 }
813
DeleteCVectorWrapper(uint32_t * ptr)814 void DeleteCVectorWrapper(uint32_t *ptr)
815 {
816 delete[] ptr;
817 }
818
GetCommonTaskInfo(std::shared_ptr<OHOS::NativeRdb::ResultSet> set,TaskInfo & info)819 void GetCommonTaskInfo(std::shared_ptr<OHOS::NativeRdb::ResultSet> set, TaskInfo &info)
820 {
821 info.commonData.taskId = static_cast<uint32_t>(GetLong(set, 0)); // Line 0 is 'task_id'
822 info.commonData.uid = static_cast<uint64_t>(GetLong(set, 1)); // Line 1 is 'uid'
823 info.commonData.ctime = static_cast<uint64_t>(GetLong(set, 4)); // Line 4 is 'ctime'
824 info.commonData.mtime = static_cast<uint64_t>(GetLong(set, 5)); // Line 5 is 'mtime'
825 info.commonData.tries = static_cast<uint64_t>(GetLong(set, 9)); // Line 9 is 'tries'
826 info.commonData.version = static_cast<uint8_t>(GetLong(set, 10)); // Line 10 is 'version'
827
828 info.commonData.action = static_cast<uint8_t>(GetInt(set, 2)); // Line 2 is 'action'
829 info.commonData.mode = static_cast<uint8_t>(GetInt(set, 3)); // Line 3 is 'mode'
830 info.commonData.reason = static_cast<uint8_t>(GetInt(set, 6)); // Line 6 is 'reason'
831 info.commonData.gauge = static_cast<bool>(GetInt(set, 7)); // Line 7 is 'gauge'
832 info.commonData.retry = static_cast<bool>(GetInt(set, 8)); // Line 8 is 'retry'
833 }
834
TouchRequestTaskInfo(const OHOS::NativeRdb::RdbPredicates & rdbPredicates,TaskInfo & taskInfo)835 int TouchRequestTaskInfo(const OHOS::NativeRdb::RdbPredicates &rdbPredicates, TaskInfo &taskInfo)
836 {
837 auto resultSet = OHOS::Request::RequestDataBase::GetInstance().Query(rdbPredicates,
838 { "task_id", "uid", "action", "mode", "ctime", "mtime", "reason", "gauge", "retry", "tries", "version",
839 "priority", "url", "data", "title", "description", "mime_type", "state", "idx", "total_processed", "sizes",
840 "processed", "extras", "form_items", "file_specs", "each_file_status" });
841 if (resultSet == nullptr || resultSet->GoToFirstRow() != OHOS::NativeRdb::E_OK) {
842 REQUEST_HILOGE("result set is nullptr or go to first row failed");
843 return OHOS::Request::QUERY_ERR;
844 }
845 GetCommonTaskInfo(resultSet, taskInfo);
846 GetRequestTaskInfoByTouch(resultSet, taskInfo);
847 resultSet->Close();
848 return OHOS::Request::QUERY_OK;
849 }
850
QueryRequestTaskInfo(const OHOS::NativeRdb::RdbPredicates & rdbPredicates,TaskInfo & taskInfo)851 int QueryRequestTaskInfo(const OHOS::NativeRdb::RdbPredicates &rdbPredicates, TaskInfo &taskInfo)
852 {
853 auto resultSet = OHOS::Request::RequestDataBase::GetInstance().Query(
854 rdbPredicates, { "task_id", "uid", "action", "mode", "ctime", "mtime", "reason", "gauge", "retry", "tries",
855 "version", "bundle", "title", "description", "mime_type", "state", "idx", "total_processed",
856 "sizes", "processed", "extras", "form_items", "file_specs", "each_file_status" });
857 if (resultSet == nullptr || resultSet->GoToFirstRow() != OHOS::NativeRdb::E_OK) {
858 REQUEST_HILOGE("result set is nullptr or go to first row failed");
859 return OHOS::Request::QUERY_ERR;
860 }
861 GetCommonTaskInfo(resultSet, taskInfo);
862 GetRequestTaskInfoByQuery(resultSet, taskInfo);
863 resultSet->Close();
864 return OHOS::Request::QUERY_OK;
865 }
866
BuildCTaskInfo(const TaskInfo & taskInfo)867 CTaskInfo *BuildCTaskInfo(const TaskInfo &taskInfo)
868 {
869 uint32_t formItemsLen = taskInfo.formItems.size();
870 CFormItem *formItemsPtr = new CFormItem[formItemsLen];
871 for (uint32_t i = 0; i < formItemsLen; i++) {
872 formItemsPtr[i].name = WrapperCString(taskInfo.formItems[i].name);
873 formItemsPtr[i].value = WrapperCString(taskInfo.formItems[i].value);
874 }
875
876 uint32_t fileSpecsLen = taskInfo.fileSpecs.size();
877 CFileSpec *fileSpecsPtr = new CFileSpec[fileSpecsLen];
878 CEachFileStatus *eachFileStatusPtr = new CEachFileStatus[fileSpecsLen];
879 for (uint32_t i = 0; i < fileSpecsLen; i++) {
880 fileSpecsPtr[i].name = WrapperCString(taskInfo.fileSpecs[i].name);
881 fileSpecsPtr[i].path = WrapperCString(taskInfo.fileSpecs[i].path);
882 fileSpecsPtr[i].fileName = WrapperCString(taskInfo.fileSpecs[i].fileName);
883 fileSpecsPtr[i].mimeType = WrapperCString(taskInfo.fileSpecs[i].mimeType);
884 eachFileStatusPtr[i].path = WrapperCString(taskInfo.eachFileStatus[i].path);
885 eachFileStatusPtr[i].reason = taskInfo.eachFileStatus[i].reason;
886 eachFileStatusPtr[i].message = WrapperCString(taskInfo.eachFileStatus[i].message);
887 }
888
889 CTaskInfo *cTaskInfo = new CTaskInfo;
890 cTaskInfo->bundle = WrapperCString(taskInfo.bundle);
891 cTaskInfo->url = WrapperCString(taskInfo.url);
892 cTaskInfo->data = WrapperCString(taskInfo.data);
893 cTaskInfo->token = WrapperCString(taskInfo.token);
894 cTaskInfo->formItemsPtr = formItemsPtr;
895 cTaskInfo->formItemsLen = formItemsLen;
896 cTaskInfo->fileSpecsPtr = fileSpecsPtr;
897 cTaskInfo->fileSpecsLen = fileSpecsLen;
898 cTaskInfo->title = WrapperCString(taskInfo.title);
899 cTaskInfo->description = WrapperCString(taskInfo.description);
900 cTaskInfo->mimeType = WrapperCString(taskInfo.mimeType);
901 cTaskInfo->progress = BuildCProgress(taskInfo.progress);
902 cTaskInfo->eachFileStatusPtr = eachFileStatusPtr;
903 cTaskInfo->eachFileStatusLen = fileSpecsLen;
904 cTaskInfo->commonData = taskInfo.commonData;
905 return cTaskInfo;
906 }
907
BuildCProgress(const Progress & progress)908 CProgress BuildCProgress(const Progress &progress)
909 {
910 return CProgress{
911 .commonData = progress.commonData,
912 .sizes = WrapperCString(progress.sizes),
913 .processed = WrapperCString(progress.processed),
914 .extras = WrapperCString(progress.extras),
915 };
916 }
917
HasTaskConfigRecord(uint32_t taskId)918 bool HasTaskConfigRecord(uint32_t taskId)
919 {
920 OHOS::NativeRdb::RdbPredicates rdbPredicates("request_task");
921 rdbPredicates.EqualTo("task_id", std::to_string(taskId));
922 auto resultSet = OHOS::Request::RequestDataBase::GetInstance().Query(rdbPredicates, { "task_id" });
923 if (resultSet == nullptr) {
924 REQUEST_HILOGE("TaskConfig result set is nullptr");
925 return false;
926 }
927 int rowCount = 0;
928 if (resultSet->GetRowCount(rowCount) != OHOS::NativeRdb::E_OK) {
929 REQUEST_HILOGE("TaskConfig result count row failed");
930 return false;
931 }
932 if (rowCount == 0) {
933 return false;
934 }
935 REQUEST_HILOGI("has the task record in request_task database");
936 return true;
937 }
938
QueryAllTaskConfig()939 CTaskConfig **QueryAllTaskConfig()
940 {
941 OHOS::NativeRdb::RdbPredicates rdbPredicates("request_task");
942 rdbPredicates.EqualTo("state", static_cast<uint8_t>(State::WAITING))
943 ->Or()
944 ->EqualTo("state", static_cast<uint8_t>(State::PAUSED));
945 std::vector<TaskConfig> taskConfigs;
946 if (QueryRequestTaskConfig(rdbPredicates, taskConfigs) == OHOS::Request::QUERY_ERR) {
947 return nullptr;
948 }
949 return BuildCTaskConfigs(taskConfigs);
950 }
951
QueryTaskConfigLen()952 int QueryTaskConfigLen()
953 {
954 OHOS::NativeRdb::RdbPredicates rdbPredicates("request_task");
955 rdbPredicates.EqualTo("state", static_cast<uint8_t>(State::WAITING))
956 ->Or()
957 ->EqualTo("state", static_cast<uint8_t>(State::PAUSED));
958 auto resultSet = OHOS::Request::RequestDataBase::GetInstance().Query(rdbPredicates, { "task_id", "uid" });
959 int len = 0;
960 if (resultSet == nullptr || resultSet->GetRowCount(len) != OHOS::NativeRdb::E_OK) {
961 REQUEST_HILOGE("Get TaskConfigs length failed");
962 return OHOS::Request::QUERY_ERR;
963 }
964 return len;
965 }
966
QueryRequestTaskConfig(const OHOS::NativeRdb::RdbPredicates & rdbPredicates,std::vector<TaskConfig> & taskConfigs)967 int QueryRequestTaskConfig(const OHOS::NativeRdb::RdbPredicates &rdbPredicates, std::vector<TaskConfig> &taskConfigs)
968 {
969 auto resultSet = OHOS::Request::RequestDataBase::GetInstance().Query(
970 rdbPredicates, { "task_id", "uid", "token_id", "action", "mode", "cover", "network", "metered", "roaming",
971 "retry", "redirect", "config_idx", "begins", "ends", "gauge", "precise", "priority",
972 "background", "bundle", "url", "title", "description", "method", "headers", "data", "token",
973 "config_extras", "version", "form_items", "file_specs", "body_file_names", "certs_paths" });
974 int rowCount = 0;
975 if (resultSet == nullptr || resultSet->GetRowCount(rowCount) != OHOS::NativeRdb::E_OK) {
976 REQUEST_HILOGE("TaskConfig result set is nullptr or get row count failed");
977 return OHOS::Request::QUERY_ERR;
978 }
979 for (auto i = 0; i < rowCount; i++) {
980 if (resultSet->GoToRow(i) != OHOS::NativeRdb::E_OK) {
981 REQUEST_HILOGE("TaskConfig result set go to %{public}d row failed", i);
982 return OHOS::Request::QUERY_ERR;
983 }
984 TaskConfig taskConfig = BuildRequestTaskConfig(resultSet);
985 taskConfigs.push_back(std::move(taskConfig));
986 }
987 resultSet->Close();
988 return OHOS::Request::QUERY_OK;
989 }
990
BuildCTaskConfig(CTaskConfig * cTaskConfig,const TaskConfig & taskConfig)991 void BuildCTaskConfig(CTaskConfig *cTaskConfig, const TaskConfig &taskConfig)
992 {
993 cTaskConfig->bundle = WrapperCString(taskConfig.bundle);
994 cTaskConfig->url = WrapperCString(taskConfig.url);
995 cTaskConfig->title = WrapperCString(taskConfig.title);
996 cTaskConfig->description = WrapperCString(taskConfig.description);
997 cTaskConfig->method = WrapperCString(taskConfig.method);
998 cTaskConfig->headers = WrapperCString(taskConfig.headers);
999 cTaskConfig->data = WrapperCString(taskConfig.data);
1000 cTaskConfig->token = WrapperCString(taskConfig.token);
1001 cTaskConfig->extras = WrapperCString(taskConfig.extras);
1002 cTaskConfig->version = taskConfig.version;
1003
1004 uint32_t formItemsLen = taskConfig.formItems.size();
1005 CFormItem *formItemsPtr = new CFormItem[formItemsLen];
1006 for (uint32_t j = 0; j < formItemsLen; j++) {
1007 formItemsPtr[j].name = WrapperCString(taskConfig.formItems[j].name);
1008 formItemsPtr[j].value = WrapperCString(taskConfig.formItems[j].value);
1009 }
1010 uint32_t fileSpecsLen = taskConfig.fileSpecs.size();
1011 CFileSpec *fileSpecsPtr = new CFileSpec[fileSpecsLen];
1012 for (uint32_t j = 0; j < fileSpecsLen; j++) {
1013 fileSpecsPtr[j].name = WrapperCString(taskConfig.fileSpecs[j].name);
1014 fileSpecsPtr[j].path = WrapperCString(taskConfig.fileSpecs[j].path);
1015 fileSpecsPtr[j].fileName = WrapperCString(taskConfig.fileSpecs[j].fileName);
1016 fileSpecsPtr[j].mimeType = WrapperCString(taskConfig.fileSpecs[j].mimeType);
1017 }
1018 uint32_t bodyFileNamesLen = taskConfig.bodyFileNames.size();
1019 CStringWrapper *bodyFileNamesPtr = new CStringWrapper[bodyFileNamesLen];
1020 for (uint32_t j = 0; j < bodyFileNamesLen; j++) {
1021 bodyFileNamesPtr[j] = WrapperCString(taskConfig.bodyFileNames[j]);
1022 }
1023
1024 uint32_t certsPathLen = taskConfig.certsPath.size();
1025 CStringWrapper *certsPathPtr = new CStringWrapper[certsPathLen];
1026 for (uint32_t j = 0; j < certsPathLen; j++) {
1027 certsPathPtr[j] = WrapperCString(taskConfig.certsPath[j]);
1028 }
1029
1030 cTaskConfig->formItemsPtr = formItemsPtr;
1031 cTaskConfig->formItemsLen = formItemsLen;
1032 cTaskConfig->fileSpecsPtr = fileSpecsPtr;
1033 cTaskConfig->fileSpecsLen = fileSpecsLen;
1034 cTaskConfig->bodyFileNamesPtr = bodyFileNamesPtr;
1035 cTaskConfig->bodyFileNamesLen = bodyFileNamesLen;
1036 cTaskConfig->certsPathPtr = certsPathPtr;
1037 cTaskConfig->certsPathLen = certsPathLen;
1038 cTaskConfig->commonData = taskConfig.commonData;
1039 }
1040
BuildCTaskConfigs(const std::vector<TaskConfig> & taskConfigs)1041 CTaskConfig **BuildCTaskConfigs(const std::vector<TaskConfig> &taskConfigs)
1042 {
1043 CTaskConfig **cTaskConfigs = new CTaskConfig *[taskConfigs.size()];
1044 for (unsigned int i = 0; i < taskConfigs.size(); i++) {
1045 CTaskConfig *cTaskConfig = new CTaskConfig;
1046 const TaskConfig &taskConfig = taskConfigs[i];
1047 BuildCTaskConfig(cTaskConfig, taskConfig);
1048 cTaskConfigs[i] = std::move(cTaskConfig);
1049 }
1050 return cTaskConfigs;
1051 }
1052
CleanTaskConfigTable(uint32_t taskId,uint64_t uid)1053 bool CleanTaskConfigTable(uint32_t taskId, uint64_t uid)
1054 {
1055 OHOS::NativeRdb::RdbPredicates predicates("request_task");
1056 predicates.EqualTo("task_id", std::to_string(taskId))->And()->EqualTo("uid", std::to_string(uid));
1057 if (OHOS::Request::RequestDataBase::GetInstance().Delete(predicates)) {
1058 REQUEST_HILOGI("request_task table deletes task success, task_id: %{public}u", taskId);
1059 return true;
1060 }
1061 REQUEST_HILOGE("request_task table deleted task failed, task_id: %{public}u", taskId);
1062 return false;
1063 }
1064
RequestDBRemoveRecordsFromTime(uint64_t time)1065 void RequestDBRemoveRecordsFromTime(uint64_t time)
1066 {
1067 OHOS::NativeRdb::RdbPredicates predicates("request_task");
1068 predicates.LessThan("mtime", std::to_string(time));
1069
1070 if (OHOS::Request::RequestDataBase::GetInstance().Delete(predicates)) {
1071 REQUEST_HILOGI("request_task table deletes records before one week success");
1072 return;
1073 }
1074 REQUEST_HILOGE("request_task table deletes records before one week failed");
1075 return;
1076 }