path: root/src/components/application_manager/include/application_manager/resumption/resumption_data_db.h

/*
 * Copyright (c) 2015, Ford Motor Company
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 *
 * Redistributions of source code must retain the above copyright notice, this
 * list of conditions and the following disclaimer.
 *
 * Redistributions in binary form must reproduce the above copyright notice,
 * this list of conditions and the following
 * disclaimer in the documentation and/or other materials provided with the
 * distribution.
 *
 * Neither the name of the Ford Motor Company nor the names of its contributors
 * may be used to endorse or promote products derived from this software
 * without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 * POSSIBILITY OF SUCH DAMAGE.
 */

#ifndef SRC_COMPONENTS_APPLICATION_MANAGER_INCLUDE_APPLICATION_MANAGER_RESUMPTION_RESUMPTION_DATA_DB_H_
#define SRC_COMPONENTS_APPLICATION_MANAGER_INCLUDE_APPLICATION_MANAGER_RESUMPTION_RESUMPTION_DATA_DB_H_
#include "application_manager/resumption/resumption_data.h"

#include "utils/sqlite_wrapper/sql_database.h"
#include "utils/sqlite_wrapper/sql_query.h"

namespace resumption {

/**
 * @brief Points what structure contains vr commands
 */
enum AccessoryVRCommand { kVRCommandFromChoice = 0, kVRCommandFromCommand };

struct ApplicationParams {
  ApplicationParams(const smart_objects::SmartObject& application);
  ApplicationParams(app_mngr::ApplicationSharedPtr application);

  std::string m_hash;
  int64_t m_grammar_id;
  int64_t m_connection_key;
  int64_t m_hmi_app_id;
  mobile_apis::HMILevel::eType m_hmi_level;
  bool m_is_media_application;
  bool m_is_valid;
  app_mngr::ApplicationSharedPtr app_ptr;
};

/**
 * @brief Show should database be saved in a disk file or in memory
 */
enum DbStorage { In_Memory_Storage = 0, In_File_Storage };

/**
 * @brief class contains logic for representation application data in
 * data base
 */
class ResumptionDataDB : public ResumptionData {
 public:
  /**
   * @brief Constructor of ResumptionDataDB
   * @param db_storage show database should be saved in a disk file or in memory
   */
  ResumptionDataDB(
      DbStorage db_storage,
      const application_manager::ApplicationManager& application_manager);

  /**
   * @brief allows to destroy ResumptionDataDB object
   */
  virtual ~ResumptionDataDB();

  /**
   * @brief Creates or opens DB and initialize it
   * @return false if DB doesn't initialize
   * otherwise returns true
   */
  virtual bool Init();

  /**
   * @brief Save application persistent info for future resuming to db
   * @param application is application which need to be saved
   */
  void SaveApplication(app_mngr::ApplicationSharedPtr application) OVERRIDE;
  /**
   * @brief Checks if saved data of applications have hmi app id
   * @param hmi_app_id - hmi application id
   * @return true if exist, otherwise false
   */
  virtual bool IsHMIApplicationIdExist(uint32_t hmi_app_id) const;
  /**
   * @brief Retrieves HMI app ID for the given mobile app ID
   * and device ID from stored data.
   * @param policy_app_id - mobile application id
   * @param device_id - contains id of device on which is running application
   * @return HMI app ID
   */
  virtual uint32_t GetHMIApplicationID(const std::string& policy_app_id,
                                       const std::string& device_id) const;

  void IncrementGlobalIgnOnCounter() OVERRIDE;

  uint32_t GetGlobalIgnOnCounter() const OVERRIDE;

  void ResetGlobalIgnOnCount() OVERRIDE;

  /**
   * @brief Increments ignition counter for all registered applications
   * and remember ign_off time stamp
   */
  void IncrementIgnOffCount() FINAL;

  /**
   * @brief Decrements ignition counter for all registered applications
   */
  void DecrementIgnOffCount() FINAL;

