leadguru-jobs 0.638.0__py3-none-any.whl → 0.640.0__py3-none-any.whl

lgt_jobs/lgt_data/models/user/user.py

@@ -0,0 +1,95 @@
+import copy
+from datetime import UTC, datetime
+from typing import List, Optional
+
+from bson import ObjectId
+
+from lgt_jobs.lgt_data.enums import UserRole
+from lgt_jobs.lgt_data.models.base import BaseModel
+from lgt_jobs.lgt_data.models.external.discord.user import DiscordUser
+from lgt_jobs.lgt_data.models.external.slack.user import SlackUser
+from lgt_jobs.lgt_data.models.notifications.notification_settings import NotificationSettings
+from lgt_jobs.lgt_data.models.people.profile import Profile
+from lgt_jobs.lgt_data.models.user.general_settings import GeneralSettings
+
+
+class UserModel(BaseModel):
+    def __init__(self):
+        super().__init__()
+        self.email: Optional[str] = None
+        self.password: Optional[str] = None
+        self.roles: List[str] = []
+        self.user_name: str = ''
+        self.company: str = ''
+        self.company_size: Optional[int] = None
+        self.company_industries: Optional[List[str]] = None
+        self.company_technologies: Optional[List[str]] = None
+        self.company_locations: Optional[List[str]] = None
+        self.company_web_site: str = ''
+        self.company_description: str = ''
+        self.position: str = ''
+        self.leads_limit: Optional[int] = None
+        self.leads_proceeded: Optional[int] = None
+        self.leads_filtered: Optional[int] = None
+        self.leads_limit_updated_at: Optional[int] = None
+        self.paid_lead_price: int = 1
+        self.state: int = 0
+        self.credits_exceeded_at: Optional[datetime] = None
+        self.unanswered_leads_period = None
+        self.inactive = None
+        self.slack_users: List[SlackUser] = []
+        self.discord_users: List[DiscordUser] = []
+        self.verified: bool = False
+        self.subscription_id: ObjectId | None = None
+        self.subscription_expired_at: datetime | None = None
+        self.balance: str | None = None
+        self.subscription_name: str | None = None
+        self.subscription_expiration_notified = False
+        self.subscription_expiration_warning_notified = False
+        self.notification_settings: NotificationSettings | None = None
+        self.general_settings: GeneralSettings | None = None
+
+    @classmethod
+    def from_dic(cls, dic: dict):
+        if not dic:
+            return None
+
+        model: UserModel = cls()
+        for k, v in dic.items():
+            setattr(model, k, v)
+
+        if '_id' in dic:
+            setattr(model, 'id', dic['_id'])
+
+        model.slack_profile = Profile.from_dic(dic.get('slack_profile'))
+        model.slack_users = [SlackUser.from_dic(user) for user in dic.get('slack_users', [])]
+        model.discord_users = [DiscordUser.from_dic(user) for user in dic.get('discord_users', [])]
+        model.notification_settings = NotificationSettings.from_dic(dic.get('notification_settings'))
+        model.general_settings = GeneralSettings.from_dic(dic.get('general_settings'))
+        return model
+
+    def to_dic(self):
+        result = copy.deepcopy(self.__dict__)
+
+        if result.get('slack_profile'):
+            result['slack_profile'] = result.get('slack_profile').__dict__
+        if result.get('notification_settings'):
+            result['notification_settings'] = NotificationSettings.to_dic(result.get('notification_settings'))
+        if result.get('general_settings'):
+            result['general_settings'] = GeneralSettings.to_dic(result.get('general_settings'))
+
+        return result
+
+    @property
+    def is_admin(self):
+        return UserRole.ADMIN in self.roles
+
+    @property
+    def subscription_expired(self):
+        return self.subscription_expired_at.replace(tzinfo=UTC) < datetime.now(UTC)
+
+    def get_slack_user(self, slack_email: str) -> SlackUser:
+        return next(filter(lambda x: slack_email == x.email, self.slack_users), None)
+
+    def get_discord_user(self, login: str) -> DiscordUser:
+        return next(filter(lambda x: login == x.login, self.discord_users), None)

