group.hh

Go to the documentation of this file.

/*
 * libkeepass - KeePass key database importer/exporter
 * Copyright (C) 2014 Christian Kindahl
 * Copyright (C) 2024 Dominik Krümpelmann
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
#pragma once
#include <array>
#include <ctime>
#include <memory>
#include <optional>
#include <vector>
 
#include "entry.hh"
#include "libkeepass/export.hh"
 
namespace keepass {
 
class Icon;
 
class LIBKEEPASS_API Group final : public std::enable_shared_from_this<Group> {
private:
  std::array<uint8_t, 16> uuid_;
  uint32_t icon_ = 0;
  std::weak_ptr<Icon> custom_icon_;
  std::weak_ptr<Group> parent_;
  std::string name_;
  std::string notes_;
  std::string tags_;
  std::optional<std::array<uint8_t, 16>> previous_parent_group_;
  std::time_t creation_time_ = 0;
  std::time_t modification_time_ = 0;
  std::time_t access_time_ = 0;
  std::time_t expiry_time_ = 0;
  std::time_t move_time_ = 0;
  uint16_t flags_ = 0;
  bool expires_ = false;
  bool expanded_ = false;
  uint32_t usage_count_ = 0;
  std::string default_autotype_sequence_;
  bool autotype_ = false;
  bool search_ = false;
  std::weak_ptr<Entry> last_visible_entry_;
 
  std::vector<std::shared_ptr<Group>> groups_;
  std::vector<std::shared_ptr<Entry>> entries_;
 
public:
  Group();
 
  const std::array<uint8_t, 16>& uuid() const { return uuid_; }
 
  void set_uuid(const std::array<uint8_t, 16>& uuid) { uuid_ = uuid; }
 
  uint32_t icon() const { return icon_; }
 
  void set_icon(const uint32_t& icon) { icon_ = icon; }
 
  std::weak_ptr<Icon> custom_icon() const { return custom_icon_; }
 
  void set_custom_icon(std::weak_ptr<Icon> icon) { custom_icon_ = std::move(icon); }
 
  const std::string& name() const { return name_; }
 
  void set_name(const std::string& name) { name_ = name; }
 
  const std::string& notes() const { return notes_; }
 
  void set_notes(const std::string& notes) { notes_ = notes; }
 
  const std::string& tags() const { return tags_; }
 
  void set_tags(const std::string& tags) { tags_ = tags; }
 
  const std::optional<std::array<uint8_t, 16>>& previous_parent_group() const {
    return previous_parent_group_;
  }
 
  void set_previous_parent_group(const std::optional<std::array<uint8_t, 16>>& uuid) {
    previous_parent_group_ = uuid;
  }
 
  std::time_t creation_time() const { return creation_time_; }
 
  void set_creation_time(const std::time_t& time) { creation_time_ = time; }
 
  std::time_t modification_time() const { return modification_time_; }
 
  void set_modification_time(const std::time_t& time) { modification_time_ = time; }
 
  std::time_t access_time() const { return access_time_; }
 
  void set_access_time(const std::time_t& time) { access_time_ = time; }
 
  std::time_t expiry_time() const { return expiry_time_; }
 
  void set_expiry_time(const std::time_t& time) { expiry_time_ = time; }
 
  std::time_t move_time() const { return move_time_; }
 
  void set_move_time(const std::time_t& time) { move_time_ = time; }
 
  uint16_t flags() const { return flags_; }
 
  void set_flags(const uint16_t& flags) { flags_ = flags; }
 
  bool expires() const { return expires_; }
 
  void set_expires(bool expires) { expires_ = expires; }
 
  bool expanded() const { return expanded_; }
 
  void set_expanded(bool expanded) { expanded_ = expanded; }
 
  uint32_t usage_count() const { return usage_count_; }
 
  void set_usage_count(uint32_t usage_count) { usage_count_ = usage_count; }
 
  const std::string& default_autotype_sequence() const { return default_autotype_sequence_; }
 
  void set_default_autotype_sequence(std::string sequence) {
    default_autotype_sequence_ = std::move(sequence);
  }
 
  bool autotype() const { return autotype_; }
 
  void set_autotype(bool autotype) { autotype_ = autotype; }
 
  bool search() const { return search_; }
 
  void set_search(bool search) { search_ = search; }
 
  std::weak_ptr<Entry> last_visible_entry() const { return last_visible_entry_; }
 
  void set_last_visible_entry(std::weak_ptr<Entry> entry) {
    last_visible_entry_ = std::move(entry);
  }
 
  const std::vector<std::shared_ptr<Group>>& Groups() const;
 
  const std::vector<std::shared_ptr<Entry>>& Entries() const;
 
  std::weak_ptr<Group> parent() const { return parent_; }
 
  void set_parent(std::weak_ptr<Group> parent) { parent_ = std::move(parent); }
 
  bool is_root_group() const { return parent_.expired(); }
 
  std::string path() const;
 
  size_t entries_count() const { return entries_.size(); }
 
  size_t groups_count() const { return groups_.size(); }
 
 
  std::vector<std::shared_ptr<Entry>> FindEntries(const std::string& query, bool regex = false,
                                                  bool recursive = true) const;
 
 
  std::vector<std::shared_ptr<Group>> FindGroups(const std::string& query, bool regex = false,
                                                 bool recursive = true) const;
 
  void AddGroup(const std::shared_ptr<Group>& group);
 
  void RemoveGroup(const std::shared_ptr<Group>& group);
 
  void AddEntry(const std::shared_ptr<Entry>& entry);
 
  void RemoveEntry(const std::shared_ptr<Entry>& entry);
 
  bool HasNonMetaEntries() const;
 
  std::string ToJson(bool include_attachments = false) const;
 
  bool operator==(const Group& other) const;
 
  bool operator!=(const Group& other) const;
};
 
} // namespace keepass