  /**
   * @brief Retrieves hash ID for the given mobile app ID
   * and device ID from stored information.
   * @param policy_app_id - mobile application id
   * @param device_id - contains id of device on which is running application
   * @param hash_id - parameter which will contain HASH id from saved
   * application
   * @return TRUE if application will be found in saved data otherwise
   * returns FALSE
   */
  virtual bool GetHashId(const std::string& policy_app_id,
                         const std::string& device_id,
                         std::string& hash_id) const;

  /**
   * @brief Retrieves data of saved application for the given mobile app ID
   * and device ID
   * @param policy_app_id - mobile application id
   * @param device_id - contains id of device on which is running application
   * @param saved_app - parameter which will contain data of saved application
   * @return TRUE if application will be found in saved data otherwise
   * returns FALSE
   */
  virtual bool GetSavedApplication(const std::string& policy_app_id,
                                   const std::string& device_id,
                                   smart_objects::SmartObject& saved_app) const;

  /**
   * @brief Remove application from list of saved applications
   * @param policy_app_id application witch need to be removed
   * @param device_id - contains id of device on which is running application
   * @return return true, if success, otherwise return false
   */
  virtual bool RemoveApplicationFromSaved(const std::string& policy_app_id,
                                          const std::string& device_id);

  /**
   * @brief Get the last ignition off time from LastState
   * @return the last ignition off time from LastState
   */
  virtual uint32_t GetIgnOffTime() const;

  /**
   * @brief Checks if saved data have application
   * @param policy_app_id - mobile application id
   * @param device_id - contains id of device on which is running application
   * @return 0 if saved data contains application otherwise returns -1
   */
  virtual ssize_t IsApplicationSaved(const std::string& policy_app_id,
                                     const std::string& device_id) const;

  /**
   * @brief Retrieves data from saved application
   * @param  will contain data for resume_ctrl
   */
  virtual void GetDataForLoadResumeData(
      smart_objects::SmartObject& saved_data) const;

  /**
   * @brief Updates HMI level of saved application
   * @param policy_app_id - mobile application id
   * @param device_id - contains id of device on which is running application
   * @param hmi_level - contains hmi level for saved application
   */
  virtual void UpdateHmiLevel(const std::string& policy_app_id,
                              const std::string& device_id,
                              mobile_apis::HMILevel::eType hmi_level);

  /**
   * @brief Re-creates and re-init DB
   * @return true if success, otherwise - false
   */
  bool RefreshDB() const;

  /**
   * @brief Gets all the data from DB to memory
   * @param data Object which holds resumption data
   * @return true if success, otherwise - false
   */
  bool GetAllData(smart_objects::SmartObject& data) const;

  /**
   * @brief Saves all the data to DB
   * @param data Object, which holds resumption data
   * @return true if success, otherwise - false
   */
  bool SaveAllData(const smart_objects::SmartObject& data);

  /**
   * @brief Checks, if DB version is actual to current schema
   * @return true if success, otherwise - false
   */
  bool IsDBVersionActual() const;

  /**
   * @brief Updates DB version accordingly to current schema
   * @return true if success, otherwise - false
   */
  bool UpdateDBVersion() const;

  bool DropAppDataResumption(const std::string& device_id,
                             const std::string& app_id) OVERRIDE;
  /**
   * @brief Write json resumption info to file system
   */
  void Persist() OVERRIDE;

 protected:
  /**
   * @brief returns pointer to data base
   */
  utils::dbms::SQLDatabase* db() const;

 private:
  /**
   * @brief Calculates DB version from current schema
   * @return version
   */
  const int32_t GetDBVersion() const;

  /**
   * @brief Retrieves hmi level from db
   * @param policy_app_id - mobile application id
   * @param device_id - contains id of device on which is running application
   * @param hmi_level - will contains hmi level for saved application
   * @return true if application with mobile id and device id has hmi level
   * otherwise returns false
   */
  bool SelectHMILevel(const std::string& policy_app_id,
                      const std::string& device_id,
                      int& hmi_level) const;
  /**
   * @brief Checks existence HMI id in DB
   * @param hmi_app_id - HMI id
   * return true if hmiID is same with saved hmiID otherwise returns false
   */
  bool CheckExistenceHMIId(uint32_t hmi_app_id) const;