lgt_jobs/lgt_data/models/user/user_follow_ups.py

@@ -0,0 +1,20 @@
+from lgt_jobs.lgt_data.models.base import DictionaryModel
+from lgt_jobs.lgt_data.models.leads.extended_lead import ExtendedLeadModel
+from lgt_jobs.lgt_data.models.notifications.notification_settings import NotificationSettings
+
+
+class UserFollowUps(DictionaryModel):
+    actual_follow_ups: list[ExtendedLeadModel] = []
+    overdue_follow_ups: list[ExtendedLeadModel] = []
+    email: str | None = None
+    notification_settings: NotificationSettings | None = None
+
+    @classmethod
+    def from_dic(cls, dic: dict):
+        if not dic:
+            return None
+        model: UserFollowUps | None = super().from_dic(dic)
+        model.actual_follow_ups = [ExtendedLeadModel.from_dic(lead) for lead in dic.get('actual_follow_ups', [])]
+        model.overdue_follow_ups = [ExtendedLeadModel.from_dic(lead) for lead in dic.get('overdue_follow_ups', [])]
+        model.notification_settings = NotificationSettings.from_dic(dic.get('notification_settings'))
+        return model

lgt_jobs/lgt_data/models/user/user_page.py

@@ -0,0 +1,19 @@
+from typing import List
+
+from lgt_jobs.lgt_data.models.user.user import UserModel
+
+
+class UsersPage:
+    users: List[UserModel]
+    count: int = 0
+
+    def __init__(self, users: List[UserModel], count: int):
+        self.users = users
+        self.count = count
+
+    @staticmethod
+    def from_dic(dic: dict):
+        users = [UserModel.from_dic(doc) for doc in dic.get('page', [])]
+        count = dic.get('count', 0)
+        return UsersPage(users=users, count=count)
+    

lgt_jobs/lgt_data/models/user/verification.py

@@ -0,0 +1,12 @@
+from datetime import datetime, UTC
+
+from lgt_jobs.lgt_data.models.base import DictionaryModel
+
+
+class UserVerificationModel(DictionaryModel):
+    pass
+
+    def __init__(self):
+        super().__init__()
+        self.email = None
+        self.created_at = datetime.now(UTC)

lgt_jobs/lgt_data/models/user_leads/extended_user_lead.py

@@ -0,0 +1,41 @@
+from typing import List
+
+from lgt_jobs.lgt_data.models.bots.bot_info import BotInfo
+from lgt_jobs.lgt_data.models.leads.lead import LeadModel
+from lgt_jobs.lgt_data.models.people.people import SlackMemberInformation
+from lgt_jobs.lgt_data.models.user_leads.user_lead import UserLeadModel
+
+
+class ExtendedUserLeadModel(UserLeadModel):
+    pass
+
+    def __init__(self):
+        super().__init__()
+        self.contact: SlackMemberInformation | None = None
+        self.previous_publications = []
+        self.bots: List[BotInfo] = []
+        self.user_email: str | None = None
+
+    @classmethod
+    def from_dic(cls, dic: dict):
+        if not dic:
+            return None
+
+        result: ExtendedUserLeadModel | None = super().from_dic(dic)
+        if not result:
+            return None
+
+        result.contact = SlackMemberInformation.from_dic(dic.get('contact'))
+        result.previous_publications = [LeadModel.from_dic(lead) for lead in dic.get('previous_publications', [])]
+        return result
+
+    def to_dic(self):
+        result = super().to_dic()
+        result["contact"] = self.contact.to_dic()
+        return result
+
+    def to_csv(self, board_name: str) -> List[str]:
+        return [self.message.source, self.contact.real_name, self.contact.title, self.contact.email,
+                self.notes, board_name, self.status,
+                self.followup_date.strftime("%d.%m.%Y %H:%M") if self.followup_date else "",
+                self.message.message.replace('\n', ' ').strip()]

lgt_jobs/lgt_data/models/user_leads/user_lead.py

