leadguru-jobs 0.639.0__py3-none-any.whl → 0.641.0__py3-none-any.whl

lgt_jobs/lgt_data/models/external/user_workspace.py

@@ -0,0 +1,32 @@
+class UserWorkspace:
+    pass
+
+    def __init__(self):
+        super().__init__()
+        self.id = ''
+        self.name = ''
+        self.url = ''
+        self.domain = ''
+        self.active_users = ''
+        self.profile_photos = []
+        self.associated_user = ''
+        self.magic_login_url = ''
+        self.magic_login_code = ''
+        self.user_email = ''
+        self.user_type = ''
+        self.variant = ''
+        self.token = ''
+        self.icon = ''
+        self.two_factor_required = False
+
+    @classmethod
+    def from_dic(cls, dic: dict):
+        if not dic:
+            return None
+
+        model: UserWorkspace = cls()
+        for k, v in dic.items():
+            setattr(model, k, v)
+
+        model.icon = dic.get('icon_88', "")
+        return model

lgt_jobs/lgt_data/models/leads/config.py

@@ -0,0 +1,13 @@
+from lgt_jobs.lgt_data.models.base import DictionaryModel
+
+
+class BaseConfig(DictionaryModel):
+    def __init__(self):
+        self.owner = None
+        self.id = None
+
+
+class Config(BaseConfig):
+    def __init__(self):
+        super().__init__()
+        self.name = None

lgt_jobs/lgt_data/models/leads/extended_lead.py

@@ -0,0 +1,46 @@
+from typing import List
+
+from lgt_jobs.lgt_data.models.bots.bot_info import BotInfo
+from lgt_jobs.lgt_data.models.chat.message import ChatMessage
+from lgt_jobs.lgt_data.models.contacts.contact import UserContact
+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 ExtendedLeadModel(LeadModel):
+    def __init__(self):
+        super().__init__()
+        self.previous_publications = []
+        self.last_conversation: List[ChatMessage] = []
+        self.contact: SlackMemberInformation | None = None
+        self.deleted = False
+        self.user_lead: UserLeadModel | None = None
+        self.dedicated: bool = False
+        self.bots: List[BotInfo] = []
+        self.user_contact: UserContact | None = None
+        self.paid: bool = False
+        self.hidden_by_user: bool = False
+
+    @classmethod
+    def from_dic(cls, dic: dict):
+        if not dic:
+            return None
+
+        result: ExtendedLeadModel | None = LeadModel.from_dic(dic)
+        if not result:
+            return None
+
+        result.contact = SlackMemberInformation.from_dic(dic.get('contact'))
+        result.user_contact = UserContact.from_dic(dic.get('user_contact'))
+        result.previous_publications = [LeadModel.from_dic(lead) for lead in dic.get('previous_publications', [])]
+        result.user_lead = UserLeadModel.from_dic(dic.get('user_lead'))
+        result.last_conversation = [ChatMessage.from_dic(message) for message in dic.get('last_conversation', [])]
+        result.bots = [BotInfo.from_dic(bot) for bot in dic.get('bots', [])]
+        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/leads/lead.py

@@ -0,0 +1,48 @@
+import copy
+from datetime import datetime
+from typing import Optional
+
+from lgt_jobs.lgt_data.models.base import BaseModel
+from lgt_jobs.lgt_data.models.leads.message import MessageModel
+
+
+class LeadModel(BaseModel):
+    def __init__(self):
+        super().__init__()
+        self.status = ''
+        self.notes = ''
+        self.archived = False
+        self.message: Optional[MessageModel] = None
+        self.hidden = False
+        self.followup_date = None
+        self.score = 0
+        self.board_id = None
+        self.linkedin_urls = []
+        self.likes = 0
+        self.reactions = 0
+        self.replies = []
+        self.last_action_at: Optional[datetime] = None
+        self.slack_channel = None
+
+    @classmethod
+    def from_dic(cls, dic: dict):
+        if not dic:
+            return None
+
+        model: LeadModel = cls()
+        for k, v in dic.items():
+            setattr(model, k, v)
+
+        if dic.get('message'):
+            model.message = MessageModel.from_dic(dic['message'])
+
+        if not model.last_action_at:
+            model.last_action_at = model.created_at
+
+        return model
+
+    def to_dic(self):
+        result = copy.deepcopy(self.__dict__)
+        result["message"] = self.message.to_dic()
+        result['archived'] = self.archived
+        return result