  /**
   * @brief Select HMI id from saved application
   * @param policy_app_id - mobile application id
   * @param device_id - contains id of device on which is running application
   * @param hmi_id - will contains hmi id from saved application
   */
  void SelectHMIId(const std::string& policy_app_id,
                   const std::string& device_id,
                   uint32_t& hmi_id) const;

  /**
   * @brief Select hash id from saved application
   * @param policy_app_id - mobile application id
   * @param device_id - contains id of device on which is running application
   * @param hash_id - will contains hash id from saved application
   */
  bool SelectHashId(const std::string& policy_app_id,
                    const std::string& device_id,
                    std::string& hash_id) const;

  /**
   * @brief Select Ign off time
   * @return Ign off time from saved data
   */
  uint32_t SelectIgnOffTime() const;

  /**
   * @brief Checks existence application in DB
   * @param policy_app_id - mobile application id
   * @param device_id - contains id of device on which is running application
   * @param application_exist will contain true if restored data contain
   * application
   * otherwise will contain false
   * return if we have problem with access to DB returns FALSE otherwise
   * returns TRUE
   */
  bool CheckExistenceApplication(const std::string& policy_app_id,
                                 const std::string& device_id,
                                 bool& application_exist) const;

  /**
   * @brief Retrieves data from saved application
   * @param will contain data for resume_ctrl
   */
  void SelectDataForLoadResumeData(
      smart_objects::SmartObject& saved_data) const;

  /**
   * @brief Deletes saved application from db
   * @param policy_app_id - mobile application id
   * @param device_id - contains id of device on which is running application
   * @return true if application data was deleted otherwise returns
   * false
   */
  bool DeleteSavedApplication(const std::string& policy_app_id,
                              const std::string& device_id);

  /**
   * @brief Deletes file from saved application
   * @param policy_app_id - mobile application id
   * @param device_id - contains id of device on which is running application
   * @return true if data was deleted otherwise returns
   * false
   */
  bool DeleteSavedFiles(const std::string& policy_app_id,
                        const std::string& device_id);

  /**
   * @brief Deletes submenu from saved application
   * @param policy_app_id - mobile application id
   * @param device_id - contains id of device on which is running application
   * @return true if data was deleted otherwise returns
   * false
   */
  bool DeleteSavedSubMenu(const std::string& policy_app_id,
                          const std::string& device_id);

  /**
   * @brief Deletes subscriptions from saved application
   * @param policy_app_id - mobile application id
   * @param device_id - contains id of device on which is running application
   * @return true if data was deleted otherwise returns
   * false
   */
  bool DeleteSavedSubscriptions(const std::string& policy_app_id,
                                const std::string& device_id);

  /**
   * @brief Deletes userLocation from saved application
   * @param policy_app_id - mobile application id
   * @param device_id - contains id of device on which is running application
   * @return true if data was deleted otherwise returns
   * false
   */
  bool DeleteUserLocation(const std::string& policy_app_id,
                          const std::string& device_id);

  /**
   * @brief Deletes commands from saved application
   * @param policy_app_id - mobile application id
   * @param device_id - contains id of device on which is running application
   * @return true if data was deleted otherwise returns
   * false
   */
  bool DeleteSavedCommands(const std::string& policy_app_id,
                           const std::string& device_id);

  /**
   * @brief Deletes choice set from saved application
   * @param policy_app_id - mobile application id
   * @param device_id - contains id of device on which is running application
   * @return true if data was deleted otherwise returns
   * false
   */
  bool DeleteSavedChoiceSet(const std::string& policy_app_id,
                            const std::string& device_id);

