404 lines
18 KiB
Python
Executable File
404 lines
18 KiB
Python
Executable File
import time
|
|
import uuid
|
|
from wsgiref.util import FileWrapper
|
|
|
|
from django.core.files.uploadedfile import TemporaryUploadedFile
|
|
from django.http import HttpResponse, JsonResponse
|
|
from django.utils.crypto import get_random_string
|
|
from drf_spectacular.utils import extend_schema
|
|
from rest_framework import status, viewsets
|
|
from rest_framework.decorators import action
|
|
from rest_framework.response import Response
|
|
from typing import List
|
|
from rest_framework.renderers import JSONRenderer
|
|
from rest_framework_xml.renderers import XMLRenderer
|
|
|
|
from fwd import settings
|
|
from ..celery_worker.client_connector import c_connector
|
|
from ..annotation.api import throw_on_failure
|
|
from ..constant.common import allowed_p_type, ProcessType, REQUEST_ID, FOLDER_TYPE, \
|
|
FolderFileType, TEMPLATE_ID, EntityStatus, pdf_extensions, allowed_file_extensions
|
|
from ..exception.exceptions import RequiredFieldException, InvalidException, NotFoundException, \
|
|
PermissionDeniedException, LimitReachedException, LockedEntityException, FileContentInvalidException, ServiceTimeoutException
|
|
from ..models import SubscriptionRequest, UserProfile, SubscriptionRequestFile, OcrTemplate, Subscription
|
|
from ..response.ReportSerializer import ReportSerializer
|
|
from ..utils import FileUtils, ProcessUtil
|
|
|
|
class CtelViewSet(viewsets.ViewSet):
|
|
lookup_field = "username"
|
|
size_to_compress = settings.SIZE_TO_COMPRESS
|
|
|
|
@extend_schema(request={
|
|
'multipart/form-data': {
|
|
'type': 'object',
|
|
'properties': {
|
|
'imei_files': {
|
|
'type': 'array',
|
|
'items': {
|
|
'type': 'string',
|
|
'format': 'binary'
|
|
}
|
|
},
|
|
'invoice_file': {
|
|
'type': 'string',
|
|
'format': 'binary'
|
|
},
|
|
'redemption_ID': {
|
|
'type': 'string'
|
|
},
|
|
},
|
|
'required': {'imei_files'}
|
|
}
|
|
}, responses=None, tags=['ocr'])
|
|
@action(detail=False, url_path="images/process", methods=["POST"])
|
|
def processes(self, request):
|
|
user_info = ProcessUtil.get_user(request)
|
|
user = user_info.user
|
|
sub = user_info.current_sub
|
|
|
|
validated_data = ProcessUtil.sbt_validate_ocr_request_and_get(request, sub)
|
|
|
|
provider_code = 'SAP'
|
|
rq_id = provider_code + uuid.uuid4().hex
|
|
|
|
imei_file_objs: List[TemporaryUploadedFile] = validated_data['imei_file']
|
|
invoice_file_objs: List[TemporaryUploadedFile] = validated_data['invoice_file']
|
|
|
|
files = {
|
|
"imei": imei_file_objs,
|
|
"invoice": invoice_file_objs
|
|
}
|
|
total_page = len(files.keys())
|
|
|
|
p_type = validated_data['type']
|
|
new_request: SubscriptionRequest = SubscriptionRequest(pages=total_page,
|
|
pages_left=total_page,
|
|
process_type=p_type, status=1, request_id=rq_id,
|
|
provider_code=provider_code,
|
|
subscription=sub)
|
|
new_request.save()
|
|
count = 0
|
|
compact_files = []
|
|
for doc_type, doc_files in files.items():
|
|
for i, doc_file in enumerate(doc_files):
|
|
_ext = doc_file.name.split(".")[-1]
|
|
if _ext not in allowed_file_extensions:
|
|
return JsonResponse(status=status.HTTP_406_NOT_ACCEPTABLE, data={"request_id": rq_id, "message": f"File {_ext} is now allowed"})
|
|
_name = f"temp_{doc_type}_{rq_id}_{i}.{_ext}"
|
|
doc_file.seek(0)
|
|
file_path = FileUtils.resize_and_save_file(_name, new_request, doc_file, 100)
|
|
S3_path = FileUtils.save_to_S3(_name, new_request, file_path)
|
|
count += 1
|
|
this_file = {
|
|
"file_name": _name,
|
|
"file_path": file_path,
|
|
"file_type": doc_type
|
|
}
|
|
compact_files.append(this_file)
|
|
c_connector.do_pdf((rq_id, sub.id, p_type, user.id, compact_files))
|
|
|
|
return JsonResponse(status=status.HTTP_200_OK, data={"request_id": rq_id})
|
|
|
|
@extend_schema(request={
|
|
'multipart/form-data': {
|
|
'type': 'object',
|
|
'properties': {
|
|
'imei_files': {
|
|
'type': 'array',
|
|
'items': {
|
|
'type': 'string',
|
|
'format': 'binary'
|
|
}
|
|
},
|
|
'invoice_file': {
|
|
'type': 'string',
|
|
'format': 'binary'
|
|
},
|
|
'redemption_ID': {
|
|
'type': 'string'
|
|
},
|
|
},
|
|
'required': {'imei_files'}
|
|
}
|
|
}, responses=None, tags=['ocr'])
|
|
@action(detail=False, url_path="images/process_sync", methods=["POST"])
|
|
def processes_sync(self, request):
|
|
user_info = ProcessUtil.get_user(request)
|
|
user = user_info.user
|
|
sub = user_info.current_sub
|
|
|
|
validated_data = ProcessUtil.sbt_validate_ocr_request_and_get(request, sub)
|
|
|
|
provider_code = 'SAP'
|
|
rq_id = provider_code + uuid.uuid4().hex
|
|
|
|
imei_file_objs: List[TemporaryUploadedFile] = validated_data['imei_file']
|
|
invoice_file_objs: List[TemporaryUploadedFile] = validated_data['invoice_file']
|
|
|
|
files = {
|
|
"imei": imei_file_objs,
|
|
"invoice": invoice_file_objs
|
|
}
|
|
total_page = len(files.keys())
|
|
p_type = validated_data['type']
|
|
new_request: SubscriptionRequest = SubscriptionRequest(pages=total_page,
|
|
pages_left=total_page,
|
|
process_type=p_type, status=1, request_id=rq_id,
|
|
provider_code=provider_code,
|
|
subscription=sub)
|
|
new_request.save()
|
|
count = 0
|
|
compact_files = []
|
|
for doc_type, doc_files in files.items():
|
|
for i, doc_file in enumerate(doc_files):
|
|
_ext = doc_file.name.split(".")[-1]
|
|
if _ext not in allowed_file_extensions:
|
|
return JsonResponse(status=status.HTTP_406_NOT_ACCEPTABLE, data={"request_id": rq_id, "message": f"File {_ext} is now allowed"})
|
|
_name = f"temp_{doc_type}_{rq_id}_{i}.{_ext}"
|
|
doc_file.seek(0)
|
|
file_path = FileUtils.resize_and_save_file(_name, new_request, doc_file, 100)
|
|
_ = FileUtils.save_to_S3(_name, new_request, file_path)
|
|
count += 1
|
|
this_file = {
|
|
"file_name": _name,
|
|
"file_path": file_path,
|
|
"file_type": doc_type
|
|
}
|
|
compact_files.append(this_file)
|
|
c_connector.do_pdf((rq_id, sub.id, p_type, user.id, compact_files))
|
|
|
|
time_out = 120
|
|
start = time.time()
|
|
while time.time() - start < time_out:
|
|
time.sleep(0.1)
|
|
report_filter = SubscriptionRequest.objects.filter(request_id=rq_id)
|
|
if len(report_filter) != 1:
|
|
raise InvalidException(excArgs='requestId')
|
|
|
|
if user_info.current_sub.id != report_filter[0].subscription.id:
|
|
raise InvalidException(excArgs="user")
|
|
if int(report_filter[0].process_type) == ProcessType.FI_INVOICE.value:
|
|
data = report_filter[0].predict_result
|
|
xml_as_string = ""
|
|
|
|
if data and 'content' in data and 'combine_results' in data['content'] and 'xml' in data['content']['combine_results']:
|
|
xml_as_string = data['content']['combine_results']['xml']
|
|
xml_as_string = xml_as_string.replace("\n", "").replace("\\", "")
|
|
return HttpResponse(xml_as_string,content_type="text/xml")
|
|
|
|
serializer: ReportSerializer = ReportSerializer(data=report_filter, many=True)
|
|
serializer.is_valid()
|
|
if report_filter[0].status == 400:
|
|
raise FileContentInvalidException()
|
|
if report_filter[0].status == 100: # continue, only return when result is fullfilled
|
|
continue
|
|
|
|
if len(serializer.data) == 0:
|
|
continue
|
|
if serializer.data[0].get("data", None) is None:
|
|
continue
|
|
if serializer.data[0]["data"].get("status", 200) != 200:
|
|
continue
|
|
|
|
return Response(status=status.HTTP_200_OK, data=serializer.data[0])
|
|
raise ServiceTimeoutException(excArgs=f"{rq_id}")
|
|
|
|
@extend_schema(request={
|
|
'multipart/form-data': {
|
|
'type': 'object',
|
|
'properties': {
|
|
'request_id': {
|
|
'type': 'string',
|
|
},
|
|
'retailername': {
|
|
'type': 'string',
|
|
},
|
|
'sold_to_party': {
|
|
'type': 'string',
|
|
},
|
|
'purchase_date': {
|
|
'type': 'array',
|
|
'items': {
|
|
'type': 'string',
|
|
}
|
|
},
|
|
'imei_number': {
|
|
'type': 'array',
|
|
'items': {
|
|
'type': 'string',
|
|
}
|
|
},
|
|
},
|
|
'required': ['request_id', 'retailername', 'sold_to_party', 'purchase_date', 'imei_number']
|
|
}
|
|
}, responses=None, tags=['ocr'])
|
|
@action(detail=False, url_path="images/feedback", methods=["POST"])
|
|
def feedback(self, request):
|
|
validated_data = ProcessUtil.sbt_validate_feedback(request)
|
|
rq_id = validated_data['request_id']
|
|
|
|
subcription_request = SubscriptionRequest.objects.filter(request_id=rq_id)
|
|
if len(subcription_request) == 0:
|
|
raise InvalidException(excArgs=f"{rq_id}")
|
|
subcription_request = subcription_request[0]
|
|
|
|
# Save to database
|
|
subcription_request.feedback_result = validated_data
|
|
subcription_request.save()
|
|
file_name = f"feedback_{rq_id}.json"
|
|
# Save to local
|
|
file_path = FileUtils.save_json_file(file_name, subcription_request, validated_data)
|
|
# Upload to S3
|
|
S3_path = FileUtils.save_to_S3(file_name, subcription_request, file_path)
|
|
|
|
return JsonResponse(status=status.HTTP_200_OK, data={"request_id": rq_id})
|
|
|
|
|
|
@extend_schema(request=None, responses=None, tags=['data'])
|
|
@extend_schema(request=None, responses=None, tags=['templates'], methods=['GET'])
|
|
@action(detail=False, url_path=r"media/(?P<folder_type>\w+)/(?P<uq_id>\w+)", methods=["GET"])
|
|
def get_file_v2(self, request, uq_id=None, folder_type=None):
|
|
user_data = request.user_data
|
|
content_type = "image/png"
|
|
|
|
file_name: str = request.query_params.get('file_name', None)
|
|
if folder_type is None:
|
|
raise RequiredFieldException(excArgs=FOLDER_TYPE)
|
|
if uq_id is None:
|
|
raise RequiredFieldException(excArgs=REQUEST_ID)
|
|
|
|
if folder_type == 'templates':
|
|
temps: list = OcrTemplate.objects.filter(id=uq_id)
|
|
if len(temps) != 1:
|
|
raise NotFoundException(excArgs='file')
|
|
temp: OcrTemplate = temps[0]
|
|
user = temp.subscription.user
|
|
content_type = 'application/pdf' if temp.file_name.split(".")[-1] in pdf_extensions else content_type
|
|
if user.id != user_data['internal_id'] or user.status != EntityStatus.ACTIVE.value:
|
|
raise PermissionDeniedException()
|
|
print(temp.file_path)
|
|
return HttpResponse(FileWrapper(FileUtils.get_file(temp.file_path)), status=status.HTTP_200_OK,
|
|
headers={'Content-Disposition': 'filename={fn}'.format(fn=temp.file_name)},
|
|
content_type=content_type)
|
|
elif folder_type == 'requests':
|
|
if file_name is None:
|
|
raise RequiredFieldException(excArgs='file_name')
|
|
try:
|
|
rqs = SubscriptionRequest.objects.filter(request_id=uq_id)
|
|
if len(rqs) != 1:
|
|
raise NotFoundException(excArgs='file')
|
|
rq = rqs[0]
|
|
user = rq.subscription.user
|
|
|
|
content_type = 'application/pdf' if file_name.split(".")[-1] in pdf_extensions else content_type
|
|
|
|
if user.id != user_data['internal_id'] or user.status != EntityStatus.ACTIVE.value:
|
|
raise PermissionDeniedException()
|
|
file_data = SubscriptionRequestFile.objects.filter(request=rq, file_name=file_name)[0]
|
|
except IndexError:
|
|
raise NotFoundException(excArgs='file')
|
|
return HttpResponse(FileWrapper(FileUtils.get_file(file_data.file_path)), status=status.HTTP_200_OK,
|
|
headers={'Content-Disposition': 'filename={fn}'.format(fn=file_data.file_name)},
|
|
content_type=content_type)
|
|
else:
|
|
raise InvalidException(excArgs='type')
|
|
|
|
@extend_schema(request=None, responses=None, tags=['data'])
|
|
@action(detail=False, url_path=r"v2/media/request/(?P<media_id>\w+)", methods=["GET"])
|
|
def get_file_v3(self, request, media_id=None):
|
|
|
|
user_info = ProcessUtil.get_user(request)
|
|
sub = user_info.current_sub
|
|
content_type = "image/png"
|
|
|
|
if media_id is None:
|
|
raise RequiredFieldException(excArgs=REQUEST_ID)
|
|
|
|
try:
|
|
media_list = SubscriptionRequestFile.objects.filter(code=media_id)
|
|
if len(media_list) != 1:
|
|
raise LockedEntityException(excArgs='media')
|
|
media_data: SubscriptionRequestFile = media_list[0]
|
|
if media_data.request.subscription.id != sub.id:
|
|
raise PermissionDeniedException()
|
|
file_name = media_data.file_name
|
|
|
|
content_type = 'application/pdf' if file_name.split(".")[-1] in pdf_extensions else content_type
|
|
|
|
except IndexError:
|
|
raise NotFoundException(excArgs='file')
|
|
return HttpResponse(FileWrapper(FileUtils.get_file(media_data.file_path)), status=status.HTTP_200_OK,
|
|
headers={'Content-Disposition': 'filename={fn}'.format(fn=file_name)},
|
|
content_type=content_type)
|
|
|
|
@extend_schema(request=None, responses=None, tags=['data'])
|
|
@throw_on_failure(InvalidException(excArgs='data'))
|
|
@action(detail=False, url_path=r"result/(?P<request_id>\w+)", methods=["GET"], renderer_classes=[JSONRenderer, XMLRenderer])
|
|
def get_result(self, request, request_id=None):
|
|
|
|
user_info = ProcessUtil.get_user(request)
|
|
if request_id is None:
|
|
raise RequiredFieldException(excArgs='requestId')
|
|
|
|
report_filter = SubscriptionRequest.objects.filter(request_id=request_id)
|
|
if len(report_filter) != 1:
|
|
raise InvalidException(excArgs='requestId')
|
|
|
|
if user_info.current_sub.id != report_filter[0].subscription.id:
|
|
raise InvalidException(excArgs="user")
|
|
if int(report_filter[0].process_type) == ProcessType.FI_INVOICE.value:
|
|
data = report_filter[0].predict_result
|
|
xml_as_string = ""
|
|
|
|
if data and 'content' in data and 'combine_results' in data['content'] and 'xml' in data['content']['combine_results']:
|
|
xml_as_string = data['content']['combine_results']['xml']
|
|
xml_as_string = xml_as_string.replace("\n", "").replace("\\", "")
|
|
|
|
# return Response(status=status.HTTP_200_OK, data=xml_as_string, content_type="application/xml; charset=utf-8")
|
|
# return HttpResponse(xml_as_string,content_type="text/xml")
|
|
|
|
return HttpResponse(xml_as_string,content_type="text/xml")
|
|
|
|
serializer: ReportSerializer = ReportSerializer(data=report_filter, many=True)
|
|
serializer.is_valid()
|
|
# print(f"[DEBUG]: result: {serializer.data[0]}")
|
|
if report_filter[0].status == 400:
|
|
raise FileContentInvalidException()
|
|
if report_filter[0].status == 100: # continue, only return when result is fullfilled
|
|
empty_data = serializer.data[0]
|
|
empty_data["data"] = None
|
|
return Response(status=status.HTTP_200_OK, data=empty_data)
|
|
data = serializer.data[0]
|
|
data["status"] = "3"
|
|
return Response(status=status.HTTP_200_OK, data=serializer.data[0])
|
|
|
|
@throw_on_failure(InvalidException(excArgs='data'))
|
|
@action(detail=False, url_path=r"rsa/(?P<request_id>\w+)", methods=["GET"])
|
|
def get_result2(self, request, request_id=None):
|
|
|
|
user_info = ProcessUtil.get_user(request)
|
|
if request_id is None:
|
|
raise RequiredFieldException(excArgs='requestId')
|
|
|
|
report_filter = SubscriptionRequest.objects.filter(request_id=request_id)
|
|
if len(report_filter) != 1:
|
|
raise InvalidException(excArgs='requestId')
|
|
|
|
if user_info.current_sub.id != report_filter[0].subscription.id:
|
|
raise InvalidException(excArgs="user")
|
|
if int(report_filter[0].process_type) == ProcessType.FI_INVOICE.value:
|
|
data = report_filter[0].predict_result
|
|
xml_as_string = ""
|
|
|
|
if data and 'content' in data and 'combine_results' in data['content'] and 'xml' in data['content']['combine_results']:
|
|
xml_as_string = data['content']['combine_results']['xml']
|
|
xml_as_string = xml_as_string.replace("\n", "").replace("\\", "")
|
|
|
|
# return Response(status=status.HTTP_200_OK, data=xml_as_string, content_type="application/xml; charset=utf-8")
|
|
return HttpResponse(xml_as_string,content_type="text/xml")
|
|
|
|
serializer: ReportSerializer = ReportSerializer(data=report_filter, many=True)
|
|
serializer.is_valid()
|
|
|
|
return Response(status=status.HTTP_200_OK, data=serializer.data[0])
|