mirror of https://gitlab.com/litecord/litecord.git
291 lines
8.6 KiB
Python
291 lines
8.6 KiB
Python
from typing import List, Dict, Any
|
|
|
|
from logbook import Logger
|
|
from litecord.enums import RelationshipType
|
|
|
|
log = Logger(__name__)
|
|
|
|
|
|
class UserStorage:
|
|
"""Storage functions related to a single user."""
|
|
def __init__(self, storage):
|
|
self.storage = storage
|
|
self.db = storage.db
|
|
|
|
async def fetch_notes(self, user_id: int) -> dict:
|
|
"""Fetch a users' notes"""
|
|
note_rows = await self.db.fetch("""
|
|
SELECT target_id, note
|
|
FROM notes
|
|
WHERE user_id = $1
|
|
""", user_id)
|
|
|
|
return {str(row['target_id']): row['note']
|
|
for row in note_rows}
|
|
|
|
async def get_user_settings(self, user_id: int) -> Dict[str, Any]:
|
|
"""Get current user settings."""
|
|
row = await self.storage.fetchrow_with_json("""
|
|
SELECT *
|
|
FROM user_settings
|
|
WHERE id = $1
|
|
""", user_id)
|
|
|
|
if not row:
|
|
log.info('Generating user settings for {}', user_id)
|
|
|
|
await self.db.execute("""
|
|
INSERT INTO user_settings (id)
|
|
VALUES ($1)
|
|
""", user_id)
|
|
|
|
# recalling get_user_settings
|
|
# should work after adding
|
|
return await self.get_user_settings(user_id)
|
|
|
|
drow = dict(row)
|
|
drow.pop('id')
|
|
return drow
|
|
|
|
async def get_relationships(self, user_id: int) -> List[Dict[str, Any]]:
|
|
"""Get all relationships for a user."""
|
|
# first, fetch all friendships outgoing
|
|
# from the user
|
|
_friend = RelationshipType.FRIEND.value
|
|
_block = RelationshipType.BLOCK.value
|
|
_incoming = RelationshipType.INCOMING.value
|
|
_outgoing = RelationshipType.OUTGOING.value
|
|
|
|
# check all outgoing friends
|
|
friends = await self.db.fetch("""
|
|
SELECT user_id, peer_id, rel_type
|
|
FROM relationships
|
|
WHERE user_id = $1 AND rel_type = $2
|
|
""", user_id, _friend)
|
|
friends = list(map(dict, friends))
|
|
|
|
# mutuals is a list of ints
|
|
# of people who are actually friends
|
|
# and accepted the friend request
|
|
mutuals = []
|
|
|
|
# for each outgoing, find if theres an outgoing from them
|
|
for row in friends:
|
|
is_friend = await self.db.fetchrow(
|
|
"""
|
|
SELECT user_id, peer_id
|
|
FROM relationships
|
|
WHERE user_id = $1 AND peer_id = $2 AND rel_type = $3
|
|
""", row['peer_id'], row['user_id'],
|
|
_friend)
|
|
|
|
if is_friend is not None:
|
|
mutuals.append(row['peer_id'])
|
|
|
|
# fetch friend requests directed at us
|
|
incoming_friends = await self.db.fetch("""
|
|
SELECT user_id, peer_id
|
|
FROM relationships
|
|
WHERE peer_id = $1 AND rel_type = $2
|
|
""", user_id, _friend)
|
|
|
|
# only need their ids
|
|
incoming_friends = [r['user_id'] for r in incoming_friends
|
|
if r['user_id'] not in mutuals]
|
|
|
|
# only fetch blocks we did,
|
|
# not fetching the ones people did to us
|
|
blocks = await self.db.fetch("""
|
|
SELECT user_id, peer_id, rel_type
|
|
FROM relationships
|
|
WHERE user_id = $1 AND rel_type = $2
|
|
""", user_id, _block)
|
|
blocks = list(map(dict, blocks))
|
|
|
|
res = []
|
|
|
|
for drow in friends:
|
|
drow['type'] = drow['rel_type']
|
|
drow['id'] = str(drow['peer_id'])
|
|
drow.pop('rel_type')
|
|
|
|
# check if the receiver is a mutual
|
|
# if it isnt, its still on a friend request stage
|
|
if drow['peer_id'] not in mutuals:
|
|
drow['type'] = _outgoing
|
|
|
|
drow['user'] = await self.storage.get_user(drow['peer_id'])
|
|
|
|
drow.pop('user_id')
|
|
drow.pop('peer_id')
|
|
res.append(drow)
|
|
|
|
for peer_id in incoming_friends:
|
|
res.append({
|
|
'id': str(peer_id),
|
|
'user': await self.storage.get_user(peer_id),
|
|
'type': _incoming,
|
|
})
|
|
|
|
for drow in blocks:
|
|
drow['type'] = drow['rel_type']
|
|
drow.pop('rel_type')
|
|
|
|
drow['id'] = str(drow['peer_id'])
|
|
drow['user'] = await self.storage.get_user(drow['peer_id'])
|
|
|
|
drow.pop('user_id')
|
|
drow.pop('peer_id')
|
|
res.append(drow)
|
|
|
|
return res
|
|
|
|
async def get_friend_ids(self, user_id: int) -> List[int]:
|
|
"""Get all friend IDs for a user."""
|
|
rels = await self.get_relationships(user_id)
|
|
|
|
return [int(r['user']['id'])
|
|
for r in rels
|
|
if r['type'] == RelationshipType.FRIEND.value]
|
|
|
|
async def get_dms(self, user_id: int) -> List[Dict[str, Any]]:
|
|
"""Get all DM channels for a user, including group DMs.
|
|
|
|
This will only fetch channels the user has in their state,
|
|
which is different than the whole list of DM channels.
|
|
"""
|
|
dm_ids = await self.db.fetch("""
|
|
SELECT dm_id
|
|
FROM dm_channel_state
|
|
WHERE user_id = $1
|
|
""", user_id)
|
|
|
|
dm_ids = [r['dm_id'] for r in dm_ids]
|
|
|
|
res = []
|
|
|
|
for dm_id in dm_ids:
|
|
dm_chan = await self.storage.get_dm(dm_id, user_id)
|
|
res.append(dm_chan)
|
|
|
|
return res
|
|
|
|
async def get_read_state(self, user_id: int) -> List[Dict[str, Any]]:
|
|
"""Get the read state for a user."""
|
|
rows = await self.db.fetch("""
|
|
SELECT channel_id, last_message_id, mention_count
|
|
FROM user_read_state
|
|
WHERE user_id = $1
|
|
""", user_id)
|
|
|
|
res = []
|
|
|
|
for row in rows:
|
|
drow = dict(row)
|
|
|
|
drow['id'] = str(drow['channel_id'])
|
|
drow.pop('channel_id')
|
|
|
|
drow['last_message_id'] = str(drow['last_message_id'])
|
|
|
|
res.append(drow)
|
|
|
|
return res
|
|
|
|
async def get_guild_settings_one(self, user_id: int,
|
|
guild_id: int) -> dict:
|
|
"""Get guild settings information for a single guild."""
|
|
row = await self.db.fetchrow("""
|
|
SELECT guild_id::text, suppress_everyone, muted,
|
|
message_notifications, mobile_push
|
|
FROM guild_settings
|
|
WHERE user_id = $1 AND guild_id = $2
|
|
""", user_id, guild_id)
|
|
|
|
if not row:
|
|
await self.db.execute("""
|
|
INSERT INTO guild_settings (user_id, guild_id)
|
|
VALUES ($1, $2)
|
|
""", user_id, guild_id)
|
|
|
|
return await self.get_guild_settings_one(user_id, guild_id)
|
|
|
|
gid = int(row['guild_id'])
|
|
drow = dict(row)
|
|
|
|
chan_overrides = {}
|
|
|
|
overrides = await self.db.fetch("""
|
|
SELECT channel_id::text, muted, message_notifications
|
|
FROM guild_settings_channel_overrides
|
|
WHERE
|
|
user_id = $1
|
|
AND guild_id = $2
|
|
""", user_id, gid)
|
|
|
|
for chan_row in overrides:
|
|
dcrow = dict(chan_row)
|
|
|
|
chan_id = dcrow['channel_id']
|
|
dcrow.pop('channel_id')
|
|
|
|
chan_overrides[chan_id] = dcrow
|
|
|
|
return {**drow, **{
|
|
'channel_overrides': chan_overrides
|
|
}}
|
|
|
|
async def get_guild_settings(self, user_id: int):
|
|
"""Get the specific User Guild Settings,
|
|
for all guilds a user is on."""
|
|
|
|
res = []
|
|
|
|
settings = await self.db.fetch("""
|
|
SELECT guild_id::text, suppress_everyone, muted,
|
|
message_notifications, mobile_push
|
|
FROM guild_settings
|
|
WHERE user_id = $1
|
|
""", user_id)
|
|
|
|
for row in settings:
|
|
gid = int(row['guild_id'])
|
|
drow = dict(row)
|
|
|
|
chan_overrides = {}
|
|
|
|
overrides = await self.db.fetch("""
|
|
SELECT channel_id::text, muted, message_notifications
|
|
FROM guild_settings_channel_overrides
|
|
WHERE
|
|
user_id = $1
|
|
AND guild_id = $2
|
|
""", user_id, gid)
|
|
|
|
for chan_row in overrides:
|
|
dcrow = dict(chan_row)
|
|
|
|
# channel_id isn't on the value of the dict
|
|
# so we query it (for the key) then pop
|
|
# from the value
|
|
chan_id = dcrow['channel_id']
|
|
dcrow.pop('channel_id')
|
|
|
|
chan_overrides[chan_id] = dcrow
|
|
|
|
res.append({**drow, **{
|
|
'channel_overrides': chan_overrides
|
|
}})
|
|
|
|
return res
|
|
|
|
async def get_user_guilds(self, user_id: int) -> List[int]:
|
|
"""Get all guild IDs a user is on."""
|
|
guild_ids = await self.db.fetch("""
|
|
SELECT guild_id
|
|
FROM members
|
|
WHERE user_id = $1
|
|
""", user_id)
|
|
|
|
return [row['guild_id'] for row in guild_ids]
|