@@ -0,0 +1,33 @@
+from datetime import datetime, UTC
+
+from bson import ObjectId
+
+from lgt_jobs.lgt_data.models.leads.lead import LeadModel
+
+
+class UserLeadModel(LeadModel):
+    pass
+
+    def __init__(self):
+        super().__init__()
+        self.order: int = 0
+        self.followup_date: datetime | None = None
+        self.user_id: ObjectId | None = None
+        self.chat_viewed_at: datetime | None = None
+        self.board_id: ObjectId | None = None
+
+    @classmethod
+    def from_dic(cls, dic: dict):
+        if not dic:
+            return None
+
+        result: UserLeadModel | None = super().from_dic(dic)
+        if not result:
+            return None
+
+        if result.followup_date:
+            result.followup_date.replace(tzinfo=UTC)
+
+        result.chat_viewed_at = dic.get('chat_viewed_at')
+        return result
+    

lgt_jobs/lgt_data/mongo_repository.py

@@ -6,14 +6,30 @@ from dateutil import tz
 from pymongo import MongoClient, UpdateOne
 from bson.objectid import ObjectId
 from lgt_jobs.lgt_data.enums import SourceType
-from lgt_jobs.lgt_data.model import (LeadModel, BaseModel, UserModel, UserResetPasswordModel, BoardModel, BoardedStatus,
-                                     DedicatedBotModel, SlackMemberInformation, UserTemplateModel,
-                                     ExtendedUserLeadModel, UserLeadModel, ExtendedLeadModel, UserContact, ChatMessage,
-                                     GroupedMessagesModel, UserVerificationModel, UsersPage, Subscription,
-                                     ScheduledMessage)
 from datetime import datetime, UTC, timedelta
 from collections import OrderedDict
-from lgt_jobs.lgt_data.models.message_request import MessageRequest
+
+from lgt_jobs.lgt_data.models.base import BaseModel
+from lgt_jobs.lgt_data.models.boards.board import BoardModel
+from lgt_jobs.lgt_data.models.boards.status import BoardedStatus
+from lgt_jobs.lgt_data.models.bots.dedicated_bot import DedicatedBotModel
+from lgt_jobs.lgt_data.models.chat.grouped_messages import GroupedMessagesModel
+from lgt_jobs.lgt_data.models.chat.message import ChatMessage
+from lgt_jobs.lgt_data.models.chat.scheduled_message import ScheduledMessage
+from lgt_jobs.lgt_data.models.chat.request import MessageRequest
+from lgt_jobs.lgt_data.models.contacts.contact import UserContact
+from lgt_jobs.lgt_data.models.leads.extended_lead import ExtendedLeadModel
+from lgt_jobs.lgt_data.models.leads.lead import LeadModel
+from lgt_jobs.lgt_data.models.people.people import SlackMemberInformation
+from lgt_jobs.lgt_data.models.templates.template import UserTemplateModel
+from lgt_jobs.lgt_data.models.user.reset_password import UserResetPasswordModel
+from lgt_jobs.lgt_data.models.user.subscription import Subscription
+from lgt_jobs.lgt_data.models.user.user import UserModel
+from lgt_jobs.lgt_data.models.user.user_follow_ups import UserFollowUps
+from lgt_jobs.lgt_data.models.user.user_page import UsersPage
+from lgt_jobs.lgt_data.models.user.verification import UserVerificationModel
+from lgt_jobs.lgt_data.models.user_leads.extended_user_lead import ExtendedUserLeadModel
+from lgt_jobs.lgt_data.models.user_leads.user_lead import UserLeadModel
 
 client = MongoClient(os.environ.get('MONGO_CONNECTION_STRING', 'mongodb://127.0.0.1:27017/'))
 
@@ -73,6 +89,10 @@ class UserMongoRepository(BaseMongoRepository):
         connected_slack_email = kwargs.get('connected_slack_email')
         soon_subscription_expiration = kwargs.get('soon_subscription_expiration')
         has_new_message = kwargs.get('has_new_message')