  /**
   * @brief Deletes global properties from saved application
   * @param policy_app_id - mobile application id
   * @param device_id - contains id of device on which is running application
   * @return true if data was deleted otherwise returns
   * false
   */
  bool DeleteSavedGlobalProperties(const std::string& policy_app_id,
                                   const std::string& device_id);
  /**
   * @brief Deletes data from application table
   * @param policy_app_id - mobile application id
   * @param device_id - contains id of device on which is running application
   * @return true if data was deleted otherwise returns
   * false
   */
  bool DeleteDataFromApplicationTable(const std::string& policy_app_id,
                                      const std::string& device_id);

  /**
   * @brief Saves files data to DB
   * @param files contains data for saving
   * @param application_primary_key - primary key from DB table application
   * @return true if data was saved successfully otherwise returns
   * false
   */
  bool InsertFilesData(const smart_objects::SmartObject& files,
                       int64_t application_primary_key) const;

  /**
   * @brief Saves submenu data to DB
   * @param submenus contains data for saving
   * @param application_primary_key - primary key from DB table application
   * @return true if data was saved successfully otherwise returns
   * false
   */
  bool InsertSubMenuData(const smart_objects::SmartObject& submenus,
                         int64_t application_primary_key) const;

  /**
   * @brief Saves commands data to DB
   * @param commands contains data for saving
   * @param application_primary_key - primary key from DB table application
   * @return true if data was saved successfully otherwise returns
   * false
   */
  bool InsertCommandsData(const smart_objects::SmartObject& commands,
                          int64_t application_primary_key) const;

  /**
   * @brief Saves subscriptions data to DB
   * @param subscriptions contains data for saving
   * @param application_primary_key - primary key from DB table application
   * @return true if data was saved successfully otherwise returns
   * false
   */
  bool InsertSubscriptionsData(const smart_objects::SmartObject& subscriptions,
                               int64_t application_primary_key) const;

  /**
   * @brief Saves choice set data to DB
   * @param choicesets contains data for saving
   * @param application_primary_key - primary key from DB table application
   * @return true if data was saved successfully otherwise returns
   * false
   */
  bool InsertChoiceSetData(const smart_objects::SmartObject& choicesets,
                           int64_t application_primary_key) const;

  /**
   * @brief Saves user location data to DB
   * @param user_location contains data for saving
   * @param application_primary_key - primary key from DB table application
   * @return true if data was saved successfully otherwise returns
   * false
   */
  bool InsertUserLocationData(const smart_objects::SmartObject& user_location,
                              int64_t application_primary_key) const;

  /**
   * @brief Saves globalProperties data to DB
   * @param global_properties contains data for saving
   * @param global_properties_key - will contain primary key from global
   * properties table
   * @return true if data was saved successfully otherwise returns
   * false
   */
  bool InsertGlobalPropertiesData(
      const smart_objects::SmartObject& global_properties,
      int64_t& global_properties_key) const;

  /**
   * @brief Saves application data to DB
   * @param application contains data for saving
   * @param policy_app_id - mobile application id
   * @param device_id - contains id of device on which is running application
   * @return true if application data was saved successfully
   * otherwise returns false
   */
  bool SaveApplicationToDB(app_mngr::ApplicationSharedPtr application,
                           const std::string& policy_app_id,
                           const std::string& device_id) const;

  bool SaveApplicationToDB(const smart_objects::SmartObject& application,
                           const std::string& policy_app_id,
                           const std::string& device_id) const;

  /**
   * @brief Updates ignition of count on saved applications after onAwake
   * notification
   */
  void UpdateDataOnAwake();

  /**
   * @brief Execute query for delete data of application
   * @param policy_app_id - mobile application id
   * @param device_id - contains id of device on which is running application
   * @param text_query - contains text of query
   * @return true if query was run successfully otherwise returns
   * false
   */
  bool ExecQueryToDeleteData(const std::string& policy_app_id,
                             const std::string& device_id,
                             const std::string& text_query);

  /**
   * @brief Execute union query for delete data of application
   * @param policy_app_id - mobile application id
   * @param device_id - contains id of device on which is running application
   * @param text_query - contains text of query
   * @return true if query was run successfully otherwise returns
   * false
   */
  bool ExecUnionQueryToDeleteData(const std::string& policy_app_id,
                                  const std::string& device_id,
                                  const std::string& text_query);

