granicus.if.org Git - icinga2/blob - lib/db_ido/userdbobject.cpp

   1 /* Icinga 2 | (c) 2012 Icinga GmbH | GPLv2+ */
   2
   3 #include "db_ido/userdbobject.hpp"
   4 #include "db_ido/usergroupdbobject.hpp"
   5 #include "db_ido/dbtype.hpp"
   6 #include "db_ido/dbvalue.hpp"
   7 #include "icinga/user.hpp"
   8 #include "icinga/notification.hpp"
   9 #include "base/convert.hpp"
  10 #include "base/objectlock.hpp"
  11 #include "base/logger.hpp"
  12
  13 using namespace icinga;
  14
  15 REGISTER_DBTYPE(User, "contact", DbObjectTypeContact, "contact_object_id", UserDbObject);
  16
  17 UserDbObject::UserDbObject(const DbType::Ptr& type, const String& name1, const String& name2)
  18         : DbObject(type, name1, name2)
  19 { }
  20
  21 Dictionary::Ptr UserDbObject::GetConfigFields() const
  22 {
  23         User::Ptr user = static_pointer_cast<User>(GetObject());
  24
  25         int typeFilter = user->GetTypeFilter();
  26         int stateFilter = user->GetStateFilter();
  27
  28         return new Dictionary({
  29                 { "alias", user->GetDisplayName() },
  30                 { "email_address", user->GetEmail() },
  31                 { "pager_address", user->GetPager() },
  32                 { "host_timeperiod_object_id", user->GetPeriod() },
  33                 { "service_timeperiod_object_id", user->GetPeriod() },
  34                 { "host_notifications_enabled", user->GetEnableNotifications() },
  35                 { "service_notifications_enabled", user->GetEnableNotifications() },
  36                 { "can_submit_commands", 1 },
  37                 { "notify_service_recovery", (typeFilter & NotificationRecovery) ? 1 : 0 },
  38                 { "notify_service_warning", (stateFilter & StateFilterWarning) ? 1 : 0 },
  39                 { "notify_service_unknown", (stateFilter & StateFilterUnknown) ? 1 : 0 },
  40                 { "notify_service_critical", (stateFilter & StateFilterCritical) ? 1 : 0 },
  41                 { "notify_service_flapping", (typeFilter & (NotificationFlappingStart | NotificationFlappingEnd)) ? 1 : 0 },
  42                 { "notify_service_downtime", (typeFilter & (NotificationDowntimeStart | NotificationDowntimeEnd | NotificationDowntimeRemoved)) ? 1 : 0 },
  43                 { "notify_host_recovery", (typeFilter & NotificationRecovery) ? 1 : 0 },
  44                 { "notify_host_down", (stateFilter & StateFilterDown) ? 1 : 0 },
  45                 { "notify_host_flapping", (typeFilter & (NotificationFlappingStart | NotificationFlappingEnd)) ? 1 : 0 },
  46                 { "notify_host_downtime", (typeFilter & (NotificationDowntimeStart | NotificationDowntimeEnd | NotificationDowntimeRemoved)) ? 1 : 0 }
  47         });
  48 }
  49
  50 Dictionary::Ptr UserDbObject::GetStatusFields() const
  51 {
  52         User::Ptr user = static_pointer_cast<User>(GetObject());
  53
  54         return new Dictionary({
  55                 { "host_notifications_enabled", user->GetEnableNotifications() },
  56                 { "service_notifications_enabled", user->GetEnableNotifications() },
  57                 { "last_host_notification", DbValue::FromTimestamp(user->GetLastNotification()) },
  58                 { "last_service_notification", DbValue::FromTimestamp(user->GetLastNotification()) }
  59         });
  60 }
  61
  62 void UserDbObject::OnConfigUpdateHeavy()
  63 {
  64         User::Ptr user = static_pointer_cast<User>(GetObject());
  65
  66         /* groups */
  67         Array::Ptr groups = user->GetGroups();
  68
  69         std::vector<DbQuery> queries;
  70
  71         DbQuery query1;
  72         query1.Table = DbType::GetByName("UserGroup")->GetTable() + "_members";
  73         query1.Type = DbQueryDelete;
  74         query1.Category = DbCatConfig;
  75         query1.WhereCriteria = new Dictionary({
  76                 { "contact_object_id", user }
  77         });
  78         queries.emplace_back(std::move(query1));
  79
  80         if (groups) {
  81                 ObjectLock olock(groups);
  82                 for (const String& groupName : groups) {
  83                         UserGroup::Ptr group = UserGroup::GetByName(groupName);
  84
  85                         DbQuery query2;
  86                         query2.Table = DbType::GetByName("UserGroup")->GetTable() + "_members";
  87                         query2.Type = DbQueryInsert | DbQueryUpdate;
  88                         query2.Category = DbCatConfig;
  89                         query2.Fields = new Dictionary({
  90                                 { "instance_id", 0 }, /* DbConnection class fills in real ID */
  91                                 { "contactgroup_id", DbValue::FromObjectInsertID(group) },
  92                                 { "contact_object_id", user }
  93                         });
  94                         query2.WhereCriteria = new Dictionary({
  95                                 { "instance_id", 0 }, /* DbConnection class fills in real ID */
  96                                 { "contactgroup_id", DbValue::FromObjectInsertID(group) },
  97                                 { "contact_object_id", user }
  98                         });
  99                         queries.emplace_back(std::move(query2));
 100                 }
 101         }
 102
 103         DbObject::OnMultipleQueries(queries);
 104
 105         queries.clear();
 106
 107         DbQuery query2;
 108         query2.Table = "contact_addresses";
 109         query2.Type = DbQueryDelete;
 110         query2.Category = DbCatConfig;
 111         query2.WhereCriteria = new Dictionary({
 112                 { "contact_id", DbValue::FromObjectInsertID(user) }
 113         });
 114         queries.emplace_back(std::move(query2));
 115
 116         Dictionary::Ptr vars = user->GetVars();
 117
 118         if (vars) { /* This is sparta. */
 119                 for (int i = 1; i <= 6; i++) {
 120                         String key = "address" + Convert::ToString(i);
 121
 122                         if (!vars->Contains(key))
 123                                 continue;
 124
 125                         String val = vars->Get(key);
 126
 127                         DbQuery query;
 128                         query.Type = DbQueryInsert;
 129                         query.Table = "contact_addresses";
 130                         query.Category = DbCatConfig;
 131                         query.Fields = new Dictionary({
 132                                 { "contact_id", DbValue::FromObjectInsertID(user) },
 133                                 { "address_number", i },
 134                                 { "address", val },
 135                                 { "instance_id", 0 } /* DbConnection class fills in real ID */
 136
 137                         });
 138                         queries.emplace_back(std::move(query));
 139                 }
 140         }
 141
 142         DbObject::OnMultipleQueries(queries);
 143 }
 144
 145 String UserDbObject::CalculateConfigHash(const Dictionary::Ptr& configFields) const
 146 {
 147         String hashData = DbObject::CalculateConfigHash(configFields);
 148
 149         User::Ptr user = static_pointer_cast<User>(GetObject());
 150
 151         Array::Ptr groups = user->GetGroups();
 152
 153         if (groups)
 154                 hashData += DbObject::HashValue(groups);
 155
 156         return SHA256(hashData);
 157 }