def send_welcome_message(user: User): """ Sends welcome message to all new users at Sign up""" text_template = get_template("welcome_message_en.txt") text_template = text_template.replace("[USERNAME]", user.username) text_template = text_template.replace("[PROFILE_LINK]", get_profile_url(user.username)) welcome_message = Message() welcome_message.message_type = MessageType.SYSTEM.value welcome_message.to_user_id = user.id welcome_message.subject = "Welcome to the HOT Tasking Manager" welcome_message.message = text_template welcome_message.save() return welcome_message.id
def send_invite_to_join_team(from_user: int, from_username: str, to_user: int, team_name: str, team_id: int): message = Message() message.message_type = MessageType.INVITATION_NOTIFICATION.value message.from_user_id = from_user message.to_user_id = to_user message.subject = "Invitation to join {}".format( MessageService.get_team_link(team_name, team_id, False)) message.message = "{} has invited you to join the {} team.\ Access the {}'s page to accept or reject that invitation.".format( MessageService.get_user_link(from_username), MessageService.get_team_link(team_name, team_id, False), MessageService.get_team_link(team_name, team_id, False), ) message.add_message() message.save()
def send_favorite_project_activities(user_id: int): current_app.logger.debug("Sending Favorite Project Activities") favorited_projects = UserService.get_projects_favorited(user_id) contributed_projects = UserService.get_projects_mapped(user_id) if contributed_projects is None: contributed_projects = [] for favorited_project in favorited_projects.favorited_projects: contributed_projects.append(favorited_project.project_id) recently_updated_projects = (Project.query.with_entities( Project.id, func.DATE(Project.last_updated).label("last_updated")).filter( Project.id.in_(contributed_projects)).filter( func.DATE(Project.last_updated) > datetime.date.today() - datetime.timedelta(days=300))) user = UserService.get_user_dto_by_id(user_id) messages = [] for project in recently_updated_projects: activity_message = [] query_last_active_users = """ select distinct(user_id) from (select user_id from task_history where project_id = :project_id order by action_date desc limit 15 ) t """ last_active_users = db.engine.execute( text(query_last_active_users), project_id=project.id) for recent_user_id in last_active_users: recent_user_details = UserService.get_user_by_id( recent_user_id) user_profile_link = MessageService.get_user_profile_link( recent_user_details.username) activity_message.append(user_profile_link) activity_message = str(activity_message)[1:-1] project_link = MessageService.get_project_link(project.id) message = Message() message.message_type = MessageType.PROJECT_ACTIVITY_NOTIFICATION.value message.project_id = project.id message.to_user_id = user.id message.subject = ( "Recent activities from your contributed/favorited Projects") message.message = ( f"{activity_message} contributed to {project_link} recently") messages.append(dict(message=message, user=user)) MessageService._push_messages(messages)
def send_request_to_join_team(from_user: int, from_username: str, to_user: int, team_name: str, team_id: int): message = Message() message.message_type = MessageType.REQUEST_TEAM_NOTIFICATION.value message.from_user_id = from_user message.to_user_id = to_user message.subject = "{} requested to join {}".format( MessageService.get_user_link(from_username), MessageService.get_team_link(team_name, team_id, True), ) message.message = "{} has requested to join the {} team.\ Access the team management page to accept or reject that request.".format( MessageService.get_user_link(from_username), MessageService.get_team_link(team_name, team_id, True), ) message.add_message() message.save()
def accept_reject_invitation_request_for_team( from_user: int, from_username: str, to_user: int, sending_member: str, team_name: str, response: str, ) -> Message: message = Message() message.message_type = MessageType.INVITATION_NOTIFICATION.value message.from_user_id = from_user message.to_user_id = to_user message.subject = "Request to join team" message.message = f'<a href="http://127.0.0.1:5000/user/{from_username}">{from_username}\ </a> has {response}ed {sending_member}\'s invitation to join the {team_name} team' message.add_message() message.save()
def send_message_after_validation( status: int, validated_by: int, mapped_by: int, task_id: int, project_id: int ): """ Sends mapper a notification after their task has been marked valid or invalid """ if validated_by == mapped_by: return # No need to send a notification if you've verified your own task user = UserService.get_user_by_id(mapped_by) text_template = get_txt_template( "invalidation_message_en.txt" if status == TaskStatus.INVALIDATED else "validation_message_en.txt" ) status_text = ( "marked invalid" if status == TaskStatus.INVALIDATED else "validated" ) task_link = MessageService.get_task_link(project_id, task_id) replace_list = [ ["[USERNAME]", user.username], ["[TASK_LINK]", task_link], ["[ORG_NAME]", current_app.config["ORG_NAME"]], ] text_template = template_var_replacing(text_template, replace_list) messages = [] validation_message = Message() validation_message.message_type = ( MessageType.INVALIDATION_NOTIFICATION.value if status == TaskStatus.INVALIDATED else MessageType.VALIDATION_NOTIFICATION.value ) validation_message.project_id = project_id validation_message.task_id = task_id validation_message.from_user_id = validated_by validation_message.to_user_id = mapped_by validation_message.subject = ( f"{task_link} mapped by you in Project {project_id} has been {status_text}" ) validation_message.message = text_template messages.append(dict(message=validation_message, user=user)) # For email alerts MessageService._push_messages(messages)
def send_message_after_validation( status: int, validated_by: int, mapped_by: int, task_id: int, project_id: int ): """ Sends mapper a notification after their task has been marked valid or invalid """ if validated_by == mapped_by: return # No need to send a message to yourself user = UserService.get_user_by_id(mapped_by) if user.validation_message is False: return # No need to send validation message if user.projects_notifications is False: return text_template = get_template( "invalidation_message_en.txt" if status == TaskStatus.INVALIDATED else "validation_message_en.txt" ) status_text = ( "marked invalid" if status == TaskStatus.INVALIDATED else "validated" ) task_link = MessageService.get_task_link(project_id, task_id) text_template = text_template.replace("[USERNAME]", user.username) text_template = text_template.replace("[TASK_LINK]", task_link) validation_message = Message() validation_message.message_type = ( MessageType.INVALIDATION_NOTIFICATION.value if status == TaskStatus.INVALIDATED else MessageType.VALIDATION_NOTIFICATION.value ) validation_message.project_id = project_id validation_message.task_id = task_id validation_message.from_user_id = validated_by validation_message.to_user_id = mapped_by validation_message.subject = f"Your mapping in Project {project_id} on {task_link} has just been {status_text}" validation_message.message = text_template validation_message.add_message() SMTPService.send_email_alert( user.email_address, user.username, validation_message.id )
def send_welcome_message(user: User): """ Sends welcome message to all new users at Sign up""" org_code = current_app.config["ORG_CODE"] text_template = get_txt_template("welcome_message_en.txt") replace_list = [ ["[USERNAME]", user.username], ["[ORG_CODE]", org_code], ["[ORG_NAME]", current_app.config["ORG_NAME"]], ["[SETTINGS_LINK]", MessageService.get_user_settings_link()], ] text_template = template_var_replacing(text_template, replace_list) welcome_message = Message() welcome_message.message_type = MessageType.SYSTEM.value welcome_message.to_user_id = user.id welcome_message.subject = "Welcome to the {} Tasking Manager".format(org_code) welcome_message.message = text_template welcome_message.save() return welcome_message.id
def accept_reject_request_to_join_team( from_user: int, from_username: str, to_user: int, team_name: str, team_id: int, response: str, ): message = Message() message.message_type = MessageType.REQUEST_TEAM_NOTIFICATION.value message.from_user_id = from_user message.to_user_id = to_user message.subject = "Request to join {} was {}ed".format( MessageService.get_team_link(team_name, team_id, False), response) message.message = "{} has {}ed your request to join the {} team.".format( MessageService.get_user_link(from_username), response, MessageService.get_team_link(team_name, team_id, False), ) message.add_message() message.save()
def send_message_after_chat(chat_from: int, chat: str, project_id: int): """ Send alert to user if they were @'d in a chat message """ # Because message-all run on background thread it needs it's own app context app = create_app() with app.app_context(): usernames = MessageService._parse_message_for_username( chat, project_id) if len(usernames) != 0: link = MessageService.get_project_link( project_id, include_chat_section=True) messages = [] for username in usernames: current_app.logger.debug(f"Searching for {username}") try: user = UserService.get_user_by_username(username) except NotFound: current_app.logger.error( f"Username {username} not found") continue # If we can't find the user, keep going no need to fail message = Message() message.message_type = MessageType.MENTION_NOTIFICATION.value message.project_id = project_id message.from_user_id = chat_from message.to_user_id = user.id message.subject = f"You were mentioned in {link} chat" message.message = chat messages.append(dict(message=message, user=user)) MessageService._push_messages(messages) query = """ select user_id from project_favorites where project_id = :project_id""" favorited_users_results = db.engine.execute(text(query), project_id=project_id) favorited_users = [r[0] for r in favorited_users_results] # Notify all contributors except the user that created the comment. contributed_users_results = (TaskHistory.query.with_entities( TaskHistory.user_id.distinct() ).filter(TaskHistory.project_id == project_id).filter( TaskHistory.user_id != chat_from).filter( TaskHistory.action == TaskAction.STATE_CHANGE.name).all()) contributed_users = [r[0] for r in contributed_users_results] users_to_notify = list(set(contributed_users + favorited_users)) if len(users_to_notify) != 0: from_user = User.query.get(chat_from) from_user_link = MessageService.get_user_link( from_user.username) project_link = MessageService.get_project_link( project_id, include_chat_section=True) messages = [] for user_id in users_to_notify: try: user = UserService.get_user_dto_by_id(user_id) except NotFound: continue # If we can't find the user, keep going no need to fail message = Message() message.message_type = MessageType.PROJECT_CHAT_NOTIFICATION.value message.project_id = project_id message.from_user_id = chat_from message.to_user_id = user.id message.subject = ( f"{from_user_link} left a comment in {project_link}") message.message = chat messages.append(dict(message=message, user=user)) # it's important to keep that line inside the if to avoid duplicated emails MessageService._push_messages(messages)
def send_message_after_comment(comment_from: int, comment: str, task_id: int, project_id: int): """ Will send a canned message to anyone @'d in a comment """ usernames = MessageService._parse_message_for_username( comment, project_id) if len(usernames) != 0: task_link = MessageService.get_task_link(project_id, task_id) messages = [] for username in usernames: try: user = UserService.get_user_by_username(username) except NotFound: continue # If we can't find the user, keep going no need to fail message = Message() message.message_type = MessageType.MENTION_NOTIFICATION.value message.project_id = project_id message.task_id = task_id message.from_user_id = comment_from message.to_user_id = user.id message.subject = f"You were mentioned in a comment in {task_link} of Project {project_id}" message.message = comment messages.append(dict(message=message, user=user)) MessageService._push_messages(messages) # Notify all contributors except the user that created the comment. results = (TaskHistory.query.with_entities( TaskHistory.user_id.distinct() ).filter(TaskHistory.project_id == project_id).filter( TaskHistory.task_id == task_id).filter( TaskHistory.user_id != comment_from).filter( TaskHistory.action == TaskAction.STATE_CHANGE.name).all()) contributed_users = [r[0] for r in results] if len(contributed_users) != 0: user_from = User.query.get(comment_from) if user_from is None: raise ValueError("Username not found") user_link = MessageService.get_user_link(user_from.username) task_link = MessageService.get_task_link(project_id, task_id) messages = [] for user_id in contributed_users: try: user = UserService.get_user_dto_by_id(user_id) # if user was mentioned, a message has already been sent to them, # so we can skip if user.username in usernames: break except NotFound: continue # If we can't find the user, keep going no need to fail message = Message() message.message_type = MessageType.TASK_COMMENT_NOTIFICATION.value message.project_id = project_id message.from_user_id = comment_from message.task_id = task_id message.to_user_id = user.id message.subject = ( f"{user_link} left a comment in {task_link} of Project {project_id}" ) message.message = comment messages.append(dict(message=message, user=user)) MessageService._push_messages(messages)
def send_message_after_chat(chat_from: int, chat: str, project_id: int): """ Send alert to user if they were @'d in a chat message """ current_app.logger.debug("Sending Message After Chat") usernames = MessageService._parse_message_for_username(chat) if len(usernames) == 0: return # Nobody @'d so return link = MessageService.get_project_link(project_id) messages = [] for username in usernames: current_app.logger.debug(f"Searching for {username}") try: user = UserService.get_user_by_username(username) except NotFound: current_app.logger.error(f"Username {username} not found") continue # If we can't find the user, keep going no need to fail # Validate mention_notification. if user.mentions_notifications is False: continue message = Message() message.message_type = MessageType.MENTION_NOTIFICATION.value message.project_id = project_id message.from_user_id = chat_from message.to_user_id = user.id message.subject = f"You were mentioned in Project Chat on {link}" message.message = chat messages.append(dict(message=message, user=user)) MessageService._push_messages(messages) query = ( """ select user_id from project_favorites where project_id = :project_id""" ) result = db.engine.execute(text(query), project_id=project_id) favorited_users = [r[0] for r in result] if len(favorited_users) != 0: project_link = MessageService.get_project_link(project_id) # project_title = ProjectService.get_project_title(project_id) messages = [] for user_id in favorited_users: try: user = UserService.get_user_dto_by_id(user_id) except NotFound: continue # If we can't find the user, keep going no need to fail if user.comments_notifications is False: continue message = Message() message.message_type = MessageType.PROJECT_CHAT_NOTIFICATION.value message.project_id = project_id message.to_user_id = user.id message.subject = ( f"{chat_from} left a comment in Project {project_link}" ) message.message = chat messages.append(dict(message=message, user=user)) MessageService._push_messages(messages)