lgt_jobs/lgt_data/models/leads/message.py

@@ -0,0 +1,51 @@
+import copy
+import json
+from typing import List
+
+from lgt_jobs.lgt_data.models.bots.base_bot import Source
+from lgt_jobs.lgt_data.models.leads.config import BaseConfig
+
+
+class MessageModel:
+    pass
+
+    def __init__(self):
+        self.message_id = None
+        self.channel_id = None
+        self.channel_name = None
+        self.message = None
+        self.name = None
+        self.sender_id = None
+        self.source: Source | None = None
+        self.companies: List[str] = list()
+        self.technologies: List[str] = list()
+        self.locations: List[str] = list()
+        self.configs: List[BaseConfig] = list()
+        self.attachments: List[dict] = []
+        self.timestamp = None
+        self.tags: List[str] = []
+
+    @classmethod
+    def from_dic(cls, dic: dict):
+        if not dic:
+            return None
+        if isinstance(dic.get('attachments'), str):
+            dic['attachments'] = json.loads(dic['attachments'])
+
+        model: MessageModel = cls()
+        for k, v in dic.items():
+            setattr(model, k, v)
+
+        model.source = Source.from_dic(dic.get("source"))
+        model.configs = [BaseConfig.from_dic(doc) for doc in dic.get("configs", [])]
+        return model
+
+    def to_dic(self):
+        result = copy.deepcopy(self.__dict__)
+
+        if result.get('source'):
+            result['source'] = Source.to_dic(result.get('source'))
+        if result.get('configs'):
+            result['configs'] = [BaseConfig.to_dic(config) for config in result.get('configs')]
+        return result
+

lgt_jobs/lgt_data/models/notifications/notification.py