  /**
   * @brief Execute query in order to insert image to DB
   * @param image_primary_key - will contain primary key from image table
   * @param image contains data for saving to DB
   * @return true if query was run successfully otherwise returns
   * false
   */
  bool ExecInsertImage(int64_t& image_primary_key,
                       const smart_objects::SmartObject& image) const;

  /**
   * @brief Execute query in order to insert choice to DB
   * @param choice_set_key - contain primary key from
   * applicationChoiceSet table
   * @param choice_array contains data for saving to DB
   * @return true if query was run successfully otherwise returns
   * false
   */
  bool ExecInsertChoice(int64_t choice_set_key,
                        const smart_objects::SmartObject& choice_array) const;

  /**
   * @brief Execute query in order to insert vr commands to DB
   * @param primary_key - will contain primary key from command table or
   * choice table
   * @param vr_commands_array contains data for saving to DB
   * @param value indicates which structure contains vrcommands
   * @return true if query was run successfully otherwise returns
   * false
   */
  bool ExecInsertVrCommands(const int64_t primary_key,
                            const smart_objects::SmartObject& vr_commands_array,
                            AccessoryVRCommand value) const;

  /**
   * @brief Execute query in order to insert choice set data to DB
   * @param choice_set_primary_key - will contain primary key from
   * applicationChoiceSet table
   * @param choiceset contains data for saving to DB
   * @return true if query was run successfully otherwise returns
   * false
   */
  bool ExecInsertApplicationChoiceSet(
      int64_t& choice_set_primary_key,
      const smart_objects::SmartObject& choiceset) const;

  /**
   * @brief combines primary key from several table to new table
   * @param first_primary_key - will contain primary key from first DB table
   * @param second_primary_key - will contain primary key from second DB table
   * @param text_query - contains text of query
   * @return true if query was run successfully otherwise returns
   * false
   */
  bool ExecInsertDataToArray(int64_t first_primary_key,
                             int64_t second_primary_key,
                             const std::string& text_query) const;

  /**
   * @brief Execute query in order to insert characters array to DB
   * @param global_properties_key contains primary key from globalproperties
   * table
   * @param characters_array contains data for saving to DB
   * @return true if query was run successfully otherwise returns
   * false
   */
  bool ExecInsertLimitedCharacters(
      int64_t global_properties_key,
      const smart_objects::SmartObject& characters_array) const;

  /**
   * @brief Execute query in order to insert vr help item array to DB
   * @param global_properties_key contains primary key from globalproperties
   * table
   * @param vrhelp_array contains data for saving to DB
   * @return true if query was run successfully otherwise returns
   * false
   */
  bool ExecInsertVRHelpItem(
      int64_t global_properties_key,
      const smart_objects::SmartObject& vrhelp_array) const;

  /**
   * @brief Execute query in order to insert data to ttsChunk table
   * @param tts_chunk contains data for saving to DB
   * @param tts_chunk_key will contain primary key from ttsChunk table
   * @return true if query was run successfully otherwise returns
   * false
   */
  bool ExecInsertTTSChunks(const smart_objects::SmartObject& tts_chunk,
                           int64_t& tts_chunk_key) const;

  /**
   * @brief Execute query in order to insert data to helpTimeoutPromptArray
   * @param global_properties contains data for saving to DB
   * @param global_properties_key contains primary key from globalproperties
   * table
   * @return true if query was run successfully otherwise returns
   * false
   */
  bool ExecInsertHelpTimeoutArray(
      const smart_objects::SmartObject& global_properties,
      int64_t global_properties_key) const;

  /**
   * @brief Execute query in order to insert or update data in application table
   * @param application contains data for saving to DB
   * @param policy_app_id contains mobile application id of application
   * @param device_id contains id of device on which is running application
   * @param application_primary_key will contain primary key from application
   * table
   * @param global_properties_key contains primary key from globalproperties
   * table
   * @return true if query was run successfully otherwise returns
   * false
   */
  bool InsertApplicationData(const ApplicationParams& application,
                             const std::string& policy_app_id,
                             const std::string& device_id,
                             int64_t* application_primary_key,
                             int64_t global_properties_key) const;

