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

   1 /******************************************************************************
   2  * Icinga 2                                                                   *
   3  * Copyright (C) 2012-2017 Icinga Development Team (https://www.icinga.com/)  *
   4  *                                                                            *
   5  * This program is free software; you can redistribute it and/or              *
   6  * modify it under the terms of the GNU General Public License                *
   7  * as published by the Free Software Foundation; either version 2             *
   8  * of the License, or (at your option) any later version.                     *
   9  *                                                                            *
  10  * This program is distributed in the hope that it will be useful,            *
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of             *
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the              *
  13  * GNU General Public License for more details.                               *
  14  *                                                                            *
  15  * You should have received a copy of the GNU General Public License          *
  16  * along with this program; if not, write to the Free Software Foundation     *
  17  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA.             *
  18  ******************************************************************************/
  19
  20 #include "db_ido/userdbobject.hpp"
  21 #include "db_ido/usergroupdbobject.hpp"
  22 #include "db_ido/dbtype.hpp"
  23 #include "db_ido/dbvalue.hpp"
  24 #include "icinga/user.hpp"
  25 #include "icinga/notification.hpp"
  26 #include "base/convert.hpp"
  27 #include "base/objectlock.hpp"
  28 #include "base/logger.hpp"
  29
  30 using namespace icinga;
  31
  32 REGISTER_DBTYPE(User, "contact", DbObjectTypeContact, "contact_object_id", UserDbObject);
  33
  34 UserDbObject::UserDbObject(const DbType::Ptr& type, const String& name1, const String& name2)
  35         : DbObject(type, name1, name2)
  36 { }
  37
  38 Dictionary::Ptr UserDbObject::GetConfigFields(void) const
  39 {
  40         Dictionary::Ptr fields = new Dictionary();
  41         User::Ptr user = static_pointer_cast<User>(GetObject());
  42
  43         fields->Set("alias", user->GetDisplayName());
  44         fields->Set("email_address", user->GetEmail());
  45         fields->Set("pager_address", user->GetPager());
  46         fields->Set("host_timeperiod_object_id", user->GetPeriod());
  47         fields->Set("service_timeperiod_object_id", user->GetPeriod());
  48         fields->Set("host_notifications_enabled", user->GetEnableNotifications());
  49         fields->Set("service_notifications_enabled", user->GetEnableNotifications());
  50         fields->Set("can_submit_commands", 1);
  51
  52         int typeFilter = user->GetTypeFilter();
  53         int stateFilter = user->GetStateFilter();
  54
  55         fields->Set("notify_service_recovery", (typeFilter & NotificationRecovery) != 0);
  56         fields->Set("notify_service_warning", (stateFilter & StateFilterWarning) != 0);
  57         fields->Set("notify_service_unknown", (stateFilter & StateFilterUnknown) != 0);
  58         fields->Set("notify_service_critical", (stateFilter & StateFilterCritical) != 0);
  59         fields->Set("notify_service_flapping", (typeFilter & (NotificationFlappingStart | NotificationFlappingEnd)) != 0);
  60         fields->Set("notify_service_downtime", (typeFilter & (NotificationDowntimeStart | NotificationDowntimeEnd | NotificationDowntimeRemoved)) != 0);
  61         fields->Set("notify_host_recovery", (typeFilter & NotificationRecovery) != 0);
  62         fields->Set("notify_host_down", (stateFilter & StateFilterDown) != 0);
  63         fields->Set("notify_host_flapping", (typeFilter & (NotificationFlappingStart | NotificationFlappingEnd)) != 0);
  64         fields->Set("notify_host_downtime", (typeFilter & (NotificationDowntimeStart | NotificationDowntimeEnd | NotificationDowntimeRemoved)) != 0);
  65
  66         return fields;
  67 }
  68
  69 Dictionary::Ptr UserDbObject::GetStatusFields(void) const
  70 {
  71         Dictionary::Ptr fields = new Dictionary();
  72         User::Ptr user = static_pointer_cast<User>(GetObject());
  73
  74         fields->Set("host_notifications_enabled", user->GetEnableNotifications());
  75         fields->Set("service_notifications_enabled", user->GetEnableNotifications());
  76         fields->Set("last_host_notification", DbValue::FromTimestamp(user->GetLastNotification()));
  77         fields->Set("last_service_notification", DbValue::FromTimestamp(user->GetLastNotification()));
  78
  79         return fields;
  80 }
  81
  82 void UserDbObject::OnConfigUpdateHeavy(void)
  83 {
  84         User::Ptr user = static_pointer_cast<User>(GetObject());
  85
  86         /* groups */
  87         Array::Ptr groups = user->GetGroups();
  88
  89         std::vector<DbQuery> queries;
  90
  91         DbQuery query1;
  92         query1.Table = DbType::GetByName("UserGroup")->GetTable() + "_members";
  93         query1.Type = DbQueryDelete;
  94         query1.Category = DbCatConfig;
  95         query1.WhereCriteria = new Dictionary();
  96         query1.WhereCriteria->Set("contact_object_id", user);
  97         queries.emplace_back(std::move(query1));
  98
  99         if (groups) {
 100                 ObjectLock olock(groups);
 101                 for (const String& groupName : groups) {
 102                         UserGroup::Ptr group = UserGroup::GetByName(groupName);
 103
 104                         DbQuery query2;
 105                         query2.Table = DbType::GetByName("UserGroup")->GetTable() + "_members";
 106                         query2.Type = DbQueryInsert | DbQueryUpdate;
 107                         query2.Category = DbCatConfig;
 108                         query2.Fields = new Dictionary();
 109                         query2.Fields->Set("instance_id", 0); /* DbConnection class fills in real ID */
 110                         query2.Fields->Set("contactgroup_id", DbValue::FromObjectInsertID(group));
 111                         query2.Fields->Set("contact_object_id", user);
 112                         query2.WhereCriteria = new Dictionary();
 113                         query2.WhereCriteria->Set("instance_id", 0); /* DbConnection class fills in real ID */
 114                         query2.WhereCriteria->Set("contactgroup_id", DbValue::FromObjectInsertID(group));
 115                         query2.WhereCriteria->Set("contact_object_id", user);
 116                         queries.emplace_back(std::move(query2));
 117                 }
 118         }
 119
 120         DbObject::OnMultipleQueries(queries);
 121
 122         queries.clear();
 123
 124         DbQuery query2;
 125         query2.Table = "contact_addresses";
 126         query2.Type = DbQueryDelete;
 127         query2.Category = DbCatConfig;
 128         query2.WhereCriteria = new Dictionary();
 129         query2.WhereCriteria->Set("contact_id", DbValue::FromObjectInsertID(user));
 130         queries.emplace_back(std::move(query2));
 131
 132         Dictionary::Ptr vars = user->GetVars();
 133
 134         if (vars) { /* This is sparta. */
 135                 for (int i = 1; i <= 6; i++) {
 136                         Dictionary::Ptr fields = new Dictionary();
 137
 138                         String key = "address" + Convert::ToString(i);
 139
 140                         if (!vars->Contains(key))
 141                                 continue;
 142
 143                         String val = vars->Get(key);
 144
 145                         fields->Set("contact_id", DbValue::FromObjectInsertID(user));
 146                         fields->Set("address_number", i);
 147                         fields->Set("address", val);
 148                         fields->Set("instance_id", 0); /* DbConnection class fills in real ID */
 149
 150                         DbQuery query;
 151                         query.Type = DbQueryInsert;
 152                         query.Table = "contact_addresses";
 153                         query.Category = DbCatConfig;
 154                         query.Fields = fields;
 155                         queries.emplace_back(std::move(query));
 156                 }
 157         }
 158
 159         DbObject::OnMultipleQueries(queries);
 160 }
 161
 162 String UserDbObject::CalculateConfigHash(const Dictionary::Ptr& configFields) const
 163 {
 164         String hashData = DbObject::CalculateConfigHash(configFields);
 165
 166         User::Ptr user = static_pointer_cast<User>(GetObject());
 167
 168         Array::Ptr groups = user->GetGroups();
 169
 170         if (groups)
 171                 hashData += DbObject::HashValue(groups);
 172
 173         return SHA256(hashData);
 174 }