@@ -0,0 +1,248 @@
+from datetime import datetime, UTC, timedelta
+from lgt_jobs.env import portal_url
+from lgt_jobs.lgt_data.enums import NotificationType
+from lgt_jobs.lgt_data.models.base import DictionaryModel
+from lgt_jobs.lgt_data.models.bots.dedicated_bot import DedicatedBotModel
+from lgt_jobs.lgt_data.models.post.post import Post
+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
+
+
+class Notification(DictionaryModel):
+    def __init__(self):
+        self.enabled: bool = True
+        self.type: NotificationType = NotificationType.INSTANTLY
+        self.day: int | None = None
+        self.hour: int | None = None
+        self.minute: int | None = None
+        self.last_notification: datetime | None = None
+        self.need_to_notify: bool = False
+        self.attributes: list = []
+
+    @property
+    def need_to_notify_now(self) -> bool:
+        if not self.enabled or not self.need_to_notify:
+            return False
+
+        now = datetime.now(UTC)
+        current_week_day = datetime.isoweekday(now)
+        if self.last_notification:
+            self.last_notification = self.last_notification.replace(tzinfo=UTC)
+
+        if (self.type == NotificationType.UNREAD_FOR_FEW_MINUTES
+                and self.last_notification and (now.minute - self.minute <= self.last_notification.minute)):
+            return False
+
+        if self.type == NotificationType.ONCE_A_WEEK and current_week_day != self.day:
+            return False
+
+        if ((self.type == NotificationType.ONCE_A_DAY or self.type == NotificationType.ONCE_A_WEEK)
+                and now.hour != self.hour and now.minute < self.minute):
+            return False
+
+        if ((self.type == NotificationType.ONCE_A_DAY or self.type == NotificationType.ONCE_A_WEEK)
+                and self.last_notification and self.last_notification > now - timedelta(hours=1)):
+            return False
+
+        return True
+
+    @staticmethod
+    def need_to_notify_week_before(date: datetime) -> bool:
+        return datetime.now(UTC) < (date + timedelta(7))
+
+
+class IncomingMessageNotification(Notification):
+    @staticmethod
+    def get_button_name() -> str:
+        return 'View message'
+
+    @staticmethod
+    def get_button_url(sender_id: str, source_id: str) -> str:
+        return f'{portal_url}/feed?senderId={sender_id}&sourceId={source_id}'
+
+    def get_subject_text(self, users: list) -> str:
+        if self.type == NotificationType.INSTANTLY or self.type == NotificationType.UNREAD_FOR_FEW_MINUTES:
+            return 'New message from your lead'
+        elif len(users) > 1:
+            return 'Unread messages from your lead'
+        return 'Unread message from your lead'
+
+    def get_notification_text(self, users: list):
+        if self.type == NotificationType.INSTANTLY:
+            return f'{users[-1]} has just sent you a message.'
+        elif self.type == NotificationType.UNREAD_FOR_FEW_MINUTES:
+            return f'{users[-1]} sent you a message {self.minute} minutes ago.'
+        elif (self.type == NotificationType.ONCE_A_DAY or self.type == NotificationType.ONCE_A_WEEK) and users:
+            match len(users):
+                case 1:
+                    return f'You have unread message(s) from {users[0]}.'
+                case 2 | 3:
+                    return f'You have unread messages from {", ".join(users)}.'
+                case _:
+                    return f'You have unread messages from {", ".join(users[:3])} and other leads.'
+
+
+class InboxNotification(Notification):
+
+    @staticmethod
+    def get_button_name():
+        return 'View message request'
+
+    @staticmethod
+    def get_button_url():
+        return f'{portal_url}/feed?requests=true'
+
+    def get_subject_text(self, users: list) -> str:
+        if self.type == NotificationType.INSTANTLY:
+            return 'New message request on Leadguru'
+        elif len(users) > 1:
+            return 'Message requests on Leadguru'
+        return 'Message request on Leadguru'
+
+    def get_notification_text(self, users: list):
+        if self.type == NotificationType.INSTANTLY:
+            return f'{users[0]} has just sent you message request.'
+        elif (self.type == NotificationType.ONCE_A_DAY or self.type == NotificationType.ONCE_A_WEEK) and users:
+            match len(users):
+                case 1:
+                    return f'You have unread message request from {users[0]}.'
+                case 2 | 3:
+                    return f'You have unread message request from {", ".join(users)}.'
+                case _:
+                    return f'You have unread message requests from {", ".join(users[:3])} and other leads.'
+
+
+class SourceDeactivationNotification(Notification):
+    @staticmethod
+    def get_button_name() -> str:
+        return 'Show community'
+
+    @staticmethod
+    def get_button_url() -> str:
+        return f'{portal_url}/communities?inactive=true'
+
+    @staticmethod
+    def get_subject_text() -> str:
+        return 'Inactivation of Community on Leadguru'
+
+    def get_notification_text(self, bots: list[DedicatedBotModel]):
+        names = [bot.source.source_name.capitalize() for bot in bots]
+        if self.type == NotificationType.INSTANTLY:
+            return f'{bots[-1].source.source_name.capitalize()} became inactive on Leadguru.'
+        elif (self.type == NotificationType.ONCE_A_DAY or self.type == NotificationType.ONCE_A_WEEK) and bots:
+            match len(bots):
+                case 1:
+                    return f'{names[-1]} became inactive on Leadguru.'
+                case 2 | 3:
+                    return f'{", ".join(names)} became inactive on Leadguru.'
+                case _:
+                    return f'{", ".join(names)} and other became inactive on Leadguru.'
+
+
+class BulkRepliesNotification(Notification):
+
+    @staticmethod
+    def get_button_name() -> str:
+        return 'View post'
+
+    @staticmethod
+    def get_button_url(post: Post) -> str:
+        return f'{portal_url}/bulk-post/form/{post.id}'
+
+    def get_subject_text(self, post: Post) -> str:
+        replied_messages = [message.id for message in post.messages if message.id in self.attributes]
+        if len(replied_messages) > 1:
+            return 'New replies to your bulk post'
+        return 'New reply to your bulk post'
+
+    @staticmethod
+    def get_notification_text(post: Post):
+        if len(post.messages) <= 1:
+            source_name = post.messages[0].server_name
+            channel_name = post.messages[0].channel_name
+            return f'You have new reply in #{channel_name} from {source_name.capitalize()} to your {post.title} post.'
+
+        channels = set([message.channel_id for message in post.messages])
+        sources = set([message.server_id for message in post.messages])
+        return (f'You have new replies in {len(channels)} from {len(sources)} communities '
+                f'to your {post.title} post.')
+
+
+class BulkReactionsNotification(Notification):
+
+    @staticmethod
+    def get_button_name() -> str:
+        return 'View post'
+
+    @staticmethod
+    def get_button_url(post: Post) -> str:
+        return f'{portal_url}/bulk-post/form/{post.id}'
+
+    @staticmethod
+    def get_subject_text() -> str:
+        return 'People are reacting to your post'
+
+    @staticmethod
+    def get_notification_text(post: Post):
+        if len(post.messages) <= 1:
+            source_name = post.messages[0].server_name
+            channel_name = post.messages[0].channel_name
+            return (f'You have new reaction in #{channel_name} from {source_name.capitalize()} '
+                    f'to your {post.title} post.')
+
+        channels = set([message.channel_id for message in post.messages])
+        sources = set([message.server_id for message in post.messages])
+        return (f'You have new reactions in {len(channels)} from {len(sources)} communities '
+                f'to your {post.title} post.')
+
+
+class FollowUpNotification(Notification):
+
+    @staticmethod
+    def get_button_name(actual: list[UserLeadModel]) -> str:
+        if len(actual) > 1:
+            return 'View calendar'
+        return 'Send message'
+
+    def get_button_url(self, actual: list[UserLeadModel]) -> str:
+        if len(actual) > 1:
+            if self.type == NotificationType.ONCE_A_DAY:
+                return f'{portal_url}/dashboard/calendar?view=day'
+            return f'{portal_url}/dashboard/calendar?view=week'
+        return f'{portal_url}/feed?senderId={actual[0].message.sender_id}&sourceId={actual[0].message.source.source_id}'
+
+    def get_subject_text(self, actual: list[UserLeadModel]) -> str:
+        subject_text = 'You have planned follow-ups' if len(actual) > 1 else 'You have planned follow-up'
+
+        if self.type == NotificationType.ONCE_A_DAY:
+            return f'{subject_text} for today'
+        elif self.type == NotificationType.ONCE_A_WEEK:
+            return f'{subject_text} for this week'
+
+    def get_notification_text(self, actual: list[ExtendedUserLeadModel], overdue: list[ExtendedUserLeadModel]) -> str:
+        notification_text = ''
+        names = [lead.contact.real_name for lead in actual]
+        if self.type == NotificationType.ONCE_A_DAY:
+            match len(actual):
+                case 1:
+                    notification_text = f'You have planned to send follow-up today to {names[0]}.'
+                case 2 | 3:
+                    notification_text = f'You have planned to send follow-up today to {", ".join(names)}.'
+                case _:
+                    notification_text = (f'You have planned to send follow-up today to {", ".join(names[:3])} '
+                                         f'and {len(names) - 3} other leads.')
+        elif self.type == NotificationType.ONCE_A_WEEK:
+            match len(actual):
+                case 1:
+                    notification_text = f'You have planned to send follow-up to {names[0]} this week.'
+                case 2 | 3:
+                    notification_text = f'You have planned to send follow-up to {", ".join(names)} this week.'
+                case _:
+                    notification_text = (f'You have planned to send follow-up to {", ".join(names[:3])} '
+                                         f'and {len(names) - 3} other leads this week.')
+
+        return f'{notification_text} Plus you have {len(overdue)} overdue follow-ups.' if overdue else notification_text
+
+
+class BillingNotifications(Notification):
+    pass