+        has_new_message_request = kwargs.get('has_new_message_request')
+        has_deactivated_sources = kwargs.get('has_deactivated_sources')
+        has_new_replies = kwargs.get('has_new_replies')
+        has_new_reactions = kwargs.get('has_new_reactions')
         min_days = kwargs.get('min_days_soon_subscription_expiration', 3)
 
         if subscription_expired:
@@ -87,6 +107,22 @@ class UserMongoRepository(BaseMongoRepository):
             pipeline['notification_settings.incoming_messages.enabled'] = True
             pipeline['notification_settings.incoming_messages.need_to_notify'] = True
 
+        if has_new_message_request:
+            pipeline['notification_settings.inbox.enabled'] = True
+            pipeline['notification_settings.inbox.need_to_notify'] = True
+
+        if has_deactivated_sources:
+            pipeline['notification_settings.source_deactivation.enabled'] = True
+            pipeline['notification_settings.source_deactivation.need_to_notify'] = True
+
+        if has_new_replies:
+            pipeline['notification_settings.bulk_replies.enabled'] = True
+            pipeline['notification_settings.bulk_replies.need_to_notify'] = True
+
+        if has_new_reactions:
+            pipeline['notification_settings.bulk_reactions.enabled'] = True
+            pipeline['notification_settings.bulk_reactions.need_to_notify'] = True
+
         if connected_slack_email:
             pipeline['slack_users.email'] = connected_slack_email
 
@@ -106,7 +142,7 @@ class UserMongoRepository(BaseMongoRepository):
         search = kwargs.get('search')
         sort_field = kwargs.get('sort_field', 'email')
         sort_direction = kwargs.get('sort_direction', 'ASCENDING')
-        sort_direction: int = pymongo.ASCENDING if sort_direction == 'ASCENDING' else pymongo.DESCENDING
+        sort_direction = pymongo.ASCENDING if sort_direction == 'ASCENDING' else pymongo.DESCENDING
         if not include_inactive:
             match_pipeline['inactive'] = False
         if email:
@@ -176,6 +212,81 @@ class UserLeadMongoRepository(BaseMongoRepository):
     collection_name = 'user_leads'
     model = ExtendedUserLeadModel
 
+    def get_leads_with_follow_ups(self):
+        now = datetime.now(UTC)
+        this_day = datetime(now.year, now.month, now.day, 21, 00, 00, tzinfo=UTC)
+        after_week = this_day + timedelta(7)
+        pipeline = [
+            {'$match': {'archived': False, 'followup_date': {'$ne': None}}},
+            {
+                '$lookup': {
+                    'from': 'users',
+                    'localField': 'user_id',
+                    'foreignField': '_id',
+                    'as': 'user'
+                }
+            },
+            {
+                '$lookup': {
+                    'from': 'slack_contact',
+                    'localField': 'message.sender_id',
+                    'foreignField': 'sender_id',
+                    'as': 'contact'
+                }
+            },
+            {'$addFields': {'contact': {'$first': '$contact'}, 'user': {'$first': '$user'}}},
+            {
+                '$project': {
+                    'user_id': 1,
+                    'user_email': '$user.email',
+                    'notification_settings': '$user.notification_settings',
+                    'followup_to': {
+                        '$cond': {
+                            'if': {'$eq': ['$user.notification_settings.follow_ups.type', 'once_a_day']},
+                            'then': this_day,
+                            'else': after_week
+                        }
+                    },
+                    'followup_date': 1,
+                    'contact': 1,
+                    'message.sender_id': 1,
+                    'message.source': 1
+                }
+            },
+            {'$group': {'_id': '$user_id', 'leads': {'$push': '$$ROOT'}}},
+            {
+                '$addFields': {
+                    'actual_follow_ups': {
+                        '$filter': {
+                            'input': '$leads',
+                            'as': 'lead',
+                            'cond': {
+                                '$and': [
+                                    {'$gte': ['$$lead.followup_date', now]},
+                                    {'$lte': ['$$lead.followup_date', '$$lead.followup_to']}
+                                ]
+                            }
+                        }
+                    },
+                    'overdue_follow_ups': {
+                        '$filter': {
+                            'input': '$leads',
+                            'as': 'lead',
+                            'cond': {'$lt': ['$$lead.followup_date', now]}
+                        }
+                    }
+                }
+            },
+            {
+                '$addFields': {
+                    'email': {'$first': '$leads.user_email'},
+                    'notification_settings': {'$first': '$leads.notification_settings'}}
+            },
+            {'$match': {'actual_follow_ups': {'$ne': []}}},
+            {'$unset': ['leads']}
+        ]
+        return [UserFollowUps.from_dic(doc) for doc in list(self.collection().aggregate(pipeline))]
+
     def update_source(self, source_id: str, source_data: dict):
         self.collection().update_many({'message.source.source_id': source_id},
                                       {'$set': {'message.source': source_data}})
