You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
195 lines
8.8 KiB
195 lines
8.8 KiB
from django.db.models.fields.related_lookups import RelatedExact
|
|
from rest_framework.views import APIView
|
|
from rest_framework.permissions import IsAuthenticated
|
|
from rest_framework.response import Response
|
|
from rest_framework import status
|
|
|
|
from django.apps import apps
|
|
from django.utils import timezone
|
|
from django.db.models import Q
|
|
from django.core.exceptions import ObjectDoesNotExist
|
|
|
|
from collections import defaultdict
|
|
from urllib.parse import unquote
|
|
|
|
from .utils import build_serializer_class, get_data, get_serialized_data
|
|
|
|
from tournaments.models import ModelLog, DataAccess, BaseModel
|
|
|
|
class DataApi(APIView):
|
|
permission_classes = [IsAuthenticated]
|
|
|
|
def post(self, request, *args, **kwargs):
|
|
|
|
# unfold content
|
|
model_operation = request.data.get('operation')
|
|
model_name = request.data.get('model_name')
|
|
data = request.data.get('data')
|
|
store_id = request.data.get('store_id')
|
|
|
|
print(f"DataApi post > {model_operation} {model_name}")
|
|
|
|
serializer_class = build_serializer_class(model_name)
|
|
data['last_updated_by'] = request.user.id # always refresh the user performing the operation
|
|
|
|
model = apps.get_model(app_label='tournaments', model_name=model_name)
|
|
now = timezone.localtime(timezone.now())
|
|
|
|
if model_operation == 'POST':
|
|
serializer = serializer_class(data=data, context={'request': request})
|
|
if serializer.is_valid():
|
|
serializer.save()
|
|
return Response(serializer.data, status=status.HTTP_201_CREATED)
|
|
# return self.save_and_create_log(request, serializer, model_operation, model_name, store_id, now)
|
|
else:
|
|
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
|
|
elif model_operation == 'PUT':
|
|
data_id = data.get('id')
|
|
instance = get_data('tournaments', model_name, data_id)
|
|
serializer = serializer_class(instance, data=data, context={'request': request})
|
|
if serializer.is_valid():
|
|
if instance.last_update <= serializer.validated_data.get('last_update'):
|
|
print('>>> update')
|
|
serializer.save()
|
|
return Response(serializer.data, status=status.HTTP_200_OK)
|
|
# return self.save_and_create_log(request, serializer, model_operation, model_name, store_id, now)
|
|
else:
|
|
print('>>> return 203')
|
|
return Response(serializer.data, status=status.HTTP_203_NON_AUTHORITATIVE_INFORMATION)
|
|
else:
|
|
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
|
|
elif model_operation == 'DELETE':
|
|
data_id = data.get('id')
|
|
try:
|
|
instance = get_data('tournaments', model_name, data_id)
|
|
instance.delete()
|
|
return Response(status=status.HTTP_204_NO_CONTENT)
|
|
except model.DoesNotExist: # POST
|
|
delete = ModelLog.objects.filter(model_id=data_id, operation=model_operation).first()
|
|
if delete:
|
|
return Response(status=status.HTTP_208_ALREADY_REPORTED)
|
|
else:
|
|
return Response(status=status.HTTP_404_NOT_FOUND)
|
|
|
|
|
|
def get(self, request, *args, **kwargs):
|
|
last_update_str = request.query_params.get('last_update')
|
|
decoded_last_update = unquote(last_update_str) # Decodes %2B into +
|
|
|
|
# print(f'last_update_str = {last_update_str}')
|
|
# print(f'decoded_last_update = {decoded_last_update}')
|
|
if not decoded_last_update:
|
|
return Response({"error": "last_update parameter is required"}, status=status.HTTP_400_BAD_REQUEST)
|
|
try:
|
|
last_update = timezone.datetime.fromisoformat(decoded_last_update)
|
|
except ValueError:
|
|
return Response({"error": f"Invalid date format for last_update: {decoded_last_update}"}, status=status.HTTP_400_BAD_REQUEST)
|
|
|
|
print(f'/data GET: {last_update}')
|
|
|
|
logs = self.query_model_logs(last_update, request.user)
|
|
print(f'>>> log count = {len(logs)}')
|
|
|
|
updates = defaultdict(dict)
|
|
deletions = defaultdict(list)
|
|
|
|
last_log_date = None
|
|
for log in logs:
|
|
last_log_date = log.date
|
|
try:
|
|
if log.operation in ['POST', 'PUT']:
|
|
data = get_serialized_data('tournaments', log.model_name, log.model_id)
|
|
updates[log.model_name][log.model_id] = data
|
|
elif log.operation == 'DELETE':
|
|
deletions[log.model_name].append({'model_id': log.model_id, 'store_id': log.store_id})
|
|
elif log.operation == 'GRANT_ACCESS':
|
|
|
|
model = apps.get_model('tournaments', model_name=log.model_name)
|
|
instance = model.objects.get(id=log.model_id)
|
|
serializer_class = build_serializer_class(log.model_name)
|
|
serializer = serializer_class(instance)
|
|
|
|
# data = get_serialized_data('tournaments', log.model_name, log.model_id)
|
|
updates[log.model_name][log.model_id] = serializer.data
|
|
# instance = model.objects.get(id=log.model_id)
|
|
self.add_children_recursively(instance, updates)
|
|
self.add_parents_recursively(instance, updates)
|
|
elif log.operation == 'REVOKE_ACCESS':
|
|
print(f'revoke access {log.model_id} - {log.store_id}')
|
|
deletions[log.model_name].append({'model_id': log.model_id, 'store_id': log.store_id})
|
|
except ObjectDoesNotExist:
|
|
pass
|
|
|
|
# Convert updates dict to list for each model
|
|
for model_name in updates:
|
|
updates[model_name] = list(updates[model_name].values())
|
|
|
|
# Convert deletions set to list for each model
|
|
for model_name in deletions:
|
|
deletions[model_name] = deletions[model_name]
|
|
|
|
response_data = {
|
|
"updates": dict(updates),
|
|
"deletions": dict(deletions),
|
|
"date": last_log_date
|
|
}
|
|
|
|
return Response(response_data, status=status.HTTP_200_OK)
|
|
|
|
def query_model_logs(self, last_update, user):
|
|
# print(f'last_update = {last_update}')
|
|
log_query = Q(date__gt=last_update) & Q(users=user)
|
|
return ModelLog.objects.filter(log_query).order_by('date')
|
|
|
|
# get recently modified DataAccess
|
|
# data_access_query = Q(last_hierarchy_update__gt=last_update) & (Q(shared_with__in=[user]) | Q(owner=user))
|
|
# data_access_list = DataAccess.objects.filter(data_access_query) #.values_list('model_id', flat=True)
|
|
|
|
# print(f'>> da count = {len(data_access_list)}')
|
|
|
|
# # get ids of all recently updated related instances of each shared data
|
|
# model_ids = []
|
|
# for data_access in data_access_list:
|
|
# model_ids.append(data_access.model_id)
|
|
# try:
|
|
# instance = get_data('tournaments', data_access.model_name, data_access.model_id)
|
|
# related_instances = instance.related_instances()
|
|
# related_ids = [ri.id for ri in instance.related_instances() if ri.last_update > last_update]
|
|
# model_ids.extend(related_ids)
|
|
# except ObjectDoesNotExist:
|
|
# pass
|
|
|
|
# get all ModelLog list since the last_update, from the user and from the data he has access to
|
|
|
|
|
|
def add_children_recursively(self, instance, updates):
|
|
"""
|
|
Recursively add all children of an instance to the updates dictionary.
|
|
"""
|
|
# print(f"Instance class: {instance.__class__}")
|
|
child_models = instance.get_children_by_model()
|
|
|
|
for child_model_name, children in child_models.items():
|
|
for child in children:
|
|
if isinstance(child, BaseModel):
|
|
serializer_class = build_serializer_class(child_model_name)
|
|
serializer = serializer_class(child)
|
|
updates[child_model_name][child.id] = serializer.data
|
|
self.add_children_recursively(child, updates)
|
|
|
|
def add_parents_recursively(self, instance, updates):
|
|
parent_models = instance.get_parents_by_model()
|
|
|
|
for parent_model_name, parent in parent_models.items():
|
|
# print(f'parent = {parent_model_name}')
|
|
if isinstance(parent, BaseModel):
|
|
serializer_class = build_serializer_class(parent_model_name)
|
|
serializer = serializer_class(parent)
|
|
updates[parent_model_name][parent.id] = serializer.data
|
|
self.add_parents_recursively(parent, updates)
|
|
|
|
# def get_data(self, model, log):
|
|
# instance = model.objects.get(id=log.model_id)
|
|
# serializer_class = build_serializer_class(log.model_name)
|
|
# serializer = serializer_class(instance)
|
|
# return serializer.data
|
|
|