lgt_jobs/lgt_data/models/notifications/notification_settings.py

@@ -0,0 +1,52 @@
+import copy
+from lgt_jobs.lgt_data.models.base import DictionaryModel
+from lgt_jobs.lgt_data.models.notifications.notification import (Notification, IncomingMessageNotification,
+                                                                 InboxNotification, SourceDeactivationNotification,
+                                                                 BillingNotifications, BulkRepliesNotification,
+                                                                 BulkReactionsNotification, FollowUpNotification)
+
+
+class NotificationSettings(DictionaryModel):
+    def __init__(self):
+        self.incoming_messages: IncomingMessageNotification | None = None
+        self.inbox: InboxNotification | None = None
+        self.source_deactivation: SourceDeactivationNotification | None = None
+        self.billing: BillingNotifications | None = None
+        self.bulk_replies: BulkRepliesNotification | None = None
+        self.bulk_reactions: BulkReactionsNotification | None = None
+        self.follow_ups: FollowUpNotification | None = None
+
+    @classmethod
+    def from_dic(cls, dic: dict):
+        if not dic:
+            return None
+
+        model: NotificationSettings = cls()
+        model.incoming_messages = IncomingMessageNotification.from_dic(dic.get('incoming_messages'))
+        model.inbox = InboxNotification.from_dic(dic.get('inbox'))
+        model.source_deactivation = SourceDeactivationNotification.from_dic(dic.get('source_deactivation'))
+        model.billing = BillingNotifications.from_dic(dic.get('billing'))
+        model.bulk_replies = BulkRepliesNotification.from_dic(dic.get('bulk_replies'))
+        model.bulk_reactions = BulkReactionsNotification.from_dic(dic.get('bulk_reactions'))
+        model.follow_ups = FollowUpNotification.from_dic(dic.get('follow_ups'))
+        return model
+
+    def to_dic(self):
+        result = copy.deepcopy(self.__dict__)
+
+        if result.get('incoming_messages'):
+            result['incoming_messages'] = Notification.to_dic(result.get('incoming_messages'))
+        if result.get('inbox'):
+            result['inbox'] = Notification.to_dic(result.get('inbox'))
+        if result.get('source_deactivation'):
+            result['source_deactivation'] = Notification.to_dic(result.get('source_deactivation'))
+        if result.get('billing'):
+            result['billing'] = Notification.to_dic(result.get('billing'))
+        if result.get('bulk_replies'):
+            result['bulk_replies'] = Notification.to_dic(result.get('bulk_replies'))
+        if result.get('bulk_reactions'):
+            result['bulk_reactions'] = Notification.to_dic(result.get('bulk_reactions'))
+        if result.get('follow_ups'):
+            result['follow_ups'] = Notification.to_dic(result.get('follow_ups'))
+
+        return result

