mirror of
https://github.com/matrix-construct/construct
synced 2024-12-04 20:52:45 +01:00
290 lines
5.4 KiB
C++
290 lines
5.4 KiB
C++
// Matrix Construct
|
|
//
|
|
// Copyright (C) Matrix Construct Developers, Authors & Contributors
|
|
// Copyright (C) 2016-2018 Jason Volk <jason@zemos.net>
|
|
//
|
|
// Permission to use, copy, modify, and/or distribute this software for any
|
|
// purpose with or without fee is hereby granted, provided that the above
|
|
// copyright notice and this permission notice is present in all copies. The
|
|
// full license for this software is available in the LICENSE file.
|
|
|
|
namespace ircd::m::sync
|
|
{
|
|
static long _notification_count(const room &, const event::idx &a, const event::idx &b);
|
|
static long _highlight_count(const room &, const user &u, const event::idx &a, const event::idx &b);
|
|
static event::idx _read_marker(data &, const room &);
|
|
static bool room_unread_notifications_polylog(data &);
|
|
static bool room_unread_notifications_linear(data &);
|
|
|
|
extern item room_unread_notifications;
|
|
}
|
|
|
|
ircd::mapi::header
|
|
IRCD_MODULE
|
|
{
|
|
"Client Sync :Room Unread Notifications"
|
|
};
|
|
|
|
decltype(ircd::m::sync::room_unread_notifications)
|
|
ircd::m::sync::room_unread_notifications
|
|
{
|
|
"rooms.unread_notifications",
|
|
room_unread_notifications_polylog,
|
|
room_unread_notifications_linear,
|
|
};
|
|
|
|
bool
|
|
ircd::m::sync::room_unread_notifications_linear(data &data)
|
|
{
|
|
if(!data.event_idx)
|
|
return false;
|
|
|
|
if(!data.room)
|
|
return false;
|
|
|
|
const bool is_user_room
|
|
{
|
|
data.room->room_id == data.user_room.room_id
|
|
};
|
|
|
|
assert(data.event);
|
|
const auto &type
|
|
{
|
|
json::get<"type"_>(*data.event)
|
|
};
|
|
|
|
const bool is_self_read
|
|
{
|
|
is_user_room &&
|
|
type == "ircd.read"
|
|
};
|
|
|
|
const bool is_push_note
|
|
{
|
|
is_user_room &&
|
|
startswith(type, user::notifications::type_prefix)
|
|
};
|
|
|
|
const user::notifications::opts note_opts
|
|
{
|
|
is_push_note?
|
|
user::notifications::unmake_type(type):
|
|
user::notifications::opts{}
|
|
};
|
|
|
|
const m::room &room
|
|
{
|
|
is_self_read?
|
|
room::id{at<"state_key"_>(*data.event)}:
|
|
is_push_note && note_opts.room_id?
|
|
note_opts.room_id:
|
|
data.room->room_id
|
|
};
|
|
|
|
char membuf[32];
|
|
const string_view &membership
|
|
{
|
|
room.room_id != data.room->room_id?
|
|
m::membership(membuf, room, data.user):
|
|
data.membership
|
|
};
|
|
|
|
if(!membership)
|
|
return false;
|
|
|
|
// skips state events only until a non-state event is seen.
|
|
if(likely(!is_user_room))
|
|
if(defined(json::get<"state_key"_>(*data.event)))
|
|
return false;
|
|
|
|
// skips old events the server has backfilled in the background.
|
|
if(likely(!is_user_room))
|
|
if(room::events::viewport_size >= 0)
|
|
if(json::get<"depth"_>(*data.event) + room::events::viewport_size < data.room_depth)
|
|
return false;
|
|
|
|
const event::idx marker_idx
|
|
{
|
|
!is_self_read?
|
|
_read_marker(data, room):
|
|
0UL
|
|
};
|
|
|
|
json::stack::object rooms
|
|
{
|
|
*data.out, "rooms"
|
|
};
|
|
|
|
json::stack::object membership_
|
|
{
|
|
*data.out, membership
|
|
};
|
|
|
|
json::stack::object room_
|
|
{
|
|
*data.out, room.room_id
|
|
};
|
|
|
|
json::stack::object unread_notifications
|
|
{
|
|
*data.out, "unread_notifications"
|
|
};
|
|
|
|
const event::idx upper_bound
|
|
{
|
|
std::max(data.range.second, data.event_idx)
|
|
};
|
|
|
|
const auto notification_count
|
|
{
|
|
marker_idx?
|
|
_notification_count(room, marker_idx, upper_bound):
|
|
0L
|
|
};
|
|
|
|
json::stack::member
|
|
{
|
|
*data.out, "notification_count", json::value
|
|
{
|
|
notification_count
|
|
}
|
|
};
|
|
|
|
json::stack::member
|
|
{
|
|
*data.out, "highlight_count", json::value
|
|
{
|
|
notification_count?
|
|
_highlight_count(room, data.user, marker_idx, upper_bound):
|
|
0L
|
|
}
|
|
};
|
|
|
|
return true;
|
|
}
|
|
|
|
bool
|
|
ircd::m::sync::room_unread_notifications_polylog(data &data)
|
|
{
|
|
if(!data.membership)
|
|
return false;
|
|
|
|
assert(data.room);
|
|
const auto &room
|
|
{
|
|
*data.room
|
|
};
|
|
|
|
const event::idx marker_idx
|
|
{
|
|
_read_marker(data, room)
|
|
};
|
|
|
|
if(!marker_idx)
|
|
return false;
|
|
|
|
const auto notification_count
|
|
{
|
|
_notification_count(room, marker_idx, data.range.second)
|
|
};
|
|
|
|
json::stack::member
|
|
{
|
|
*data.out, "notification_count", json::value
|
|
{
|
|
notification_count
|
|
}
|
|
};
|
|
|
|
json::stack::member
|
|
{
|
|
*data.out, "highlight_count", json::value
|
|
{
|
|
notification_count?
|
|
_highlight_count(room, data.user, marker_idx, data.range.second):
|
|
0L
|
|
}
|
|
};
|
|
|
|
return true;
|
|
}
|
|
|
|
ircd::m::event::idx
|
|
ircd::m::sync::_read_marker(data &data,
|
|
const room &room)
|
|
try
|
|
{
|
|
const m::user::room_account_data account_data
|
|
{
|
|
data.user, room
|
|
};
|
|
|
|
m::event::idx ret(0);
|
|
account_data.get(std::nothrow, "m.fully_read", [&ret]
|
|
(const string_view &, const json::object &content)
|
|
{
|
|
ret = index(std::nothrow, event::id
|
|
{
|
|
json::string
|
|
{
|
|
content["event_id"]
|
|
}
|
|
});
|
|
});
|
|
|
|
return ret;
|
|
}
|
|
catch(const m::INVALID_MXID &e)
|
|
{
|
|
log::derror
|
|
{
|
|
log, "account_data for %s in %s :invalid m.fully_read marker :%s",
|
|
string_view{data.user.user_id},
|
|
string_view{room.room_id},
|
|
e.what(),
|
|
};
|
|
|
|
return 0;
|
|
}
|
|
|
|
long
|
|
ircd::m::sync::_notification_count(const room &room,
|
|
const event::idx &a,
|
|
const event::idx &b)
|
|
{
|
|
const event::idx_range range
|
|
{
|
|
std::minmax(a, b)
|
|
};
|
|
|
|
return room::events::count(room, range);
|
|
}
|
|
|
|
long
|
|
ircd::m::sync::_highlight_count(const room &room,
|
|
const user &user,
|
|
const event::idx &a,
|
|
const event::idx &b)
|
|
{
|
|
const event::idx_range range
|
|
{
|
|
std::minmax(a, b)
|
|
};
|
|
|
|
const user::notifications notifications
|
|
{
|
|
user
|
|
};
|
|
|
|
user::notifications::opts opts;
|
|
opts.room_id = room.room_id;
|
|
opts.only = "highlight";
|
|
opts.from = range.second;
|
|
opts.to = range.first;
|
|
const auto ret
|
|
{
|
|
notifications.count(opts)
|
|
};
|
|
|
|
return ret;
|
|
}
|