def notify_failed_load_document(file_name, kwargs):
"""
Notify users about failed LoadDocument tasks
"""
from apps.project.models import UploadSession
project_id = UploadSession.objects.get(pk=kwargs['session_id']).project_id
data = dict(file_name=file_name,
project_id=project_id,
upload_session_id=kwargs['session_id'],
directory_path=kwargs['directory_path'])
message = ChannelMessage(
message_types.CHANNEL_MSG_TYPE_FAILED_LOAD_DOCUMENT, data)
admins_and_managers = User.objects.qs_admins_and_managers()
Websockets().send_to_users(qs_users=admins_and_managers,
message_obj=message)
non_admins = User.objects \
.filter(role__is_admin=False, role__is_manager=False) \
.filter(Q(project_owners__pk=project_id) |
Q(project_reviewers__pk=project_id) |
Q(project_super_reviewers__pk=project_id))
if non_admins.exists():
Websockets().send_to_users(qs_users=non_admins, message_obj=message)
def notify_cancelled_upload_session(session, user_id):
"""
Notify users about cancelled upload session
"""
cancelled_by_user = User.objects.get(pk=user_id)
data = {
'session_id':
session.pk,
'project_id':
session.project_id,
'cancelled_by_user_id':
cancelled_by_user.pk if cancelled_by_user else None,
'cancelled_by_user_name':
cancelled_by_user.get_full_name() if cancelled_by_user else None
}
message = ChannelMessage(
message_types.CHANNEL_MSG_TYPE_CANCELLED_UPLOAD_SESSION, data)
admins_and_managers = User.objects.qs_admins_and_managers()
Websockets().send_to_users(qs_users=admins_and_managers,
message_obj=message)
non_admins = User.objects \
.filter(role__is_admin=False, role__is_manager=False) \
.filter(Q(project_owners__pk=session.project_id) |
Q(project_reviewers__pk=session.project_id) |
Q(project_super_reviewers__pk=session.project_id))
if non_admins.exists():
Websockets().send_to_users(qs_users=non_admins, message_obj=message)
def notify_active_upload_sessions(sessions: List[UploadSession]):
"""
Notify users about active upload sessions to show/track progress
"""
data = []
for session in sessions:
progress = session.document_tasks_progress_total
document_progress_details = session.document_tasks_progress()
all_documents = len(document_progress_details)
processed_documents = sum([
1 for k, v in document_progress_details.items()
if v.get('tasks_overall_status') in READY_STATES
])
unprocessed_documents = all_documents - processed_documents
data.append({
'session_id':
session.pk,
'project_id':
session.project.pk,
'user_id':
session.created_by.pk if session.created_by else None,
'user_name':
session.created_by.get_full_name() if session.created_by else None,
'progress':
progress,
'processed_documents':
processed_documents,
'unprocessed_documents':
unprocessed_documents,
'completed':
bool(session.completed),
'created_date':
session.created_date
})
message = ChannelMessage(
message_types.CHANNEL_MSG_TYPE_ACTIVE_UPLOAD_SESSIONS, data)
admins_and_managers = User.objects.qs_admins_and_managers()
Websockets().send_to_users(qs_users=admins_and_managers,
message_obj=message)
for reviewer in User.objects.filter(role__is_admin=False,
role__is_manager=False):
_data = [
i for i in data if User.objects.filter(pk=reviewer.pk).filter(
Q(project_owners__pk=i['project_id'])
| Q(project_reviewers__pk=i['project_id'])
| Q(project_super_reviewers__pk=i['project_id'])).exists()
]
if _data:
message = ChannelMessage(
message_types.CHANNEL_MSG_TYPE_ACTIVE_UPLOAD_SESSIONS, _data)
Websockets().send_to_user(user_id=reviewer.pk, message_obj=message)
def notify_active_upload_sessions(sessions: List[UploadSession]):
"""
Notify users about active upload sessions to show/track progress
"""
data = []
for session in sessions:
progress = session.document_tasks_progress_total
document_progress_details = session.document_tasks_progress()
all_documents = len(document_progress_details)
processed_documents = sum([1 for k, v in document_progress_details.items() if v.get('tasks_overall_status') in READY_STATES])
unprocessed_documents = all_documents - processed_documents
session_data = {'session_id': session.pk,
'project_id': session.project.pk,
'user_id': session.created_by.pk if session.created_by else None,
'user_name': session.created_by.get_full_name() if session.created_by else None,
'progress': progress,
'processed_documents': processed_documents,
'unprocessed_documents': unprocessed_documents,
'completed': bool(session.completed),
'created_date': session.created_date}
from apps.project.tasks import LoadArchive
session_archive_tasks = session.task_set.filter(name=LoadArchive.name,
progress=100,
metadata__progress_sent=False)
if session_archive_tasks.exists():
archive_tasks_progress_data = list()
for task in session_archive_tasks.all():
archive_tasks_progress_data.append(
dict(archive_name=task.metadata.get('file_name'),
arhive_progress=task.metadata.get('progress')))
session_data['archive_data'] = archive_tasks_progress_data
for task in session_archive_tasks:
task.metadata['progress_sent'] = True
task.save()
data.append(session_data)
message = ChannelMessage(message_types.CHANNEL_MSG_TYPE_ACTIVE_UPLOAD_SESSIONS, data)
admins_and_managers = User.objects.qs_admins_and_managers()
Websockets().send_to_users(qs_users=admins_and_managers, message_obj=message)
for reviewer in User.objects.filter(role__is_admin=False, role__is_manager=False):
_data = [i for i in data
if User.objects.filter(pk=reviewer.pk).filter(
Q(project_owners__pk=i['project_id']) |
Q(project_reviewers__pk=i['project_id']) |
Q(project_super_reviewers__pk=i['project_id'])).exists()]
if _data:
message = ChannelMessage(message_types.CHANNEL_MSG_TYPE_ACTIVE_UPLOAD_SESSIONS, _data)
Websockets().send_to_user(user_id=reviewer.pk, message_obj=message)
def document_field_detection_failed_impl(sender, signal, document: Document,
document_field: DocumentField,
message: str,
document_initial_load: bool):
if document_initial_load:
# WS notifications for failed detection are disabled when
# document is being processed for the first time
return
project_id = document.project_id
data = {
'document': {
'id': document.pk,
'name': document.name,
'project_id': project_id,
'project_name': document.project.name,
},
'field': {
'id': document_field.uid,
'code': document_field.code,
'title': document_field.title
},
'message': message
}
chan_msg = ChannelMessage(message_types.CHANNEL_MSG_TYPE_DETECTION_FAILED,
data)
users = User.get_users_for_object(object_pk=project_id,
object_model=Project,
perm_name='add_project_document')
Websockets().send_to_users(qs_users=users, message_obj=chan_msg)
def notify_active_pdf2pdfa_tasks(data):
"""
Notify users about active upload sessions to show/track progress
"""
user_ids = set([i['user_id'] for i in data])
for user_id in user_ids:
user_data = [i for i in data if i['user_id'] == user_id]
message = ChannelMessage(message_types.CHANNEL_MSG_TYPE_ACTIVE_PDF2PDFA_TASKS, user_data)
Websockets().send_to_user(user_id=user_id, message_obj=message)
def notify_on_document_changes(doc_id: int, message: ChannelMessage):
"""
Send the websocket message to the users allowed to read the specified document.
:param doc_id: ID of the document.
:param message: Message to send.
:return:
"""
admins_and_managers = User.objects \
.qs_admins_and_managers().order_by().values_list('pk')
reviewers_owners = Project.objects \
.qs_owners_reviewers_super_reviewers_by_doc_id(doc_id)
Websockets().send_to_users(
qs_users=admins_and_managers.union(reviewers_owners),
message_obj=message)
def notify_active_upload_sessions(sessions: List[UploadSession]):
"""
Notify users about active upload sessions to show/track progress
"""
data = []
for session in sessions:
# calculate progress baed on stored entities
session_data = get_session_data_by_document_query(session)
data.append(session_data)
from guardian.shortcuts import get_objects_for_user
for user in User.objects.filter(is_active=True):
user_project_ids = list(get_objects_for_user(user, 'project.add_project_document', Project)
.values_list('pk', flat=True))
user_data = [i for i in data if i['project_id'] in user_project_ids]
message = ChannelMessage(message_types.CHANNEL_MSG_TYPE_ACTIVE_UPLOAD_SESSIONS, user_data)
Websockets().send_to_user(user_id=user.pk, message_obj=message)
def notify_cancelled_upload_session(session, user_id):
"""
Notify users about cancelled upload session
"""
cancelled_by_user = User.objects.get(pk=user_id)
data = {'session_id': session.pk,
'project_id': session.project_id,
'cancelled_by_user_id': cancelled_by_user.pk if cancelled_by_user else None,
'cancelled_by_user_name': cancelled_by_user.name if cancelled_by_user else None}
message = ChannelMessage(message_types.CHANNEL_MSG_TYPE_CANCELLED_UPLOAD_SESSION, data)
users = User.get_users_for_object(
object_pk=session.project_id,
object_model=Project,
perm_name='add_project_document')
Websockets().send_to_users(qs_users=users, message_obj=message)
def notify_failed_load_document(file_name, session_id, directory_path):
"""
Notify users about failed LoadDocument tasks
"""
project_id = UploadSession.objects.get(pk=session_id).project_id
data = dict(
file_name=file_name,
project_id=project_id,
upload_session_id=session_id,
directory_path=directory_path
)
message = ChannelMessage(message_types.CHANNEL_MSG_TYPE_FAILED_LOAD_DOCUMENT, data)
users = User.get_users_for_object(
object_pk=project_id,
object_model=Project,
perm_name='add_project_document').values_list('pk', flat=True)
Websockets().send_to_users(qs_users=users, message_obj=message)
def notify_on_document_changes(doc_id: int, message: ChannelMessage):
"""
Send the websocket message to the users allowed to read the specified document.
:param doc_id: ID of the document.
:param message: Message to send.
:return:
"""
project_id = Document.objects.get(pk=doc_id).project_id
users_with_project_perm = User.get_users_for_object(
object_pk=project_id,
object_model=Project,
perm_name='change_document_field_values')
users_with_document_perm = User.get_users_for_object(
object_pk=doc_id,
object_model=Document,
perm_name='change_document_field_values')
Websockets().send_to_users(qs_users=users_with_project_perm.union(
users_with_document_perm).distinct(),
message_obj=message)
def combine_querysets_and_send_message(q_sets: List[QuerySet], message: ChannelMessage):
result_set = set()
for q_set in q_sets:
user_ids = set([id for id in q_set.values_list('pk', flat=True)])
result_set.union(user_ids)
Websockets().send_to_users_by_ids(user_ids=list(result_set), message_obj=message)