lgt_jobs/lgt_data/models/people/people.py

@@ -0,0 +1,75 @@
+import copy
+from datetime import datetime
+from typing import Optional
+
+from lgt_jobs.lgt_data.models.base import BaseModel
+from lgt_jobs.lgt_data.models.bots.base_bot import Source
+from lgt_jobs.lgt_data.models.external.slack.timezone import SlackTimeZone
+from lgt_jobs.lgt_data.models.people.profile import Profile
+
+
+class SlackMemberInformation(BaseModel, Profile):
+    workspace: str
+    sender_id: str
+    images: dict
+    full_text: str
+    deleted: bool = False
+    is_bot: bool = False
+    is_app_user: bool = False
+    is_admin: bool = False
+    is_owner: bool = False
+    is_email_confirmed: bool = False
+    online: Optional[str] = None
+    online_updated_at: datetime = None
+    timezone: SlackTimeZone = None
+    source: Source = None
+
+    @classmethod
+    def from_dic(cls, dic: dict):
+        model: SlackMemberInformation = cls()
+        if not dic:
+            return None
+
+        for k, v in dic.items():
+            setattr(model, k, v)
+
+        model.online = dic.get('online', '') == "active"
+        model: SlackMemberInformation | None = super().from_dic(dic)
+        model.source = Source.from_dic(dic.get('source'))
+        return model
+
+    def to_dic(self):
+        result = copy.deepcopy(self.__dict__)
+        if result.get('source'):
+            result['source'] = Source.to_dic(result.get('source'))
+        return result
+
+    @staticmethod
+    def from_slack_response(slack_profile: dict, source: Source = None):
+        member_info: SlackMemberInformation = SlackMemberInformation()
+        member_info.source = source
+        member_info.sender_id = slack_profile.get("id")
+        member_info.display_name = slack_profile["profile"].get("display_name")
+        member_info.real_name = slack_profile["profile"].get("real_name")
+        member_info.title = slack_profile["profile"].get("title")
+        member_info.phone = slack_profile["profile"].get("phone")
+        member_info.skype = slack_profile["profile"].get("skype")
+        member_info.email = slack_profile["profile"].get("email")
+        member_info.images = {
+            'image_24': slack_profile.get("profile", {}).get("image_24",
+                                                             'https://a.slack-edge.com/80588/img/slackbot_24.png'),
+            'image_32': slack_profile.get("profile", {}).get("image_32",
+                                                             'https://a.slack-edge.com/80588/img/slackbot_32.png'),
+            'image_48': slack_profile.get("profile", {}).get("image_48",
+                                                             'https://a.slack-edge.com/80588/img/slackbot_48.png'),
+            'image_72': slack_profile.get("profile", {}).get("image_72",
+                                                             'https://a.slack-edge.com/80588/img/slackbot_72.png'),
+            'image_192': slack_profile.get("profile", {}).get("image_192",
+                                                              'https://a.slack-edge.com/80588/img/slackbot_192.png'),
+            'image_512': slack_profile.get("profile", {}).get("image_512",
+                                                              'https://a.slack-edge.com/80588/img/slackbot_512.png'),
+
+        }
+        member_info.timezone = {"tz": slack_profile.get("tz"), "tz_label": slack_profile.get("tz_label"),
+                                "tz_offset": slack_profile.get("tz_offset")}
+        return member_info

