leadguru-jobs 0.614.0__tar.gz → 0.616.0__tar.gz

{leadguru_jobs-0.614.0 → leadguru_jobs-0.616.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: leadguru_jobs
-Version: 0.614.0
+Version: 0.616.0
 Summary: LGT jobs builds
 Author-email: developer@leadguru.co
 Classifier: Development Status :: 5 - Production/Stable

{leadguru_jobs-0.614.0 → leadguru_jobs-0.616.0}/leadguru_jobs.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: leadguru_jobs
-Version: 0.614.0
+Version: 0.616.0
 Summary: LGT jobs builds
 Author-email: developer@leadguru.co
 Classifier: Development Status :: 5 - Production/Stable

{leadguru_jobs-0.614.0 → leadguru_jobs-0.616.0}/lgt_jobs/jobs/chat_history.py

@@ -3,15 +3,12 @@ from abc import ABC
 from typing import Optional, List
 import logging as log
 from lgt_jobs.lgt_common.slack_client.web_client import SlackWebClient, SlackMessageConvertService
-from lgt_jobs.lgt_data.helpers import get_help_text
-from lgt_jobs.lgt_data.model import ChatMessage, UserModel, UserContact, DedicatedBotModel
+from lgt_jobs.lgt_data.model import ChatMessage, UserContact, DedicatedBotModel
 from lgt_jobs.lgt_data.mongo_repository import UserMongoRepository, DedicatedBotRepository, UserContactsRepository, \
     ChatRepository
 from pydantic import BaseModel
-from lgt_jobs.lgt_data.enums import SourceType, ImageName
-from lgt_jobs.runner import BaseBackgroundJob, BaseBackgroundJobData, BackgroundJobRunner
-from lgt_jobs.env import portal_url
-from lgt_jobs.smtp import SendMailJobData, SendMailJob
+from lgt_jobs.lgt_data.enums import SourceType
+from lgt_jobs.runner import BaseBackgroundJob, BaseBackgroundJobData
 
 """
 Load slack chat history
@@ -50,7 +47,7 @@ class LoadChatHistoryJob(BaseBackgroundJob, ABC):
 
             log.info(f"[LoadChatHistoryJob]: processing {len(contacts)} contacts for user: {user.email}")
             for contact in contacts:
-                message = self._update_history(user=user, contact=contact, bot=bot)
+                message = self._update_history(contact=contact, bot=bot)
 
                 if not message:
                     continue
@@ -65,13 +62,13 @@ class LoadChatHistoryJob(BaseBackgroundJob, ABC):
                     last_message = message
                     last_message_contact = contact
 
-        has_to_be_notified = (not user.new_message_notified_at or
-                              (last_message and last_message.created_at > user.new_message_notified_at))
-
+        last_notification = user.notification_settings.incoming_messages.last_notification
+        has_to_be_notified = (not last_notification or (last_message and last_message.created_at > last_notification))
         if last_message and has_to_be_notified and last_message.user == last_message_contact.sender_id:
-            LoadChatHistoryJob._notify_about_new_messages(user, last_message_contact, last_message_bot,
-                                                          data.template_path)
-            UserMongoRepository().set(data.user_id, new_message_notified_at=datetime.now(UTC))
+            user.notification_settings.incoming_messages.need_to_notify = True
+            user.notification_settings.incoming_messages.attributes = [last_message_contact.sender_id,
+                                                                       last_message_bot.source.source_id]
+            UserMongoRepository().set(data.user_id, notification_settings=user.notification_settings.to_dic())
 
     def _get_new_messages(self, contact: UserContact, bot: DedicatedBotModel, slack_chat: List[ChatMessage]):
         messages = self.chat_repo.get_list(sender_id=contact.sender_id, bot_id=bot.id)
@@ -82,7 +79,7 @@ class LoadChatHistoryJob(BaseBackgroundJob, ABC):
                 new_messages.append(message)
         return new_messages
 
-    def _update_history(self, user: UserModel, contact: UserContact, bot: DedicatedBotModel) -> Optional[ChatMessage]:
+    def _update_history(self, contact: UserContact, bot: DedicatedBotModel) -> Optional[ChatMessage]:
         slack_client = SlackWebClient(bot.token, bot.cookies)
         try:
             chat_id = slack_client.im_open(contact.sender_id).get('channel', {}).get('id')
@@ -111,20 +108,3 @@ class LoadChatHistoryJob(BaseBackgroundJob, ABC):
             return new_messages[-1]
 
         return None
-
-    @staticmethod
-    def _notify_about_new_messages(user: UserModel, contact: UserContact, bot: DedicatedBotModel, template_path: str):
-        with open(template_path, mode='r') as template_file:
-            html = template_file.read()
-            chat_url = f'{portal_url}/feed?senderId={contact.sender_id}&sourceId={bot.source.source_id}'
-            html = html.replace("$$USER_NAME$$", contact.name if hasattr(contact, 'name') else contact.real_name)
-            html = html.replace("$$PORTAL_LINK$$", chat_url)
-            html = html.replace("$$HELP_TEXT$$", get_help_text(user))
-            message_data = {
-                "html": html,
-                "subject": 'New message(s) on Leadguru',
-                "recipient": user.email,
-                "images": [ImageName.LOGO, ImageName.ARROW, ImageName.MAIL]
-            }
-
-        BackgroundJobRunner.submit(SendMailJob, SendMailJobData(**message_data))

{leadguru_jobs-0.614.0 → leadguru_jobs-0.616.0}/lgt_jobs/lgt_data/enums.py

@@ -54,12 +54,6 @@ class DefaultBoards(str, Enum):
     Primary = 'Primary board'
 
 
-class BotEventType(str, Enum):
-    CREATE = 'BotAdded'
-    UPDATE = 'BotUpdated'
-    DELETE = 'BotDeleted'
-
-
 class ImageName(str, Enum):
     ARROW = 'arrow.png'
     CRY = 'cry.png'
@@ -96,3 +90,10 @@ class FeaturesEnum(str, Enum):
 class FeatureOptions(str, Enum):
     BASIC = 'basic'
     ADVANCED = 'advanced'
+
+
+class NotificationType(str, Enum):
+    INSTANTLY = 'instantly'
+    ONCE_A_DAY = 'once_a_day'
+    ONCE_A_WEEK = 'once_a_week'
+    WEEK_BEFORE = 'week_before'

{leadguru_jobs-0.614.0 → leadguru_jobs-0.616.0}/lgt_jobs/lgt_data/model.py

@@ -2,9 +2,9 @@ from __future__ import annotations
 import copy
 import json
 from abc import ABC
-from datetime import datetime, UTC
+from datetime import datetime, UTC, timedelta
 from typing import Optional, List
-from .enums import UserRole, SourceType, FeaturesEnum, FeatureOptions
+from lgt_jobs.lgt_data.enums import UserRole, SourceType, FeaturesEnum, FeatureOptions, NotificationType
 from bson import ObjectId
 
 
@@ -256,6 +256,96 @@ class MessageModel:
         return result
 
 
+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[str] = []
+
+    @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.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 NotificationSettings(DictionaryModel):
+    def __init__(self):
+        self.incoming_messages: Notification | None = None
+        self.inbox: Notification | None = None
+        self.source_deactivation: Notification | None = None
+        self.billing: Notification | None = None
+        self.bulk_replies: Notification | None = None
+        self.bulk_reactions: Notification | None = None
+        self.follow_ups: Notification | None = None
+
+    @classmethod
+    def from_dic(cls, dic: dict):
+        if not dic:
+            return None
+
+        model: NotificationSettings = cls()
+        model.incoming_messages = Notification.from_dic(dic.get('incoming_messages'))
+        model.inbox = Notification.from_dic(dic.get('inbox'))
+        model.source_deactivation = Notification.from_dic(dic.get('source_deactivation'))
+        model.billing = Notification.from_dic(dic.get('billing'))
+        model.bulk_replies = Notification.from_dic(dic.get('bulk_replies'))
+        model.bulk_reactions = Notification.from_dic(dic.get('bulk_reactions'))
+        model.follow_ups = Notification.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
+
+
+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
+
+
 class UserModel(BaseModel):
     def __init__(self):
         super().__init__()
@@ -271,13 +361,11 @@ class UserModel(BaseModel):
         self.company_web_site: str = ''
         self.company_description: str = ''
         self.position: str = ''
-        self.new_message_notified_at: Optional[datetime] = None
+        # self.new_message_notified_at: Optional[datetime] = None     # TODO: Move to settings
         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.keywords: Optional[List[str]] = None
-        self.block_words: Optional[List[str]] = None
         self.paid_lead_price: int = 1
         self.state: int = 0
         self.credits_exceeded_at: Optional[datetime] = None
@@ -292,6 +380,8 @@ class UserModel(BaseModel):
         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_setting: GeneralSettings | None = None
 
     @classmethod
     def from_dic(cls, dic: dict):
@@ -308,13 +398,16 @@ class UserModel(BaseModel):
         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'))
         return model
 
     def to_dic(self):
         result = copy.deepcopy(self.__dict__)
 
-        if result.get('slack_profile', None):
+        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'))
 
         return result
 

{leadguru_jobs-0.614.0 → leadguru_jobs-0.616.0}/lgt_jobs/lgt_data/mongo_repository.py

@@ -71,6 +71,7 @@ class UserMongoRepository(BaseMongoRepository):
         subscription_expired = kwargs.get('subscription_expired')
         connected_slack_email = kwargs.get('connected_slack_email')
         soon_subscription_expiration = kwargs.get('soon_subscription_expiration')
+        has_new_message = kwargs.get('has_new_message')
         min_days = kwargs.get('min_days_soon_subscription_expiration', 3)
 
         if subscription_expired:
@@ -81,6 +82,10 @@ class UserMongoRepository(BaseMongoRepository):
             pipeline['subscription_expired_at'] = {'$lte': datetime.now(UTC) + timedelta(min_days)}
             pipeline['subscription_expiration_warning_notified'] = False
 
+        if has_new_message:
+            pipeline['notification_settings.incoming_messages.enabled'] = True
+            pipeline['notification_settings.incoming_messages.need_to_notify'] = True
+            
         if connected_slack_email:
             pipeline['slack_users.email'] = connected_slack_email