  /**
   * @brief Calls InsertApplicationData method
   * @param application contains data for saving to DB
   * @param policy_app_id contains mobile application id of application
   * @param device_id contains id of device on which is running application
   * @return true if InsertApplicationData works successfully, otherwise
   * returns false;
   */
  bool InsertApplicationData(app_mngr::ApplicationSharedPtr application,
                             const std::string& policy_app_id,
                             const std::string& device_id);

  /**
   * @brief Delete application data where ign_off_count >= application_lifes
   * @param application_lifes contains amount ign off
   * @return true if query was run successfully otherwise returns
   * false
   */
  bool DeleteAppWithIgnCount(const int application_lifes);

  /**
   * @brief Selects data from file table
   * @param policy_app_id contains mobile application id of application
   * @param device_id contains id of device on which is running application
   * @param saved_app will contain data from file table
   * @return true if query was run successfully otherwise returns
   * false
   */
  bool SelectFilesData(const std::string& policy_app_id,
                       const std::string& device_id,
                       smart_objects::SmartObject& saved_app) const;

  /**
   * @brief Selects data from subMenu table
   * @param policy_app_id contains mobile application id of application
   * @param device_id contains id of device on which is running application
   * @param saved_app will contain data from subMenu table
   * @return true if query was run successfully otherwise returns
   * false
   */
  bool SelectSubmenuData(const std::string& policy_app_id,
                         const std::string& device_id,
                         smart_objects::SmartObject& saved_app) const;

  /**
   * @brief Selects data from commands table
   * @param policy_app_id contains mobile application id of application
   * @param device_id contains id of device on which is running application
   * @param saved_app will contain commands
   * @return true if query was run successfully otherwise returns
   * false
   */
  bool SelectCommandData(const std::string& policy_app_id,
                         const std::string& device_id,
                         smart_objects::SmartObject& saved_app) const;

  /**
   * @brief Selects data from applicationSubscriptionsArray table
   * @param policy_app_id contains mobile application id of application
   * @param device_id contains id of device on which is running application
   * @param saved_app will contain subscriptions
   * @return true if query was run successfully otherwise returns
   * false
   */
  bool SelectSubscriptionsData(const std::string& policy_app_id,
                               const std::string& device_id,
                               smart_objects::SmartObject& saved_app) const;

  /**
   * @brief Selects data from applicationUserLocation table
   * @param policy_app_id contains mobile application id of application
   * @param device_id contains id of device on which is running application
   * @param saved_app contains userLocation
   * @return true if query has been executed successfully otherwise returns
   * false
   */
  bool SelectUserLocationData(const std::string& policy_app_id,
                              const std::string& device_id,
                              smart_objects::SmartObject& saved_app) const;

  /**
   * @brief Selects choice set data from DB
   * @param policy_app_id contains mobile application id of application
   * @param device_id contains id of device on which is running application
   * @param saved_app will contain choiceSets
   * @return true if query was run successfully otherwise returns
   * false
   */
  bool SelectChoiceSetData(const std::string& policy_app_id,
                           const std::string& device_id,
                           smart_objects::SmartObject& saved_app) const;

  /**
   * @brief Selects global properties data from DB
   * @param policy_app_id contains mobile application id of application
   * @param device_id contains id of device on which is running application
   * @param saved_app will contain global properties
   * @return true if query was run successfully otherwise returns
   * false
   */
  bool SelectGlobalPropertiesData(const std::string& policy_app_id,
                                  const std::string& device_id,
                                  smart_objects::SmartObject& saved_app) const;

  /**
   * @brief Selects image data from DB
   * @param image_key primary key from image table
   * @param image will contain image data from DB
   * @return true if query was run successfully otherwise returns
   * false
   */
  bool SelectImageData(int64_t image_key,
                       smart_objects::SmartObject& image) const;