lgt_jobs/lgt_data/models/people/profile.py

@@ -0,0 +1,13 @@
+from lgt_jobs.lgt_data.models.base import DictionaryModel
+
+
+class Profile(DictionaryModel):
+    def __init__(self):
+        self.title = ''
+        self.phone = ''
+        self.skype = ''
+        self.display_name = ''
+        self.real_name = ''
+        self.email = ''
+        self.photo_url = ''
+        self.main = False

lgt_jobs/lgt_data/models/post/message.py

@@ -0,0 +1,18 @@
+from lgt_jobs.lgt_data.models.base import DictionaryModel
+
+
+class PostMessage(DictionaryModel):
+    id: str
+    server_id: str
+    server_name: str
+    channel_id: str
+    channel_name: str
+
+    @classmethod
+    def from_dic(cls, dic: dict):
+        if not dic:
+            return None
+        model = cls()
+        for k, v in dic.items():
+            setattr(model, k, v)
+        return model

lgt_jobs/lgt_data/models/post/post.py

@@ -0,0 +1,15 @@
+from lgt_jobs.lgt_data.models.base import BaseModel
+from lgt_jobs.lgt_data.models.post.message import PostMessage
+
+
+class Post(BaseModel):
+    messages: list[PostMessage]
+    title: str
+
+    @classmethod
+    def from_dic(cls, dic: dict):
+        if not dic:
+            return None
+        model: Post | None = super().from_dic(dic)
+        model.messages = [PostMessage.from_dic(message) for message in dic.get('messages', [])]
+        return model

lgt_jobs/lgt_data/models/templates/template.py

@@ -0,0 +1,12 @@
+from typing import Optional
+
+from bson import ObjectId
+
+from lgt_jobs.lgt_data.models.base import BaseModel
+
+
+class UserTemplateModel(BaseModel):
+    text: str
+    subject: Optional[str]
+    user_id: Optional[ObjectId]
+    

lgt_jobs/lgt_data/models/user/feature.py

@@ -0,0 +1,10 @@
+from lgt_jobs.lgt_data.enums import FeaturesEnum, FeatureOptions
+from lgt_jobs.lgt_data.models.base import DictionaryModel
+
+
+class Feature(DictionaryModel):
+    display_name: str
+    name: FeaturesEnum
+    description: str | None = None
+    limit: int | None = None
+    options: FeatureOptions | None = None

lgt_jobs/lgt_data/models/user/general_settings.py

@@ -0,0 +1,9 @@
+from lgt_jobs.lgt_data.models.base import DictionaryModel
+
+
+class GeneralSettings(DictionaryModel):
+    def __init__(self):
+        self.theme: str | None = None
+        self.ask_pipeline_and_status: bool = False
+        self.ask_follow_up: bool = False
+        self.dashboard_is_starting_page: bool = False