Implement pkgmgr_parser_insert_manifest_info_in_usr_db

Signed-off-by: Ilho Kim <ilho159.kim@samsung.com>

diff --git a/parser/include/pkgmgr_parser_db.h b/parser/include/pkgmgr_parser_db.h
index e4187aa..4c4b56b 100644 (file)
--- a/parser/include/pkgmgr_parser_db.h
+++ b/parser/include/pkgmgr_parser_db.h
@@ -46,12 +46,15 @@
 extern "C" {
 #endif
 
+#include <sqlite3.h>
+
 #include "pkgmgr_parser.h"
 #include "pkgmgrinfo_type.h"
 
 // TODO: add descriptions
-int pkgmgr_parser_insert_pkg_info(manifest_x *mfx, uid_t uid);
-int pkgmgr_parser_delete_pkg_info(const char *package, uid_t uid);
+int pkgmgr_parser_insert_pkg_info(sqlite3 *db, manifest_x *mfx, uid_t uid);
+int pkgmgr_parser_update_pkg_info(sqlite3 *db, manifest_x *mfx, uid_t uid);
+int pkgmgr_parser_delete_pkg_info(sqlite3 *db, const char *package, uid_t uid);
 
 /**
  * @fn int pkgmgr_parser_insert_manifest_info_in_usr_db(manifest_x *mfx, uid_t uid)

diff --git a/parser/src/pkgmgr_parser_db.c b/parser/src/pkgmgr_parser_db.c
index 380f667..d1ce42b 100644 (file)
--- a/parser/src/pkgmgr_parser_db.c
+++ b/parser/src/pkgmgr_parser_db.c
@@ -2192,24 +2192,31 @@ static int __delete_package_info(sqlite3 *db, const char *pkgid)
        return 0;
 }
 
-API int pkgmgr_parser_insert_pkg_info(manifest_x *mfx, uid_t uid)
+API int pkgmgr_parser_insert_pkg_info(sqlite3 *db, manifest_x *mfx, uid_t uid)
 {
        int ret;
-       const char *dbpath;
-       sqlite3 *db;
 
-       if (mfx == NULL) {
+       if (db == NULL || mfx == NULL) {
                _LOGE("invalid parameter");
                return PM_PARSER_R_EINVAL;
        }
 
-       dbpath = __get_parser_db_path(uid);
+       __BEGIN_TRANSACTION(db);
+       __DO_TRANSACTION(db, __insert_package_info(db, mfx));
+       __END_TRANSACTION(db);
 
-       //ret = __open_db(uid, dbpath, &db, SQLITE_OPEN_READWRITE);
-       ret = 0;
-       if (ret != SQLITE_OK) {
-               _LOGE("open db failed: %d", ret);
-               return PM_PARSER_R_ERROR;
+       sqlite3_close_v2(db);
+
+       return PM_PARSER_R_OK;
+}
+
+API int pkgmgr_parser_update_pkg_info(sqlite3 *db, manifest_x *mfx, uid_t uid)
+{
+       int ret;
+
+       if (db == NULL || mfx == NULL) {
+               _LOGE("invalid parameter");
+               return PM_PARSER_R_EINVAL;
        }
 
        __BEGIN_TRANSACTION(db);
@@ -2224,8 +2231,12 @@ API int pkgmgr_parser_insert_pkg_info(manifest_x *mfx, uid_t uid)
 
 API int pkgmgr_parser_insert_manifest_info_in_usr_db(manifest_x *mfx, uid_t uid)
 {
-       // TODO: use pkginfo-client APIs to send manifest_x to server
-       return 0;
+       if (_parser_insert_manifest_info(mfx, uid) < 0) {
+               _LOGE("Fail to insert manifest uid[%d]", uid);
+               return PM_PARSER_R_ERROR;
+       }
+
+       return PM_PARSER_R_OK;
 }
 
 API int pkgmgr_parser_insert_manifest_info_in_db(manifest_x *mfx)
@@ -2233,26 +2244,15 @@ API int pkgmgr_parser_insert_manifest_info_in_db(manifest_x *mfx)
        return pkgmgr_parser_insert_manifest_info_in_usr_db(mfx, __getuid());
 }
 
-API int pkgmgr_parser_delete_pkg_info(const char *package, uid_t uid)
+API int pkgmgr_parser_delete_pkg_info(sqlite3 *db, const char *package, uid_t uid)
 {
        int ret;
-       const char *dbpath;
-       sqlite3 *db;
 
-       if (package == NULL) {
+       if (db == NULL || package == NULL) {
                _LOGE("invalid parameter");
                return PM_PARSER_R_EINVAL;
        }
 
-       dbpath = __get_parser_db_path(uid);
-
-       //ret = __open_db(uid, dbpath, &db, SQLITE_OPEN_READWRITE);
-       ret = 0;
-       if (ret != SQLITE_OK) {
-               _LOGE("open db failed: %d", ret);
-               return PM_PARSER_R_ERROR;
-       }
-
        __BEGIN_TRANSACTION(db);
        __DO_TRANSACTION(db, __delete_package_info(db, package));
        __END_TRANSACTION(db);
@@ -2263,8 +2263,12 @@ API int pkgmgr_parser_delete_pkg_info(const char *package, uid_t uid)
 API int pkgmgr_parser_delete_manifest_info_from_usr_db(manifest_x *mfx,
        uid_t uid)
 {
-       // TODO: use pkginfo-client APIs to send package id to server
-       return 0;
+       if (_parser_delete_manifest_info(mfx, uid) < 0) {
+               _LOGE("Fail to update manifest uid[%d]", uid);
+               return PM_PARSER_R_ERROR;
+       }
+
+       return PM_PARSER_R_OK;
 }
 
 API int pkgmgr_parser_delete_manifest_info_from_db(manifest_x *mfx)
@@ -2274,7 +2278,12 @@ API int pkgmgr_parser_delete_manifest_info_from_db(manifest_x *mfx)
 
 API int pkgmgr_parser_update_manifest_info_in_usr_db(manifest_x *mfx, uid_t uid)
 {
-       return pkgmgr_parser_insert_manifest_info_in_usr_db(mfx, uid);
+       if (_parser_update_manifest_info(mfx, uid) < 0) {
+               _LOGE("Fail to update manifest uid[%d]", uid);
+               return PM_PARSER_R_ERROR;
+       }
+
+       return PM_PARSER_R_OK;
 }
 
 API int pkgmgr_parser_update_manifest_info_in_db(manifest_x *mfx)

diff --git a/src/common/database/pkg_set_db_handler.cc b/src/common/database/pkg_set_db_handler.cc
index 90fac3d..b1d21a5 100644 (file)
--- a/src/common/database/pkg_set_db_handler.cc
+++ b/src/common/database/pkg_set_db_handler.cc
@@ -28,16 +28,41 @@ PkgSetDBHandler::~PkgSetDBHandler() {}
 
 void PkgSetDBHandler::SetPkgInfo(package_x* package) { package_ = package; }
 void PkgSetDBHandler::SetPkgID(std::string pkgid) { pkgid = std::move(pkgid); }
+void PkgSetDBHandler::SetWriteType(WriteType write_type) { write_type_ = write_type; }
+
+std::vector<std::vector<std::string>>&& PkgSetDBHandler::GetResult() {
+  return std::move(result_);
+}
 
 bool PkgSetDBHandler::Execute() {
   SetOpType(OPERATION_TYPE_WRITE);
-  SetDBType(DB_TYPE_FILE_CERTDB);
-  if (!Connect())
+  SetDBType(DB_TYPE_FILE_PKGDB);
+  result_.clear();
+  result_.resize(1);
+
+  if (!Connect()) {
+    result_[0].emplace_back("FAIL");
     return false;
+  }
+
+  int ret = 0;
 
-  int ret = pkgmgr_parser_insert_pkg_info(package_, uid_);
-  if (ret != PM_PARSER_R_OK)
+  if (write_type_ == Insert) {
+    ret = pkgmgr_parser_insert_pkg_info(GetConnection(), package_, uid_);
+  } else if (write_type_ == Update) {
+    ret = pkgmgr_parser_update_pkg_info(GetConnection(), package_, uid_);
+  } else if (write_type_ == Delete) {
+    ret = pkgmgr_parser_delete_pkg_info(GetConnection(), package_->package, uid_);
+  } else {
+
+  }
+
+  if (ret != PM_PARSER_R_OK) {
+    result_[0].emplace_back("FAIL");
     return false;
+  }
+
+  result_[0].emplace_back("SUCCESS");
 
   return true;
 }

diff --git a/src/common/database/pkg_set_db_handler.hh b/src/common/database/pkg_set_db_handler.hh
index 138e8af..1fda60a 100644 (file)
--- a/src/common/database/pkg_set_db_handler.hh
+++ b/src/common/database/pkg_set_db_handler.hh
@@ -19,6 +19,7 @@
 
 #include <string>
 #include <list>
+#include <vector>
 
 #include <sys/types.h>
 
@@ -26,6 +27,13 @@
 #include "pkgmgrinfo_basic.h"
 #include "pkgmgrinfo_private.h"
 
+enum WriteType {
+  None = -1,
+  Insert,
+  Update,
+  Delete
+};
+
 namespace pkgmgr_common {
 namespace database {
 
@@ -39,12 +47,16 @@ class EXPORT_API PkgSetDBHandler : public AbstractDBHandler{
   ~PkgSetDBHandler();
   void SetPkgInfo(package_x* package);
   void SetPkgID(std::string pkgid);
+  void SetWriteType(WriteType write_type);
   bool Execute() override;
+  std::vector<std::vector<std::string>>&& GetResult();
 
  private:
   std::string pkgid_;
   package_x* package_ = nullptr;
   uid_t uid_;
+  WriteType write_type_ = None;
+  std::vector<std::vector<std::string>> result_;
 };
 
 }  // namespace database

diff --git a/src/common/parcel/pkginfo_parcelable.cc b/src/common/parcel/pkginfo_parcelable.cc
index 721e462..9b7e03f 100644 (file)
--- a/src/common/parcel/pkginfo_parcelable.cc
+++ b/src/common/parcel/pkginfo_parcelable.cc
@@ -439,16 +439,21 @@ package_x *PkgInfoParcelable::ReadPackage(tizen_base::Parcel* parcel) {
 PkgInfoParcelable::PkgInfoParcelable()
     : AbstractParcelable(0, ParcelableType::PkgInfo) {}
 
-PkgInfoParcelable::PkgInfoParcelable(std::vector<package_x *>&& pkg_list)
-    : AbstractParcelable(0, ParcelableType::PkgInfo),
-        pkg_list_(std::move(pkg_list)) {}
+PkgInfoParcelable::PkgInfoParcelable(uid_t uid, std::vector<package_x *>&& pkg_list, WriteType write_type)
+    : AbstractParcelable(uid, ParcelableType::PkgInfo), pkg_list_(std::move(pkg_list)), write_type_(write_type) {}
 
 const std::vector<package_x *>& PkgInfoParcelable::GetPkgInfo() {
   return pkg_list_;
 }
 
+WriteType PkgInfoParcelable::GetWriteType() {
+  return write_type_;
+}
+
 void PkgInfoParcelable::WriteToParcel(tizen_base::Parcel* parcel) const {
   AbstractParcelable::WriteToParcel(parcel);
+  WriteInt(parcel, write_type_);
+
   WriteInt(parcel, pkg_list_.size());
 
   for (auto pkg : pkg_list_) {
@@ -458,8 +463,13 @@ void PkgInfoParcelable::WriteToParcel(tizen_base::Parcel* parcel) const {
 
 void PkgInfoParcelable::ReadFromParcel(tizen_base::Parcel* parcel) {
   int len = 0;
+  int write_type = 0;
 
   AbstractParcelable::ReadFromParcel(parcel);
+
+  ReadInt(parcel, &write_type);
+  write_type_ = static_cast<WriteType>(write_type);
+
   ReadInt(parcel, &len);
 
   for (int i = 0; i < len ; ++i) {

diff --git a/src/common/parcel/pkginfo_parcelable.hh b/src/common/parcel/pkginfo_parcelable.hh
index 04e7824..0138677 100644 (file)
--- a/src/common/parcel/pkginfo_parcelable.hh
+++ b/src/common/parcel/pkginfo_parcelable.hh
@@ -2,6 +2,7 @@
 #define PKGINFO_PARCELABLE_HH_
 
 #include "abstract_parcelable.hh"
+#include "pkg_set_db_handler.hh"
 
 #include <vector>
 
@@ -22,9 +23,9 @@ class EXPORT_API PkgInfoParcelable : public AbstractParcelable {
   };
 
   PkgInfoParcelable();
-  PkgInfoParcelable(std::vector<package_x *>&& pkg_list);
+  PkgInfoParcelable(uid_t uid, std::vector<package_x *>&& pkg_list, WriteType write_type = None);
   const std::vector<package_x *>& GetPkgInfo();
-  std::vector<package_x *>&& ExtractPkgInfo();
+  WriteType GetWriteType();
 
   void WriteToParcel(tizen_base::Parcel* parcel) const override;
   void ReadFromParcel(tizen_base::Parcel* parcel) override;
@@ -60,6 +61,7 @@ class EXPORT_API PkgInfoParcelable : public AbstractParcelable {
   package_x *ReadPackage(tizen_base::Parcel* parcel);
 
   std::vector<package_x *> pkg_list_;
+  WriteType write_type_;
 };
 
 }  // namespace parcel

diff --git a/src/common/request_handler/get_pkginfo_request_handler.cc b/src/common/request_handler/get_pkginfo_request_handler.cc
index f499e02..91f801c 100644 (file)
--- a/src/common/request_handler/get_pkginfo_request_handler.cc
+++ b/src/common/request_handler/get_pkginfo_request_handler.cc
@@ -31,7 +31,7 @@ bool GetPkginfoRequestHandler::HandleRequest(unsigned char* data, int size,
   db.SetFilter(const_cast<pkgmgrinfo_filter_x*>(parcel->GetFilter()));
   if (db.Execute() == false) return false;
 
-  result_ = std::make_shared<PkgInfoParcelable>(db.GetPkgHandle());
+  result_ = std::make_shared<PkgInfoParcelable>(parcel->GetUid(), db.GetPkgHandle());
 
   return true;
 }

diff --git a/src/common/request_handler/set_pkginfo_request_handler.cc b/src/common/request_handler/set_pkginfo_request_handler.cc
index 7d12d26..3b71153 100644 (file)
--- a/src/common/request_handler/set_pkginfo_request_handler.cc
+++ b/src/common/request_handler/set_pkginfo_request_handler.cc
@@ -23,21 +23,30 @@ bool SetPkginfoRequestHandler::HandleRequest(unsigned char* data, int size,
       abstract_parcel->GetType() != ParcelableType::PkgInfo)
     return false;
 
-  auto* parcel = dynamic_cast<PkgInfoParcelable*>(abstract_parcel.get());
+  auto* parcel = dynamic_cast<PkgInfoParcelable*>(abstract_parcel->GetUid(), abstract_parcel.get());
   if (parcel == nullptr) return false;
 
   PkgSetDBHandler db(parcel->GetUid());
   db.SetLocale(locale);
+  db.SetWriteType(parcel->GetWriteType());
 
   for (auto& i : parcel->GetPkgInfo()) {
     db.SetPkgInfo(i);
     if (db.Execute() == false) return false;
   }
+
+  result_ = std::make_shared<ResultParcelable>(db.GetResult());
+
   return true;
 }
 
 std::vector<uint8_t> SetPkginfoRequestHandler::GetResult() {
-  return std::vector<uint8_t>('0');
+  tizen_base::Parcel parcel;
+
+  parcel.WriteParcelable(*result_.get());
+  std::vector<uint8_t> raw = parcel.GetRaw();
+
+  return raw;
 }
 
 }  // namespace request_handler

diff --git a/src/common/request_handler/set_pkginfo_request_handler.hh b/src/common/request_handler/set_pkginfo_request_handler.hh
index 43b436a..a936b5e 100644 (file)
--- a/src/common/request_handler/set_pkginfo_request_handler.hh
+++ b/src/common/request_handler/set_pkginfo_request_handler.hh
@@ -6,6 +6,7 @@
 #define SERVER_SET_PKGINFO_REQUEST_HANDLER_HH_
 
 #include "abstract_request_handler.hh"
+#include "result_parcelable.hh"
 
 #include <string>
 
@@ -21,6 +22,9 @@ class EXPORT_API SetPkginfoRequestHandler : public AbstractRequestHandler {
   bool HandleRequest(unsigned char* data, int size, std::string locale) override;
 
   std::vector<uint8_t> GetResult() override;
+
+ private:
+  std::shared_ptr<pkgmgr_common::parcel::ResultParcelable> result_;
 };
 
 }  // namespace request_handler

diff --git a/src/manager/pkginfo_manager.cc b/src/manager/pkginfo_manager.cc
index 36aaf74..71d17da 100644 (file)
--- a/src/manager/pkginfo_manager.cc
+++ b/src/manager/pkginfo_manager.cc
@@ -27,6 +27,7 @@
 
 #include "logging.hh"
 #include "common/database/abstract_db_handler.hh"
+#include "common/database/pkg_set_db_handler.hh"
 #include "common/parcel/appinfo_parcelable.hh"
 #include "common/parcel/filter_parcelable.hh"
 #include "common/parcel/pkginfo_parcelable.hh"
@@ -702,3 +703,108 @@ extern "C" EXPORT_API int _parser_execute_write_queries(const char **queries, in
 
        return 0;
 }
+
+extern "C" EXPORT_API int _parser_insert_manifest_info(manifest_x *mfx, uid_t uid)
+{
+       std::vector<package_x *> vt { mfx };
+
+       std::shared_ptr<pkgmgr_common::parcel::AbstractParcelable> parcelable(
+                       new pkgmgr_common::parcel::PkgInfoParcelable(uid, std::move(vt), WriteType::Insert));
+
+       pkgmgr_client::PkgInfoClient client(parcelable, uid,
+                       pkgmgr_common::ReqType::SET_PKG_INFO);
+       if (!client.SendRequest()) {
+               return -1;
+       }
+
+       std::shared_ptr<pkgmgr_common::parcel::ResultParcelable> return_parcel(
+                       std::static_pointer_cast<pkgmgr_common::parcel::ResultParcelable>(
+                                       client.GetResultParcel()));
+
+       auto result_list = return_parcel->GetResult();
+       if (result_list.size() != 1) {
+               LOG(ERROR) << "Invalid result";
+               return -1;
+       }
+
+       if (result_list[0].size() != 1) {
+               LOG(ERROR) << "Invalid result";
+               return -1;
+       }
+
+       LOG(ERROR) << "result : " << result_list[0][0];
+       if (result_list[0][0] != "SUCCESS")
+               return -1;
+
+       return 0;
+}
+
+extern "C" EXPORT_API int _parser_update_manifest_info(manifest_x *mfx, uid_t uid)
+{
+       std::vector<package_x *> vt { mfx };
+
+       std::shared_ptr<pkgmgr_common::parcel::AbstractParcelable> parcelable(
+                       new pkgmgr_common::parcel::PkgInfoParcelable(uid, std::move(vt), WriteType::Update));
+
+       pkgmgr_client::PkgInfoClient client(parcelable, uid,
+                       pkgmgr_common::ReqType::SET_PKG_INFO);
+       if (!client.SendRequest()) {
+               return -1;
+       }
+
+       std::shared_ptr<pkgmgr_common::parcel::ResultParcelable> return_parcel(
+                       std::static_pointer_cast<pkgmgr_common::parcel::ResultParcelable>(
+                                       client.GetResultParcel()));
+
+       auto result_list = return_parcel->GetResult();
+       if (result_list.size() != 1) {
+               LOG(ERROR) << "Invalid result";
+               return -1;
+       }
+
+       if (result_list[0].size() != 1) {
+               LOG(ERROR) << "Invalid result";
+               return -1;
+       }
+
+       LOG(ERROR) << "result : " << result_list[0][0];
+       if (result_list[0][0] != "SUCCESS")
+               return -1;
+
+       return 0;
+}
+
+extern "C" EXPORT_API int _parser_delete_manifest_info(manifest_x *mfx, uid_t uid)
+{
+       std::vector<package_x *> vt { mfx };
+
+       std::shared_ptr<pkgmgr_common::parcel::AbstractParcelable> parcelable(
+                       new pkgmgr_common::parcel::PkgInfoParcelable(uid, std::move(vt), WriteType::Delete));
+
+       pkgmgr_client::PkgInfoClient client(parcelable, uid,
+                       pkgmgr_common::ReqType::SET_PKG_INFO);
+       if (!client.SendRequest()) {
+               return -1;
+       }
+
+       std::shared_ptr<pkgmgr_common::parcel::ResultParcelable> return_parcel(
+                       std::static_pointer_cast<pkgmgr_common::parcel::ResultParcelable>(
+                                       client.GetResultParcel()));
+
+       auto result_list = return_parcel->GetResult();
+       if (result_list.size() != 1) {
+               LOG(ERROR) << "Invalid result";
+               return -1;
+       }
+
+       if (result_list[0].size() != 1) {
+               LOG(ERROR) << "Invalid result";
+               return -1;
+       }
+
+       LOG(ERROR) << "result : " << result_list[0][0];
+       if (result_list[0][0] != "SUCCESS")
+               return -1;
+
+       return 0;
+}

diff --git a/src/manager/pkginfo_manager.h b/src/manager/pkginfo_manager.h
index 7684e2c..bb8e9cf 100644 (file)
--- a/src/manager/pkginfo_manager.h
+++ b/src/manager/pkginfo_manager.h
@@ -67,6 +67,12 @@ int _parser_execute_write_query(const char *query, uid_t uid);
 
 int _parser_execute_write_queries(const char **queries, int len, uid_t uid);
 
+int _parser_insert_manifest_info(manifest_x *mfx, uid_t uid);
+
+int _parser_update_manifest_info(manifest_x *mfx, uid_t uid);
+
+int _parser_delete_manifest_info(manifest_x *mfx, uid_t uid);
+
 #ifdef __cplusplus
 }
 #endif

diff --git a/test/unit_tests/test_parcel.cc b/test/unit_tests/test_parcel.cc
index fd76bc7..6e2ddd1 100644 (file)
--- a/test/unit_tests/test_parcel.cc
+++ b/test/unit_tests/test_parcel.cc
@@ -122,7 +122,7 @@ TEST_F(ParcelTest, PkgInfoParcelable) {
 
   origin_packages.emplace_back(GetTestPackage("test_pkgid1"));
   origin_packages.emplace_back(GetTestPackage("test_pkgid2"));
-  pp::PkgInfoParcelable origin_parcelable(std::move(origin_packages));
+  pp::PkgInfoParcelable origin_parcelable(0, std::move(origin_packages));
   pp::PkgInfoParcelable new_parcelable;
   parcel.WriteParcelable(origin_parcelable);
   parcel.ReadParcelable(&new_parcelable);