  /**
   * @brief Selects ttsChunk data from DB
   * @param tts_chunk_key primary key from ttsChunk table
   * @param tts_chunk will contain ttsChunk data from DB
   * @return true if query was run successfully otherwise returns
   * false
   */
  bool SelectTTSChunkData(int64_t tts_chunk_key,
                          smart_objects::SmartObject& tts_chunk) const;

  /**
   * @brief Selects VR help items data from DB
   * @param global_properties_key primary key from global properties table
   * @param global_properties will contain VR help items
   * @return true if query was run successfully otherwise returns
   * false
   */
  bool SelectVrHelpItemsData(
      int64_t global_properties_key,
      smart_objects::SmartObject& global_properties) const;

  /**
   * @brief Selects table limited character data from DB
   * @param global_properties_key primary key from global properties table
   * @param keyboard_properties will contain table limited character
   * @return true if query was run successfully otherwise returns
   * false
   */
  bool SelectCharactersData(
      int64_t global_properties_key,
      smart_objects::SmartObject& keyboard_properties) const;

  /**
   * @brief Selects data from application table of DB
   * @param policy_app_id contains mobile application id of application
   * @param device_id contains id of device on which is running application
   * @param saved_app will contain data from application table
   * @return true if query was run successfully otherwise returns
   * false
   */
  bool SelectDataFromAppTable(const std::string& policy_app_id,
                              const std::string& device_id,
                              smart_objects::SmartObject& saved_app) const;

  /**
   * @brief Selects count from array table
   * @param count_item will contain amount item in table
   * @param text_query - contains text of query
   * @param policy_app_id contains mobile application id of application
   * @param device_id contains id of device on which is running application
   * @return true if query was run successfully otherwise returns
   * false
   */
  bool SelectCountFromArray(uint32_t& count_item,
                            const std::string& text_query,
                            const std::string& policy_app_id,
                            const std::string& device_id) const;

  /**
   * @brief Binds data from smart object with query
   * @param key contains key from smart object
   * @param so contains data which needs to bind with query
   * @param query object of query for DB
   * @param pos contains position for binding query
   */
  void CustomBind(const std::string& key,
                  const smart_objects::SmartObject& so,
                  utils::dbms::SQLQuery& query,
                  const int pos) const;

  /**
   * @brief prepare and bind the same type query
   * @param query object of query for DB
   * @param policy_app_id contains mobile application id of application
   * @param device_id contains id of device on which is running application
   * @param text_query - contains text of query
   * @return true if query was binded successfully otherwise returns
   * false
   */
  bool PrepareSelectQuery(utils::dbms::SQLQuery& query,
                          const std::string& policy_app_id,
                          const std::string& device_id,
                          const std::string& text_query) const;

  /**
   * @brief Updates HMI level and time stamp in application table
   * @param application contains data for saving
   * @param policy_app_id - mobile application id
   * @param device_id - contains id of device on which is running application
   * @return true if application data were updated successfully
   * otherwise returns false
   */
  bool UpdateApplicationData(app_mngr::ApplicationConstSharedPtr application,
                             const std::string& policy_app_id,
                             const std::string& device_id);

  /**
   * @brief Writes data to DB after update
   */
  void WriteDb();

  /**
   * @brief Updates grammarID for application
   * @param policy_app_id Application ID
   * @param device_id Device ID
   * @param grammar_id GrammarID
   * @return true if succedeed, otherwise - false
   */
  bool UpdateGrammarID(const std::string& policy_app_id,
                       const std::string& device_id,
                       const uint32_t grammar_id);

  DISALLOW_COPY_AND_ASSIGN(ResumptionDataDB);

  utils::dbms::SQLDatabase* db_;
  mutable sync_primitives::RecursiveLock resumption_lock_;
};
}  // namespace resumption

#endif  // SRC_COMPONENTS_APPLICATION_MANAGER_INCLUDE_APPLICATION_MANAGER_RESUMPTION_RESUMPTION_DATA_DB_H_