800 lines
28 KiB
C
800 lines
28 KiB
C
/*
|
|
* This file is part of matrix-glib-sdk
|
|
*
|
|
* matrix-glib-sdk is free software: you can redistribute it and/or
|
|
* modify it under the terms of the GNU Lesser General Public
|
|
* License as published by the Free Software Foundation, either
|
|
* version 3 of the License, or (at your option) any later version.
|
|
*
|
|
* matrix-glib-sdk 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 Lesser General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU Lesser General Public
|
|
* License along with matrix-glib-sdk. If not, see
|
|
* <http://www.gnu.org/licenses/>.
|
|
*/
|
|
|
|
#include "matrix-event-room-power-levels.h"
|
|
#include "matrix-types.h"
|
|
#include "config.h"
|
|
|
|
/**
|
|
* SECTION:matrix-event-room-power-levels
|
|
* @short_description: event to control power level assignments
|
|
*
|
|
* This is the default event handler for `m.room.power_levels` events.
|
|
*
|
|
* This event specifies the minimum level a user must have in order to perform a certain
|
|
* action. It also specifies the levels of each user in the room. If a `user_id` is in the
|
|
* users list, then that `user_id` has the associated power level. Otherwise they have the
|
|
* default level set in `users_default`. If `users_default` is not supplied, it is assumed to
|
|
* be 0. The level required to send a certain event is governed by the keys `events`,
|
|
* `state_default` and `events_default`. If an event type is specified in events, then the
|
|
* user must have at least the level specified in order to send that event. If the event type
|
|
* is not supplied, it defaults to `events_default` for message events and `state_default` for
|
|
* state events.
|
|
*/
|
|
enum {
|
|
PROP_0,
|
|
PROP_USERS_DEFAULT,
|
|
PROP_EVENTS_DEFAULT,
|
|
PROP_STATE_DEFAULT,
|
|
PROP_BAN,
|
|
PROP_KICK,
|
|
PROP_REDACT,
|
|
PROP_INVITE,
|
|
PROP_EVENT_LEVELS,
|
|
PROP_USER_LEVELS,
|
|
NUM_PROPERTIES
|
|
};
|
|
|
|
static GParamSpec *matrix_event_room_power_levels_properties[NUM_PROPERTIES];
|
|
|
|
typedef struct {
|
|
gint _users_default;
|
|
gint _events_default;
|
|
gint _state_default;
|
|
gint _ban;
|
|
gint _kick;
|
|
gint _redact;
|
|
gint _invite;
|
|
GHashTable* _event_levels;
|
|
GHashTable* _user_levels;
|
|
} MatrixEventRoomPowerLevelsPrivate;
|
|
|
|
/**
|
|
* MatrixEventRoomPowerLevels:
|
|
*/
|
|
G_DEFINE_TYPE_WITH_PRIVATE(MatrixEventRoomPowerLevels, matrix_event_room_power_levels, MATRIX_EVENT_TYPE_STATE);
|
|
|
|
static void
|
|
matrix_event_room_power_levels_real_from_json(MatrixEventBase *matrix_event_base, JsonNode *json_data, GError **error)
|
|
{
|
|
MatrixEventRoomPowerLevelsPrivate *priv;
|
|
JsonObject *root;
|
|
JsonObject *content_root;
|
|
JsonNode *content_node;
|
|
JsonNode *node;
|
|
|
|
g_return_if_fail (json_data != NULL);
|
|
|
|
priv = matrix_event_room_power_levels_get_instance_private(MATRIX_EVENT_ROOM_POWER_LEVELS(matrix_event_base));
|
|
root = json_node_get_object(json_data);
|
|
content_node = json_object_get_member(root, "content");
|
|
content_root = json_node_get_object(content_node);
|
|
|
|
#if DEBUG
|
|
if ((node = json_object_get_member(root, "state_key")) != NULL) {
|
|
const gchar *state_key = json_node_get_string(node);
|
|
|
|
if ((state_key == NULL) || (*state_key == 0)) {
|
|
g_warning("state_key of a m.room.power_levels event is non-empty");
|
|
}
|
|
}
|
|
#endif
|
|
|
|
if ((node = json_object_get_member(content_root, "ban")) != NULL) {
|
|
priv->_ban = json_node_get_int(node);
|
|
} else {
|
|
g_warning("content.ban is missing from a m.room.power_levels event");
|
|
}
|
|
|
|
if ((node = json_object_get_member(content_root, "kick")) != NULL) {
|
|
priv->_kick = json_node_get_int(node);
|
|
} else {
|
|
g_warning("content.kick is missing from a m.room.power_levels event");
|
|
}
|
|
|
|
if ((node = json_object_get_member(content_root, "redact")) != NULL) {
|
|
priv->_redact = json_node_get_int(node);
|
|
} else {
|
|
g_warning("content.redact is missing from a m.room.power_levels event");
|
|
}
|
|
|
|
if ((node = json_object_get_member(content_root, "events_default")) != NULL) {
|
|
priv->_events_default = json_node_get_int(node);
|
|
} else {
|
|
g_warning("content.events_default is missing from a m.room.power_levels event");
|
|
}
|
|
|
|
if ((node = json_object_get_member(content_root, "state_default")) != NULL) {
|
|
priv->_state_default = json_node_get_int(node);
|
|
} else {
|
|
g_warning("content.state_default is missing from a m.room.power_levels event");
|
|
}
|
|
|
|
if ((node = json_object_get_member(content_root, "users_default")) != NULL) {
|
|
priv->_users_default = json_node_get_int(node);
|
|
}
|
|
|
|
if ((node = json_object_get_member(content_root, "invite")) != NULL) {
|
|
priv->_invite = json_node_get_int(node);
|
|
}
|
|
|
|
if ((node = json_object_get_member(content_root, "events")) != NULL) {
|
|
JsonObject *events_root;
|
|
JsonObjectIter iter;
|
|
const gchar *event_name;
|
|
JsonNode *event_node;
|
|
|
|
g_hash_table_remove_all(priv->_event_levels);
|
|
|
|
events_root = json_node_get_object(node);
|
|
json_object_iter_init(&iter, events_root);
|
|
|
|
while (json_object_iter_next(&iter, &event_name, &event_node)) {
|
|
g_hash_table_insert(priv->_event_levels, g_strdup(event_name), GINT_TO_POINTER(json_node_get_int(event_node)));
|
|
}
|
|
}
|
|
|
|
if ((node = json_object_get_member(content_root, "users")) != NULL) {
|
|
JsonObject *users_root;
|
|
JsonObjectIter iter;
|
|
const gchar *user_id;
|
|
JsonNode *user_node;
|
|
|
|
g_hash_table_remove_all(priv->_user_levels);
|
|
|
|
users_root = json_node_get_object(node);
|
|
json_object_iter_init(&iter, users_root);
|
|
|
|
while (json_object_iter_next(&iter, &user_id, &user_node)) {
|
|
g_hash_table_insert(priv->_user_levels, g_strdup(user_id), GINT_TO_POINTER(json_node_get_int(user_node)));
|
|
}
|
|
}
|
|
|
|
MATRIX_EVENT_BASE_CLASS(matrix_event_room_power_levels_parent_class)->from_json(matrix_event_base, json_data, error);
|
|
}
|
|
|
|
static void
|
|
matrix_event_room_power_levels_real_to_json(MatrixEventBase *matrix_event_base, JsonNode *json_data, GError **error)
|
|
{
|
|
MatrixEventRoomPowerLevelsPrivate *priv;
|
|
JsonObject *root;
|
|
JsonObject *content_root;
|
|
JsonObject *users_root;
|
|
JsonObject *events_root;
|
|
JsonNode *content_node;
|
|
JsonNode *users_node;
|
|
JsonNode *events_node;
|
|
GHashTableIter iter;
|
|
const gchar *state_key;
|
|
gpointer key;
|
|
gpointer value;
|
|
|
|
g_return_if_fail (json_data != NULL);
|
|
|
|
priv = matrix_event_room_power_levels_get_instance_private(MATRIX_EVENT_ROOM_POWER_LEVELS(matrix_event_base));
|
|
root = json_node_get_object(json_data);
|
|
content_node = json_object_get_member(root, "content");
|
|
content_root = json_node_get_object(content_node);
|
|
|
|
state_key = matrix_event_state_get_state_key(MATRIX_EVENT_STATE(matrix_event_base));
|
|
|
|
if ((state_key == NULL) || (*state_key == 0)) {
|
|
g_set_error(error, MATRIX_ERROR, MATRIX_ERROR_INCOMPLETE,
|
|
"Won't generate a m.room.power_levels event with a non-empty state_key");
|
|
|
|
return;
|
|
}
|
|
|
|
if (priv->_user_levels == NULL) {
|
|
g_set_error(error, MATRIX_ERROR, MATRIX_ERROR_INCOMPLETE,
|
|
"Won't create an m.room.power_levels event without a content.users key");
|
|
|
|
return;
|
|
}
|
|
|
|
if (priv->_event_levels == NULL) {
|
|
g_set_error(error, MATRIX_ERROR, MATRIX_ERROR_INCOMPLETE,
|
|
"Won't create an m.room.power_levels event without a content.events key");
|
|
|
|
return;
|
|
}
|
|
|
|
json_object_set_int_member(content_root, "ban", priv->_ban);
|
|
json_object_set_int_member(content_root, "kick", priv->_kick);
|
|
json_object_set_int_member(content_root, "redact", priv->_redact);
|
|
json_object_set_int_member(content_root, "state_default", priv->_state_default);
|
|
json_object_set_int_member(content_root, "events_default", priv->_events_default);
|
|
|
|
users_root = json_object_new();
|
|
users_node = json_node_new(JSON_NODE_OBJECT);
|
|
json_node_set_object(users_node, users_root);
|
|
|
|
g_hash_table_iter_init(&iter, priv->_user_levels);
|
|
|
|
while (g_hash_table_iter_next(&iter, &key, &value)) {
|
|
json_object_set_int_member(users_root, g_strdup(key), GPOINTER_TO_INT(value));
|
|
}
|
|
|
|
json_object_set_member(content_root, "users", users_node);
|
|
|
|
events_root = json_object_new();
|
|
events_node = json_node_new(JSON_NODE_OBJECT);
|
|
json_node_set_object(events_node, events_root);
|
|
|
|
g_hash_table_iter_init(&iter, priv->_event_levels);
|
|
|
|
while (g_hash_table_iter_next(&iter, &key, &value)) {
|
|
json_object_set_int_member(events_root, g_strdup(key), GPOINTER_TO_INT(value));
|
|
}
|
|
|
|
json_object_set_member(content_root, "events", events_node);
|
|
|
|
MATRIX_EVENT_BASE_CLASS(matrix_event_room_power_levels_parent_class)->to_json(matrix_event_base, json_data, error);
|
|
}
|
|
|
|
/**
|
|
* matrix_event_room_power_levels_set_user_level:
|
|
* @event: a #MatrixEventRoomPowerLevels
|
|
* @user_id: (transfer none) (not nullable): a Matrix ID
|
|
* @level: the level to set for @user_id
|
|
*
|
|
* Set the level of @user_id to @level in @event.
|
|
*/
|
|
void
|
|
matrix_event_room_power_levels_set_user_level(MatrixEventRoomPowerLevels *matrix_event_room_power_levels, const gchar *user_id, gint level)
|
|
{
|
|
MatrixEventRoomPowerLevelsPrivate *priv;
|
|
|
|
g_return_if_fail(matrix_event_room_power_levels != NULL);
|
|
g_return_if_fail(user_id != NULL);
|
|
|
|
priv = matrix_event_room_power_levels_get_instance_private(matrix_event_room_power_levels);
|
|
|
|
g_hash_table_insert(priv->_user_levels, g_strdup(user_id), GINT_TO_POINTER(level));
|
|
}
|
|
|
|
/**
|
|
* matrix_event_room_power_levels_set_event_level:
|
|
* @event: a #MatrixEventRoomPowerLevels
|
|
* @event_type: an event type name
|
|
* @level: the required level for sending @event_type messages
|
|
*
|
|
* Set the level required to send messages with type @event_type to @level.
|
|
*/
|
|
void
|
|
matrix_event_room_power_levels_set_event_level(MatrixEventRoomPowerLevels *matrix_event_room_power_levels, const gchar *event_type, gint level)
|
|
{
|
|
MatrixEventRoomPowerLevelsPrivate *priv;
|
|
|
|
g_return_if_fail(matrix_event_room_power_levels != NULL);
|
|
g_return_if_fail(event_type != NULL);
|
|
|
|
priv = matrix_event_room_power_levels_get_instance_private(matrix_event_room_power_levels);
|
|
|
|
g_hash_table_insert(priv->_event_levels, g_strdup(event_type), GINT_TO_POINTER(level));
|
|
}
|
|
|
|
/**
|
|
* matrix_event_room_power_levels_new:
|
|
*
|
|
* Create a new #MatrixEventRoomPowerLevels object
|
|
*
|
|
* Returns: (transfer full): a new #MatrixEventRoomPowerLevels object
|
|
*/
|
|
MatrixEventRoomPowerLevels *
|
|
matrix_event_room_power_levels_new(void)
|
|
{
|
|
return (MatrixEventRoomPowerLevels *)matrix_event_state_construct(MATRIX_EVENT_TYPE_ROOM_POWER_LEVELS);
|
|
}
|
|
|
|
/**
|
|
* matrix_event_room_power_levels_get_users_default:
|
|
* @event: a #MatrixEventRoomPowerLevels
|
|
*
|
|
* Get the default user level from @event.
|
|
*
|
|
* Returns: a power level
|
|
*/
|
|
gint
|
|
matrix_event_room_power_levels_get_users_default(MatrixEventRoomPowerLevels *matrix_event_room_power_levels)
|
|
{
|
|
MatrixEventRoomPowerLevelsPrivate *priv;
|
|
|
|
g_return_val_if_fail(matrix_event_room_power_levels != NULL, 0);
|
|
|
|
priv = matrix_event_room_power_levels_get_instance_private(matrix_event_room_power_levels);
|
|
|
|
return priv->_users_default;
|
|
}
|
|
|
|
/**
|
|
* matrix_event_room_power_levels_set_users_default:
|
|
* @event: a #MatrixEventRoomPowerLevels
|
|
* @users_default: a power level
|
|
*
|
|
* Set the default user level in @event.
|
|
*/
|
|
void
|
|
matrix_event_room_power_levels_set_users_default(MatrixEventRoomPowerLevels *matrix_event_room_power_levels, gint users_default)
|
|
{
|
|
MatrixEventRoomPowerLevelsPrivate *priv;
|
|
|
|
g_return_if_fail(matrix_event_room_power_levels != NULL);
|
|
|
|
priv = matrix_event_room_power_levels_get_instance_private(matrix_event_room_power_levels);
|
|
|
|
if (priv->_users_default != users_default) {
|
|
priv->_users_default = users_default;
|
|
|
|
g_object_notify_by_pspec((GObject *)matrix_event_room_power_levels, matrix_event_room_power_levels_properties[PROP_USERS_DEFAULT]);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* matrix_event_room_power_levels_get_events_default:
|
|
* @event: a #MatrixEventRoomPowerLevels
|
|
*
|
|
* Get the level required to send messages in @event, if not otherwise set with
|
|
* matrix_event_room_power_levels_set_event_level()
|
|
*/
|
|
gint
|
|
matrix_event_room_power_levels_get_events_default(MatrixEventRoomPowerLevels *matrix_event_room_power_levels)
|
|
{
|
|
MatrixEventRoomPowerLevelsPrivate *priv;
|
|
|
|
g_return_val_if_fail(matrix_event_room_power_levels != NULL, 0);
|
|
|
|
priv = matrix_event_room_power_levels_get_instance_private(matrix_event_room_power_levels);
|
|
|
|
return priv->_events_default;
|
|
}
|
|
|
|
/**
|
|
* matrix_event_room_power_levels_set_events_default:
|
|
* @event: a #MatrixEventRoomPowerLevels
|
|
* @events_default: a power level
|
|
*
|
|
* Set the event level required for sending message events. This is the default value to be
|
|
* used for events that are not set with matrix_event_room_power_levels_set_event_level().
|
|
*/
|
|
void
|
|
matrix_event_room_power_levels_set_events_default(MatrixEventRoomPowerLevels *matrix_event_room_power_levels, gint events_default)
|
|
{
|
|
MatrixEventRoomPowerLevelsPrivate *priv;
|
|
|
|
g_return_if_fail(matrix_event_room_power_levels != NULL);
|
|
|
|
priv = matrix_event_room_power_levels_get_instance_private(matrix_event_room_power_levels);
|
|
|
|
if (priv->_events_default != events_default) {
|
|
priv->_events_default = events_default;
|
|
|
|
g_object_notify_by_pspec((GObject *)matrix_event_room_power_levels, matrix_event_room_power_levels_properties[PROP_EVENTS_DEFAULT]);
|
|
}
|
|
}
|
|
|
|
gint
|
|
matrix_event_room_power_levels_get_state_default(MatrixEventRoomPowerLevels *matrix_event_room_power_levels)
|
|
{
|
|
MatrixEventRoomPowerLevelsPrivate *priv;
|
|
|
|
g_return_val_if_fail(matrix_event_room_power_levels != NULL, 0);
|
|
|
|
priv = matrix_event_room_power_levels_get_instance_private(matrix_event_room_power_levels);
|
|
return priv->_state_default;
|
|
}
|
|
|
|
void
|
|
matrix_event_room_power_levels_set_state_default(MatrixEventRoomPowerLevels *matrix_event_room_power_levels, gint state_default)
|
|
{
|
|
MatrixEventRoomPowerLevelsPrivate *priv;
|
|
|
|
g_return_if_fail(matrix_event_room_power_levels != NULL);
|
|
|
|
priv = matrix_event_room_power_levels_get_instance_private(matrix_event_room_power_levels);
|
|
|
|
if (priv->_state_default != state_default) {
|
|
priv->_state_default = state_default;
|
|
|
|
g_object_notify_by_pspec((GObject *)matrix_event_room_power_levels, matrix_event_room_power_levels_properties[PROP_STATE_DEFAULT]);
|
|
}
|
|
}
|
|
|
|
gint
|
|
matrix_event_room_power_levels_get_ban(MatrixEventRoomPowerLevels *matrix_event_room_power_levels)
|
|
{
|
|
MatrixEventRoomPowerLevelsPrivate *priv;
|
|
|
|
g_return_val_if_fail(matrix_event_room_power_levels != NULL, 0);
|
|
|
|
priv = matrix_event_room_power_levels_get_instance_private(matrix_event_room_power_levels);
|
|
|
|
return priv->_ban;
|
|
}
|
|
|
|
void
|
|
matrix_event_room_power_levels_set_ban(MatrixEventRoomPowerLevels *matrix_event_room_power_levels, gint ban)
|
|
{
|
|
MatrixEventRoomPowerLevelsPrivate *priv;
|
|
|
|
g_return_if_fail(matrix_event_room_power_levels != NULL);
|
|
|
|
priv = matrix_event_room_power_levels_get_instance_private(matrix_event_room_power_levels);
|
|
|
|
if (priv->_ban != ban) {
|
|
priv->_ban = ban;
|
|
|
|
g_object_notify_by_pspec((GObject *) matrix_event_room_power_levels, matrix_event_room_power_levels_properties[PROP_BAN]);
|
|
}
|
|
}
|
|
|
|
gint
|
|
matrix_event_room_power_levels_get_kick(MatrixEventRoomPowerLevels *matrix_event_room_power_levels)
|
|
{
|
|
MatrixEventRoomPowerLevelsPrivate *priv;
|
|
|
|
g_return_val_if_fail(matrix_event_room_power_levels != NULL, 0);
|
|
|
|
priv = matrix_event_room_power_levels_get_instance_private(matrix_event_room_power_levels);
|
|
|
|
return priv->_kick;
|
|
}
|
|
|
|
void
|
|
matrix_event_room_power_levels_set_kick(MatrixEventRoomPowerLevels *matrix_event_room_power_levels, gint kick)
|
|
{
|
|
MatrixEventRoomPowerLevelsPrivate *priv;
|
|
|
|
g_return_if_fail(matrix_event_room_power_levels != NULL);
|
|
|
|
priv = matrix_event_room_power_levels_get_instance_private(matrix_event_room_power_levels);
|
|
|
|
if (priv->_kick != kick) {
|
|
priv->_kick = kick;
|
|
|
|
g_object_notify_by_pspec((GObject *)matrix_event_room_power_levels, matrix_event_room_power_levels_properties[PROP_KICK]);
|
|
}
|
|
}
|
|
|
|
gint
|
|
matrix_event_room_power_levels_get_redact(MatrixEventRoomPowerLevels *matrix_event_room_power_levels)
|
|
{
|
|
MatrixEventRoomPowerLevelsPrivate *priv;
|
|
|
|
g_return_val_if_fail(matrix_event_room_power_levels != NULL, 0);
|
|
|
|
priv = matrix_event_room_power_levels_get_instance_private(matrix_event_room_power_levels);
|
|
|
|
return priv->_redact;
|
|
}
|
|
|
|
void
|
|
matrix_event_room_power_levels_set_redact(MatrixEventRoomPowerLevels *matrix_event_room_power_levels, gint redact)
|
|
{
|
|
MatrixEventRoomPowerLevelsPrivate *priv;
|
|
|
|
g_return_if_fail(matrix_event_room_power_levels != NULL);
|
|
|
|
priv = matrix_event_room_power_levels_get_instance_private(matrix_event_room_power_levels);
|
|
|
|
if (priv->_redact != redact) {
|
|
priv->_redact = redact;
|
|
|
|
g_object_notify_by_pspec((GObject *)matrix_event_room_power_levels, matrix_event_room_power_levels_properties[PROP_REDACT]);
|
|
}
|
|
}
|
|
|
|
gint
|
|
matrix_event_room_power_levels_get_invite(MatrixEventRoomPowerLevels *matrix_event_room_power_levels)
|
|
{
|
|
MatrixEventRoomPowerLevelsPrivate *priv;
|
|
|
|
g_return_val_if_fail(matrix_event_room_power_levels != NULL, 0);
|
|
|
|
priv = matrix_event_room_power_levels_get_instance_private(matrix_event_room_power_levels);
|
|
|
|
return priv->_invite;
|
|
}
|
|
|
|
void
|
|
matrix_event_room_power_levels_set_invite(MatrixEventRoomPowerLevels *matrix_event_room_power_levels, gint invite)
|
|
{
|
|
MatrixEventRoomPowerLevelsPrivate *priv;
|
|
|
|
g_return_if_fail(matrix_event_room_power_levels != NULL);
|
|
|
|
priv = matrix_event_room_power_levels_get_instance_private(matrix_event_room_power_levels);
|
|
|
|
if (priv->_invite != invite) {
|
|
priv->_invite = invite;
|
|
|
|
g_object_notify_by_pspec((GObject *)matrix_event_room_power_levels, matrix_event_room_power_levels_properties[PROP_INVITE]);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* matrix_event_room_power_levels_get_event_levels:
|
|
* @event: a #MatrixEventRoomPowerLevels
|
|
*
|
|
* Returns: (transfer none): the list of event type power level requirements
|
|
*/
|
|
GHashTable *
|
|
matrix_event_room_power_levels_get_event_levels(MatrixEventRoomPowerLevels *matrix_event_room_power_levels)
|
|
{
|
|
MatrixEventRoomPowerLevelsPrivate *priv;
|
|
|
|
g_return_val_if_fail(matrix_event_room_power_levels != NULL, NULL);
|
|
|
|
priv = matrix_event_room_power_levels_get_instance_private(matrix_event_room_power_levels);
|
|
|
|
return priv->_event_levels;
|
|
}
|
|
|
|
/**
|
|
* matrix_event_room_power_levels_get_user_levels:
|
|
* @event: a #MatrixEventRoomPowerLevels
|
|
*
|
|
* Get the table of individual user levels from @event.
|
|
*
|
|
* The returned value is owned by @event and should not be freed.
|
|
*
|
|
* The returned #GHashTable has user IDs as keys. The value are integer power levels
|
|
* converted to pointers; use GPOINTER_TO_INT() to convert them to actual power levels.
|
|
*
|
|
* Returns: (transfer none) (nullable): a table of user levels
|
|
*/
|
|
GHashTable *
|
|
matrix_event_room_power_levels_get_user_levels(MatrixEventRoomPowerLevels *matrix_event_room_power_levels)
|
|
{
|
|
MatrixEventRoomPowerLevelsPrivate *priv;
|
|
|
|
g_return_val_if_fail(matrix_event_room_power_levels != NULL, NULL);
|
|
|
|
priv = matrix_event_room_power_levels_get_instance_private(matrix_event_room_power_levels);
|
|
|
|
return priv->_user_levels;
|
|
}
|
|
|
|
static void
|
|
matrix_event_room_power_levels_finalize(GObject *gobject)
|
|
{
|
|
MatrixEventRoomPowerLevelsPrivate *priv = matrix_event_room_power_levels_get_instance_private(MATRIX_EVENT_ROOM_POWER_LEVELS(gobject));
|
|
|
|
g_hash_table_unref(priv->_event_levels);
|
|
g_hash_table_unref(priv->_user_levels);
|
|
|
|
G_OBJECT_CLASS(matrix_event_room_power_levels_parent_class)->finalize(gobject);
|
|
}
|
|
|
|
static void
|
|
matrix_event_room_power_levels_get_property(GObject *gobject, guint property_id, GValue *value, GParamSpec *pspec)
|
|
{
|
|
MatrixEventRoomPowerLevels *matrix_event_room_power_levels = MATRIX_EVENT_ROOM_POWER_LEVELS(gobject);
|
|
|
|
switch (property_id) {
|
|
case PROP_USERS_DEFAULT:
|
|
g_value_set_int(value, matrix_event_room_power_levels_get_users_default(matrix_event_room_power_levels));
|
|
|
|
break;
|
|
case PROP_EVENTS_DEFAULT:
|
|
g_value_set_int(value, matrix_event_room_power_levels_get_events_default(matrix_event_room_power_levels));
|
|
|
|
break;
|
|
case PROP_STATE_DEFAULT:
|
|
g_value_set_int(value, matrix_event_room_power_levels_get_state_default(matrix_event_room_power_levels));
|
|
|
|
break;
|
|
case PROP_BAN:
|
|
g_value_set_int(value, matrix_event_room_power_levels_get_ban(matrix_event_room_power_levels));
|
|
|
|
break;
|
|
case PROP_KICK:
|
|
g_value_set_int(value, matrix_event_room_power_levels_get_kick(matrix_event_room_power_levels));
|
|
|
|
break;
|
|
case PROP_REDACT:
|
|
g_value_set_int(value, matrix_event_room_power_levels_get_redact(matrix_event_room_power_levels));
|
|
|
|
break;
|
|
case PROP_INVITE:
|
|
g_value_set_int(value, matrix_event_room_power_levels_get_invite(matrix_event_room_power_levels));
|
|
|
|
break;
|
|
case PROP_EVENT_LEVELS:
|
|
g_value_set_boxed(value, matrix_event_room_power_levels_get_event_levels(matrix_event_room_power_levels));
|
|
|
|
break;
|
|
case PROP_USER_LEVELS:
|
|
g_value_set_boxed(value, matrix_event_room_power_levels_get_user_levels(matrix_event_room_power_levels));
|
|
|
|
break;
|
|
default:
|
|
G_OBJECT_WARN_INVALID_PROPERTY_ID(gobject, property_id, pspec);
|
|
|
|
break;
|
|
}
|
|
}
|
|
|
|
static void
|
|
matrix_event_room_power_levels_set_property(GObject *gobject, guint property_id, const GValue *value, GParamSpec *pspec)
|
|
{
|
|
MatrixEventRoomPowerLevels *matrix_event_room_power_levels = MATRIX_EVENT_ROOM_POWER_LEVELS(gobject);
|
|
|
|
switch (property_id) {
|
|
case PROP_USERS_DEFAULT:
|
|
matrix_event_room_power_levels_set_users_default(matrix_event_room_power_levels, g_value_get_int(value));
|
|
|
|
break;
|
|
case PROP_EVENTS_DEFAULT:
|
|
matrix_event_room_power_levels_set_events_default(matrix_event_room_power_levels, g_value_get_int(value));
|
|
|
|
break;
|
|
case PROP_STATE_DEFAULT:
|
|
matrix_event_room_power_levels_set_state_default(matrix_event_room_power_levels, g_value_get_int(value));
|
|
|
|
break;
|
|
case PROP_BAN:
|
|
matrix_event_room_power_levels_set_ban(matrix_event_room_power_levels, g_value_get_int(value));
|
|
|
|
break;
|
|
case PROP_KICK:
|
|
matrix_event_room_power_levels_set_kick(matrix_event_room_power_levels, g_value_get_int(value));
|
|
|
|
break;
|
|
case PROP_REDACT:
|
|
matrix_event_room_power_levels_set_redact(matrix_event_room_power_levels, g_value_get_int(value));
|
|
|
|
break;
|
|
case PROP_INVITE:
|
|
matrix_event_room_power_levels_set_invite(matrix_event_room_power_levels, g_value_get_int(value));
|
|
|
|
break;
|
|
default:
|
|
G_OBJECT_WARN_INVALID_PROPERTY_ID(gobject, property_id, pspec);
|
|
break;
|
|
}
|
|
}
|
|
|
|
static void
|
|
matrix_event_room_power_levels_class_init(MatrixEventRoomPowerLevelsClass *klass)
|
|
{
|
|
((MatrixEventBaseClass *)klass)->from_json = matrix_event_room_power_levels_real_from_json;
|
|
((MatrixEventBaseClass *)klass)->to_json = matrix_event_room_power_levels_real_to_json;
|
|
G_OBJECT_CLASS(klass)->get_property = matrix_event_room_power_levels_get_property;
|
|
G_OBJECT_CLASS(klass)->set_property = matrix_event_room_power_levels_set_property;
|
|
G_OBJECT_CLASS(klass)->finalize = matrix_event_room_power_levels_finalize;
|
|
|
|
/**
|
|
* MatrixEventRoomPowerLevels:users-default:
|
|
*
|
|
* The default power level for every user in the room, unless their user ID is mentioned
|
|
* in the #MatrixEventRoomPowerLevels:users property.
|
|
*/
|
|
matrix_event_room_power_levels_properties[PROP_USERS_DEFAULT] = g_param_spec_int(
|
|
"users-default", "users-default", "users-default",
|
|
G_MININT, G_MAXINT, 0,
|
|
G_PARAM_STATIC_STRINGS | G_PARAM_READWRITE);
|
|
g_object_class_install_property(G_OBJECT_CLASS(klass), PROP_USERS_DEFAULT, matrix_event_room_power_levels_properties[PROP_USERS_DEFAULT]);
|
|
|
|
/**
|
|
* MatrixEventRoomPowerLevels:events-default:
|
|
*
|
|
* The default level required to send message events. Can be overridden with values in
|
|
* the #MatrixEventRoomPowerLevels:events property.
|
|
*/
|
|
matrix_event_room_power_levels_properties[PROP_EVENTS_DEFAULT] = g_param_spec_int(
|
|
"events-default", "events-default", "events-default",
|
|
G_MININT, G_MAXINT, 0,
|
|
G_PARAM_STATIC_STRINGS | G_PARAM_READWRITE);
|
|
g_object_class_install_property(G_OBJECT_CLASS(klass), PROP_EVENTS_DEFAULT, matrix_event_room_power_levels_properties[PROP_EVENTS_DEFAULT]);
|
|
|
|
/**
|
|
* MatrixEventRoomPowerLevels:state-default:
|
|
*
|
|
* The default level required to send state events. Can be overridden with values in the
|
|
* #MatrixEventRoomPowerLevels:events property.
|
|
*/
|
|
matrix_event_room_power_levels_properties[PROP_STATE_DEFAULT] = g_param_spec_int(
|
|
"state-default", "state-default", "state-default",
|
|
G_MININT, G_MAXINT, 10,
|
|
G_PARAM_STATIC_STRINGS | G_PARAM_READWRITE);
|
|
g_object_class_install_property(G_OBJECT_CLASS(klass), PROP_STATE_DEFAULT, matrix_event_room_power_levels_properties[PROP_STATE_DEFAULT]);
|
|
|
|
/**
|
|
* MatrixEventRoomPowerLevels:ban:
|
|
*
|
|
* The level required to ban a user.
|
|
*/
|
|
matrix_event_room_power_levels_properties[PROP_BAN] = g_param_spec_int(
|
|
"ban", "ban", "ban",
|
|
G_MININT, G_MAXINT, 5,
|
|
G_PARAM_STATIC_STRINGS | G_PARAM_READWRITE);
|
|
g_object_class_install_property(G_OBJECT_CLASS(klass), PROP_BAN, matrix_event_room_power_levels_properties[PROP_BAN]);
|
|
|
|
/**
|
|
* MatrixEventRoomPowerLevels:kick:
|
|
*
|
|
* The level required to kick a user.
|
|
*/
|
|
matrix_event_room_power_levels_properties[PROP_KICK] = g_param_spec_int(
|
|
"kick", "kick", "kick",
|
|
G_MININT, G_MAXINT, 5,
|
|
G_PARAM_STATIC_STRINGS | G_PARAM_READWRITE);
|
|
g_object_class_install_property(G_OBJECT_CLASS(klass), PROP_KICK, matrix_event_room_power_levels_properties[PROP_KICK]);
|
|
|
|
/**
|
|
* MatrixEventRoomPowerLevels:redact:
|
|
*
|
|
* The level required to redact an event.
|
|
*/
|
|
matrix_event_room_power_levels_properties[PROP_REDACT] = g_param_spec_int(
|
|
"redact", "redact", "redact",
|
|
G_MININT, G_MAXINT, 20,
|
|
G_PARAM_STATIC_STRINGS | G_PARAM_READWRITE);
|
|
g_object_class_install_property(G_OBJECT_CLASS(klass), PROP_REDACT, matrix_event_room_power_levels_properties[PROP_REDACT]);
|
|
|
|
/**
|
|
* MatrixEventRoomPowerLevels:invite:
|
|
*
|
|
* The level required to invite someone.
|
|
*/
|
|
matrix_event_room_power_levels_properties[PROP_INVITE] = g_param_spec_int(
|
|
"invite", "invite", "invite",
|
|
G_MININT, G_MAXINT, 0,
|
|
G_PARAM_STATIC_STRINGS | G_PARAM_READWRITE);
|
|
g_object_class_install_property(G_OBJECT_CLASS(klass), PROP_INVITE, matrix_event_room_power_levels_properties[PROP_INVITE]);
|
|
|
|
/**
|
|
* MatrixEventRoomPowerLevels:event-levels:
|
|
*
|
|
* A hash map to store the required level to send specific events.
|
|
*/
|
|
matrix_event_room_power_levels_properties[PROP_EVENT_LEVELS] = g_param_spec_boxed(
|
|
"event-levels", "event-levels", "event-levels",
|
|
G_TYPE_HASH_TABLE,
|
|
G_PARAM_STATIC_STRINGS | G_PARAM_READABLE);
|
|
g_object_class_install_property(G_OBJECT_CLASS(klass), PROP_EVENT_LEVELS, matrix_event_room_power_levels_properties[PROP_EVENT_LEVELS]);
|
|
|
|
/**
|
|
* MatrixEventRoomPowerLevels:user-levels:
|
|
*
|
|
* A hash map to store current level for individual users.
|
|
*/
|
|
matrix_event_room_power_levels_properties[PROP_USER_LEVELS] = g_param_spec_boxed(
|
|
"user-levels", "user-levels", "user-levels",
|
|
G_TYPE_HASH_TABLE,
|
|
G_PARAM_STATIC_STRINGS | G_PARAM_READABLE);
|
|
g_object_class_install_property(G_OBJECT_CLASS(klass), PROP_USER_LEVELS, matrix_event_room_power_levels_properties[PROP_USER_LEVELS]);
|
|
}
|
|
|
|
static void
|
|
matrix_event_room_power_levels_init(MatrixEventRoomPowerLevels *matrix_event_room_power_levels)
|
|
{
|
|
MatrixEventRoomPowerLevelsPrivate *priv = matrix_event_room_power_levels_get_instance_private(matrix_event_room_power_levels);
|
|
|
|
priv->_users_default = 0;
|
|
priv->_events_default = 0;
|
|
priv->_state_default = 10;
|
|
priv->_ban = 5;
|
|
priv->_kick = 5;
|
|
priv->_redact = 20;
|
|
priv->_invite = 0;
|
|
priv->_event_levels = g_hash_table_new_full(g_str_hash, g_str_equal, g_free, NULL);
|
|
priv->_user_levels = g_hash_table_new_full(g_str_hash, g_str_equal, g_free, NULL);
|
|
}
|