@@ -222,22 +333,22 @@ class UserLeadMongoRepository(BaseMongoRepository):
         archived = kwargs.get('archived')
         from_date = kwargs.get('from_date')
         to_date = kwargs.get('to_date')
-        has_followup = kwargs.get('has_followup', None)
-        followup_to = kwargs.get('followup_to_date', None)
-        followup_from = kwargs.get('followup_from_date', None)
-        created_to = kwargs.get('created_to_date', None)
-        created_from = kwargs.get('created_from_date', None)
-        sender_ids = kwargs.get('sender_ids', None)
-        text = kwargs.get('text', None)
-        stop_words = kwargs.get('stop_words', None)
-        tags = kwargs.get('tags', None)
-        configs = kwargs.get('config', None)
-        bots_names = kwargs.get('bots_names', None)
-        locations = kwargs.get('locations', None)
-        with_chat = kwargs.get('with_chat', None)
-        leads_ids = kwargs.get('leads_ids', None)
-        exclude_leads = kwargs.get('exclude_leads', None)
-        exclude_senders = kwargs.get('exclude_senders', None)
+        has_followup = kwargs.get('has_followup')
+        followup_to = kwargs.get('followup_to_date')
+        followup_from = kwargs.get('followup_from_date')
+        created_to = kwargs.get('created_to_date')
+        created_from = kwargs.get('created_from_date')
+        sender_ids = kwargs.get('sender_ids')
+        text = kwargs.get('text')
+        stop_words = kwargs.get('stop_words')
+        tags = kwargs.get('tags')
+        configs = kwargs.get('config')
+        bots_names = kwargs.get('bots_names')
+        locations = kwargs.get('locations')
+        with_chat = kwargs.get('with_chat')
+        leads_ids = kwargs.get('leads_ids')
+        exclude_leads = kwargs.get('exclude_leads')
+        exclude_senders = kwargs.get('exclude_senders')
         deleted = kwargs.get('deleted', False)
 
         pipeline['message.profile.display_name'] = {
@@ -549,18 +660,17 @@ class LeadMongoRepository(BaseMongoRepository):
         from_date: datetime = kwargs.get('from_date')
         to_date: datetime = kwargs.get('to_date')
 
-        country = kwargs.get('country', None)
-        user_id = kwargs.get('user_id', None)
-        tags = kwargs.get('tags', None)
-        text = kwargs.get('text', None)
-        stop_words = kwargs.get('stop_words', None)
-        exclude_leads = kwargs.get('exclude_leads', None)
-        exclude_senders = kwargs.get('exclude_senders', None)
-        excluded_channels = kwargs.get('excluded_channels', None)
-        sender_ids = kwargs.get('sender_ids', None)
-        configs = kwargs.get('config', None)
-        bots_names = kwargs.get('bots_names', None)
-        locations = kwargs.get('locations', None)
+        country = kwargs.get('country')
+        user_id = kwargs.get('user_id')
+        tags = kwargs.get('tags')
+        text = kwargs.get('text')
+        stop_words = kwargs.get('stop_words')
+        exclude_leads = kwargs.get('exclude_leads')
+        exclude_senders = kwargs.get('exclude_senders')
+        sender_ids = kwargs.get('sender_ids')
+        configs = kwargs.get('config')
+        bots_names = kwargs.get('bots_names')
+        locations = kwargs.get('locations')
         publication_text = kwargs.get('publication_text')
 
         pipeline['message.profile.display_name'] = {
@@ -610,13 +720,6 @@ class LeadMongoRepository(BaseMongoRepository):
         if exclude_senders:
             pipeline['message.sender_id'] = {'$nin': exclude_senders}
 
-        if excluded_channels:
-            pipeline['$and'] = []
-            for ws, channels in excluded_channels.items():
-                if channels is not None:
-                    pipeline['$and'].append(
-                        {'$or': [{'message.name': {'$ne': ws}}, {'message.channel_id': {'$nin': channels}}]})
-
         if sender_ids:
             pipeline['message.sender_id'] = {'$in': sender_ids}
 
@@ -848,6 +951,9 @@ class DedicatedBotRepository(BaseMongoRepository):
         kwargs["only_valid"] = only_valid
         pipeline = self.__create_bots_filter(**kwargs)
         docs = self.collection().find(pipeline)
+        sort_by = kwargs.get('sort_by')
+        if sort_by:
+            docs = docs.sort({sort_by: 1})
         return [DedicatedBotModel.from_dic(doc) for doc in docs]
 
     def get_source_ids_for_user(self, **kwargs):
@@ -864,7 +970,7 @@ class DedicatedBotRepository(BaseMongoRepository):
 
     @staticmethod
     def __create_bots_filter(**kwargs):
-        pipeline = {}
+        pipeline: dict = {}
         name = kwargs.get('name')
         source_type = kwargs.get('source_type', None)
         user_name = kwargs.get('user_name')
@@ -876,6 +982,8 @@ class DedicatedBotRepository(BaseMongoRepository):
         source_id = kwargs.get('source_id')
         server_id = kwargs.get('server_id')
         active_server_id = kwargs.get('active_server_id')
+        invalid_creds = kwargs.get('invalid_creds')
+        sort_by = kwargs.get('sort_by')
 
         if bot_id:
             pipeline["_id"] = to_object_id(bot_id)
@@ -904,12 +1012,18 @@ class DedicatedBotRepository(BaseMongoRepository):
         if only_valid:
             pipeline['invalid_creds'] = False
 
+        if invalid_creds is not None:
+            pipeline['invalid_creds'] = invalid_creds
+
         if not include_deleted:
             pipeline['deleted'] = False
 
         if not include_paused and source_type == SourceType.DISCORD:
             pipeline['paused'] = False
 
+        if sort_by:
+            pipeline['sort_by'] = {'$exists': True}
+
         return pipeline
 
 
@@ -1144,15 +1258,59 @@ class ChatRepository(BaseMongoRepository):
 
         if from_date:
             start = datetime(from_date.year, from_date.month, from_date.day, tzinfo=tz.tzutc())
-            pipeline['last_action_at']['$gte'] = start
+            pipeline['created_at']['$gte'] = start
 
         if to_date:
             end = datetime(to_date.year, to_date.month, to_date.day, 23, 59, 59, tzinfo=tz.tzutc())
-            pipeline['last_action_at']['$lte'] = end
+            pipeline['created_at']['$lte'] = end
 
         return [ChatMessage.from_dic(msg)
                 for msg in self.collection().find(pipeline).sort("id", pymongo.ASCENDING)]
 
+    def get_aggregated_list(self, **kwargs):
+        match_pipeline = {}
+        user_id = kwargs.get('user_id')
+        from_date = kwargs.get('from_date')
+        to_date = kwargs.get('to_date')
+        sort_by = kwargs.get('sort_by', 'id')
+        viewed = kwargs.get('viewed')
+
+        if user_id:
+            match_pipeline['user_id'] = to_object_id(user_id)
+
+        if from_date or to_date:
+            match_pipeline['created_at'] = {}
+
+        if viewed is not None:
+            match_pipeline['viewed'] = viewed
+
+        if from_date:
+            start = datetime(from_date.year, from_date.month, from_date.day, tzinfo=tz.tzutc())
+            match_pipeline['created_at']['$gte'] = start
+
+        if to_date:
+            end = datetime(to_date.year, to_date.month, to_date.day, 23, 59, 59, tzinfo=tz.tzutc())
+            match_pipeline['created_at']['$lte'] = end
+
+        pipeline = [
+            {'$match': match_pipeline},
+            {
+                '$lookup': {
+                    'from': 'slack_contact',
+                    'localField': 'sender_id',
+                    'foreignField': 'sender_id',
+                    'as': 'user'
+                }
+            },
+            {
+                '$addFields': {'user': {'$first': '$user'}}
+            },
+            {
+                '$sort': {sort_by: 1}
+            }]
+
+        return self.collection().aggregate(pipeline)
+
     def get_grouped_messages(self, **kwargs):
         match_pipeline = {}
         pipeline = [
@@ -1202,6 +1360,28 @@ class MessageRequestsRepository(BaseMongoRepository):
         self.collection().update_one({'user_id': to_object_id(user_id), 'sender_id': sender_id},
                                      {'$set': message_request.to_dic()}, upsert=True)
 
+    def get_many(self, user_id: str, viewed: bool = False):
+        pipeline = [
+            {
+                '$match': {'user_id': to_object_id(user_id), 'viewed': viewed}
+            },
+            {
+                '$lookup': {
+                    'from': 'slack_contact',
+                    'localField': 'sender_id',
+                    'foreignField': 'sender_id',
+                    'as': 'user'
+                }
+            },
+            {
+                '$addFields': {'user': {'$first': '$user'}}
+            },
+            {
+                '$sort': {'created_at': 1}
+            }
+        ]
+        return self.collection().aggregate(pipeline)
+
     def find(self, user_id: str, sender_id: str):
         return self.collection().find_one({'user_id': to_object_id(user_id), 'sender_id': sender_id})
 

lgt_jobs/lgt_data/repositories/post/posts.py

@@ -0,0 +1,28 @@
+from bson import ObjectId
+
+from lgt_jobs.lgt_data.models.post.post import Post
+from lgt_jobs.lgt_data.mongo_repository import BaseMongoRepository
+
+
+class PostsRepository(BaseMongoRepository):
+    collection_name = 'posts'
+
+    def get_users_posts(self, ids: list[str]) -> dict[ObjectId, list[Post]]:
+        pipeline = [
+            {
+                '$lookup': {
+                    'from': 'posted_messages',
+                    'as': 'messages',
+                    'let': {'id': '$_id'},
+                    'pipeline': [
+                        {'$match': {'$expr': {'$and': [{'$in': ['$id', ids]}, {'$eq': ['$$id', '$post_id']}]}}}
+                    ]}},
+            {
+                '$match': {'messages': {'$ne': []}}
+            },
+            {
+                '$group': {'_id': '$user_id', 'posts': {'$push': '$$ROOT'}}
+            }]
+        docs = self.collection().aggregate(pipeline)
+        posts_map = {doc['_id']: [Post.from_dic(post) for post in doc['posts']] for doc in docs}
+        return posts_map

lgt_jobs/runner.py

@@ -2,8 +2,8 @@ import json
 from datetime import datetime, UTC
 from lgt_jobs.lgt_common.pubsub.messages import publish_message2_pubsub
 from lgt_jobs.lgt_data.engine import DelayedJob
-from .basejobs import InvalidJobTypeException, BaseBackgroundJobData, BaseBackgroundJob
-from .env import background_jobs_topic
+from lgt_jobs.basejobs import InvalidJobTypeException, BaseBackgroundJobData, BaseBackgroundJob
+from lgt_jobs.env import background_jobs_topic
 
 
 def datetime_converter(o):

lgt_jobs/simple_job.py

@@ -1,7 +1,7 @@
 from abc import ABC
 from typing import Optional
 from pydantic import BaseModel
-from .basejobs import BaseBackgroundJobData, BaseBackgroundJob
+from lgt_jobs.basejobs import BaseBackgroundJobData, BaseBackgroundJob
 
 
 class SimpleTestJobData(BaseBackgroundJobData, BaseModel):