public:
virtual ~IActionLoader() = default;
virtual void ListActions() = 0;
- virtual void GetAction(const std::string& name) = 0;
+ virtual std::string GetAction(const std::string& name) = 0;
};
} // namespace action
#include "common/utils/logging.hh"
#include "utils/action_model_converter.hh"
+namespace {
+
+common::ParameterType GetParameterTypeFromString(const std::string& type) {
+ LOG(DEBUG) << "GetParmameterType : " << type;
+
+ if (type.compare("integer") == 0)
+ return common::ParameterType::IntType;
+ else if (type.compare("string") == 0)
+ return common::ParameterType::StringType;
+ else if (type.compare("double") == 0)
+ return common::ParameterType::DoubleType;
+ else if (type.compare("bool") == 0)
+ return common::ParameterType::BoolType;
+
+ return common::ParameterType::InvalidType;
+}
+
+} // namespace
+
namespace action {
ActionRequestHandler::ActionRequestHandler() {}
db->ListActions();
}
-void ActionRequestHandler::OnGetAction(const std::string& id) {
+rpc::Action ActionRequestHandler::OnGetAction(const std::string& id) {
auto db = std::make_unique<action::SqliteDb>();
- db->GetAction(id);
+ std::string json_str = db->GetAction(id);
+ common::ActionModel model(json_str);
+
+ rpc::Action action;
+ action.Setaction_id(model.GetActionId());
+ action.Setapp_id(model.GetAppId());
+ action.Setlabel(model.GetLabel());
+ action.Setdescription(model.GetDescription());
+ action.Settype("app_control"); // TODO
+ // action.Seturi();
+ // action.Setmime();
+ // action.Setoperation();
+ // action.Setparameters();
+ // action.Setresults();
+ // action.Setprivileges();
+
+ return action;
}
void ActionRequestHandler::OnGetActionId(const std::string& user_description,
float search_threshold) {}
void ActionRequestHandler::OnExecute(const std::string& instance,
- common::ActionModel& model) {
- LOG(DEBUG) << "OnExecute action : " << model.GetActionId()
- << ", appid : " << model.GetAppId();
+ rpc::Action& action) {
+ auto db = std::make_unique<action::SqliteDb>();
+ std::string json_str = db->GetAction(action.Getaction_id());
+ common::ActionModel model(json_str);
+ LOG(DEBUG) << "OnExecute action : " << model.GetActionId() << " appid: " << model.GetAppId();
+
+ std::vector<common::ActionParameter> params;
+ for (auto const& iter : action.Getparameters()) {
+ common::ParameterType param_type = GetParameterTypeFromString(iter.Gettype());
+ LOG(DEBUG) << "param key : " << iter.Getkey() << ", val : "
+ << iter.Getvalue() << ", type : " << iter.Gettype();
+
+ auto param = common::ActionParameter(iter.Getkey(), param_type,
+ iter.Getvalue(), iter.Getdescription(), iter.Getis_requied());
+
+ params.push_back(param);
+ }
+ model.SetParameters(params);
auto executor = ActionExecutorFactory::CreateExecutor(instance, model);
executor->SetResultHandler(this);
void Init();
void OnListActions() override;
- void OnGetAction(const std::string& id) override;
+ rpc::Action OnGetAction(const std::string& id) override;
void OnGetActionId(const std::string& user_description,
int top_k,
float search_threshold) override;
void OnExecute(const std::string& instance,
- common::ActionModel& model) override;
+ rpc::Action& model) override;
void OnResult(const std::string& requester,
const std::string& result) override;
#include "common/action_model.h"
-// TODO: dependency?
#include "action/tizen_action_service_stub.h"
+namespace rpc = rpc_port::tizen_action_service_stub;
+
namespace action {
class IRequestHandler {
public:
virtual ~IRequestHandler() = default;
virtual void OnListActions() = 0;
- virtual void OnGetAction(const std::string& id) = 0;
+ virtual rpc::Action OnGetAction(const std::string& id) = 0;
virtual void OnGetActionId(const std::string& user_description, int top_k,
float search_threshold) = 0;
- virtual void OnExecute(const std::string& requester, common::ActionModel& model) = 0;
+ virtual void OnExecute(const std::string& requester, rpc::Action& model) = 0;
};
} // namespace action
* limitations under the License.
*/
- #include "action/service.hh"
+#include "action/service.hh"
#include <algorithm>
#include "common/utils/logging.hh"
#include "common/action_model.h"
-namespace {
-
-common::ActionType GetActionType(std::string type) {
- if (type.compare("app_control") == 0)
- return common::ActionType::AppControl;
- else if (type.compare("plugin") == 0)
- return common::ActionType::Plugin;
-
- return common::ActionType::InvalidType;
-}
-
-common::ParameterType GetParameterType(std::string type) {
- LOG(DEBUG) << "GetParmameterType : " << type;
-
- if (type.compare("integer") == 0)
- return common::ParameterType::IntType;
- else if (type.compare("string") == 0)
- return common::ParameterType::StringType;
- else if (type.compare("double") == 0)
- return common::ParameterType::DoubleType;
- else if (type.compare("bool") == 0)
- return common::ParameterType::BoolType;
-
- return common::ParameterType::InvalidType;
-}
-
-}
-
namespace action {
Service::Service(std::string sender, std::string instance,
}
rpc::Action Service::GetAction(std::string action_id) {
- // return action by id
- // ActionModel action = handler_.OnGetAction(action_id);
-
- LOG(DEBUG) << "GetAction : " << action_id;
-
- action::SqliteDb sqlite_db;
-
- std::string result = sqlite_db.Select(action_id);
-
- LOG(DEBUG) << "GetAction result : " << result;
-
- auto ps = new utils::JsonParser(result);
-
- auto params = ps->GetParameters();
-
- rpc::Action action;
- std::vector<rpc::Parameter> actionparams;
-
- action.Setapp_id(ps->GetAppId());
- action.Setaction_id(ps->GetName());
- action.Setlabel(ps->GetName());
- action.Setdescription(ps->GetDescription());
-
- for (auto const& iter : params) {
- auto param_value = iter.second;
-
- auto param = rpc::Parameter(iter.first, param_value["type"], "", param_value["desc"],
- param_value["isMandatory"].compare("true") == 0 ? true : false);
-
- actionparams.push_back(param);
- }
-
- action.Setparameters(actionparams);
-
- LOG(DEBUG) << "appid : " << action.Getapp_id();
- LOG(DEBUG) << "actionid : " << action.Getaction_id();
-
- // return {};
- return action;
+ return handler_.OnGetAction(action_id);
}
std::vector<rpc::VectorDbResult> Service::GetActionId(
}
int Service::Execute(rpc::Action action) {
- LOG(DEBUG) << "Execute : " << action.Getaction_id() << ", type : " << action.Gettype();
-
- std::string action_id = action.Getaction_id();
- action::SqliteDb sqlite_db;
-
- std::string result = sqlite_db.Select(action_id);
- if (result.empty()) {
- LOG(DEBUG) << "Not exsit action";
- return -1;
- }
-
- common::ActionModel model;
- std::vector<common::ActionParameter> actionparams;
- auto ps = new utils::JsonParser(result);
-
- auto params = ps->GetParameters();
- auto param_values = action.Getparameters();
-
- model.SetActionId(action.Getaction_id());
- model.SetAppId(ps->GetAppId());
- model.SetType(GetActionType(action.Gettype()));
-
- for (auto const& iter : param_values) {
- std::string param_name = iter.Getkey();
- auto param_schema = params[param_name];
-
- common::ParameterType param_type = GetParameterType(param_schema["type"]);
-
- LOG(DEBUG) << "param key : " << param_name << ", val : " << iter.Getvalue() << ", type : " << param_schema["type"];
-
- auto param = common::ActionParameter(param_name, param_type, iter.Getvalue(),
- iter.Getdescription(), iter.Getis_requied());
-
- actionparams.push_back(param);
- }
- model.SetParameters(actionparams);
-
- handler_.OnExecute(GetInstance(), model);
-
+ LOG(DEBUG) << "Execute : " << action.Getaction_id()
+ << ", type : " << action.Gettype();
+ handler_.OnExecute(GetInstance(), action);
return 0;
}
Select();
}
-void SqliteDb::GetAction(const std::string& name) {
- // TODO
- Select(name);
+std::string SqliteDb::GetAction(const std::string& name) {
+ return Select(name);
}
std::string SqliteDb::Select(const std::string& name) {
~SqliteDb() = default;
void ListActions() override;
- void GetAction(const std::string& name) override;
+ std::string GetAction(const std::string& name) override;
void Select();
std::string Select(const std::string& name);
APPLY_PKG_CONFIG(${TARGET_TIZEN_ACTION_COMMON} PUBLIC
DLOG_DEPS
+ JSONCPP_DEPS
TIZEN_DATABASE_DEPS
)
#include "common/action_model.h"
+#include <json/json.h>
+
+#include <string>
+#include <map>
+
+#include "common/utils/logging.hh"
+
+namespace {
+
+Json::Value ParseJsonFromString(const std::string& json_str) {
+ Json::Value root;
+ Json::CharReaderBuilder builder;
+ JSONCPP_STRING err;
+ const std::unique_ptr<Json::CharReader> reader(builder.newCharReader());
+ if (!reader->parse(json_str.c_str(), json_str.c_str() + json_str.length(),
+ &root, &err)) {
+ LOG(ERROR) << "Failed to parse json string: " << err;
+ return {};
+ }
+ return root;
+}
+
+std::map<std::string, common::ParameterType> kTypeMap = {
+ {"int", common::ParameterType::IntType},
+ {"string", common::ParameterType::StringType},
+ {"double", common::ParameterType::DoubleType},
+ {"bool", common::ParameterType::BoolType},
+};
+
+common::ParameterType ConvertStringToParameterType(const std::string& type) {
+ auto it = kTypeMap.find(type);
+ if (it == kTypeMap.end()) {
+ LOG(ERROR) << "Unknown parameter type: " << type;
+ return common::ParameterType::InvalidType;
+ }
+ return it->second;
+}
+
+common::ActionType GetActionTypeFromString(const std::string& type) {
+ if (type.compare("app_control") == 0)
+ return common::ActionType::AppControl;
+ else if (type.compare("plugin") == 0)
+ return common::ActionType::Plugin;
+ return common::ActionType::InvalidType;
+}
+
+} // namespace
+
namespace common {
ActionModel::ActionModel() {}
+ActionModel::ActionModel(std::string json_str) {
+ Json::Value root = ParseJsonFromString(json_str);
+
+ action_id_ = root["name"].asString();
+ app_id_ = root["appId"].asString();
+ type_ = GetActionTypeFromString(root["type"].asString());
+ label_ = root["label"].asString();
+ description_ = root["desc"].asString();
+
+ // params
+ for (auto const& it : root["params"].getMemberNames()) {
+ std::string name = it;
+ common::ParameterType type =
+ ConvertStringToParameterType(root["params"][it]["type"].asString());
+ std::string description = root["params"][it]["desc"].asString();
+ bool is_required = root["params"][it]["isRequired"].asBool();
+ parameters_.emplace_back(name, type, "", description, is_required);
+ }
+
+ // returns
+ for (auto const& it : root["returns"].getMemberNames()) {
+ std::string name = it;
+ common::ParameterType type =
+ ConvertStringToParameterType(root["returns"][it]["type"].asString());
+ std::string description = root["returns"][it]["desc"].asString();
+ // ActionParameterType -> another class???
+ returns_.emplace_back(name, type, "", description, false);
+ }
+}
+
ActionModel::ActionModel(std::string action_id, std::string app_id,
std::string label, std::string description, std::string uri,
std::string mime, std::string operation, std::vector<ActionParameter> parameters,
parameters_ = std::move(parameters);
}
+const std::vector<ActionParameter>& ActionModel::GetReturns() const {
+ return returns_;
+}
+
+void ActionModel::SetReturns(std::vector<ActionParameter> returns) {
+ returns_ = std::move(returns);
+}
+
const std::vector<std::string>& ActionModel::GetPrivileges() const {
return privileges_;
}
class ActionModel {
public:
ActionModel();
- ActionModel(std::string action_id, std::string app_id,
+ explicit ActionModel(std::string json_str);
+ explicit ActionModel(std::string action_id, std::string app_id,
std::string label, std::string description, std::string uri,
std::string mime, std::string operation, std::vector<ActionParameter> parameters,
std::vector<std::string> privileges);
const std::vector<ActionParameter>& GetParameters() const;
void SetParameters(std::vector<ActionParameter> parameters);
+ const std::vector<ActionParameter>& GetReturns() const;
+ void SetReturns(std::vector<ActionParameter> returns);
+
const std::vector<std::string>& GetPrivileges() const;
void SetPrivileges(std::vector<std::string> privileges);
//is std::map better?
std::vector<ActionParameter> parameters_;
+ std::vector<ActionParameter> returns_;
// std::vector<Result> results_;
std::vector<std::string> privileges_;
projects / platform / core / appfw / tizen-action.git / commitdiff