def get_request_response(task, message_id):
request_data = prepare_get_response_data(task, message_id)
session = Session()
if TREASURY_SKIP_REQUEST_VERIFY:
session.verify = False
try:
response = session.post(
TREASURY_WSDL_URL,
data=request_data,
timeout=(CONNECT_TIMEOUT, READ_TIMEOUT),
headers={'content-type': 'text/xml'},
)
except RETRY_REQUESTS_EXCEPTIONS as exc:
logger.exception(exc,
extra={"MESSAGE_ID": "TREASURY_REQUEST_EXCEPTION"})
raise task.retry(
exc=exc, countdown=get_exponential_request_retry_countdown(task))
else:
if response.status_code != 200:
logger_method = get_task_retry_logger_method(task, logger)
logger_method(
f"Unexpected status code {response.status_code}:{response.content}",
extra={
"MESSAGE_ID": "TREASURY_UNSUCCESSFUL_STATUS_CODE",
"STATUS_CODE": response.status_code,
})
raise task.retry(countdown=get_exponential_request_retry_countdown(
task, response))
else:
return parse_response_content(response.content)
def process_tender(self, tender_id, *args, **kwargs):
client_request_id = uuid4().hex
try:
response = request_cdb_tender_data(
tender_id,
client_request_id=client_request_id,
)
except RETRY_REQUESTS_EXCEPTIONS as exc:
logger.exception(str(exc),
extra={
"MESSAGE_ID":
"PAYMENTS_CRAWLER_GET_TENDER_EXCEPTION",
"CDB_CLIENT_REQUEST_ID": client_request_id,
})
countdown = get_exponential_request_retry_countdown(self)
raise self.retry(countdown=countdown, exc=exc)
else:
if response.status_code != 200:
logger_method = get_task_retry_logger_method(self, logger)
logger_method(
"Unexpected status code {} while getting tender {}: {}".format(
response.status_code, tender_id, response.text),
extra={
"MESSAGE_ID":
"PAYMENTS_CRAWLER_GET_TENDER_UNSUCCESSFUL_CODE",
"STATUS_CODE": response.status_code,
})
countdown = get_exponential_request_retry_countdown(self, response)
raise self.retry(countdown=countdown)
tender = response.json()["data"]
for complaint_data in tender.get("complaints", []):
if complaint_data[
"status"] in ALLOWED_COMPLAINT_RESOLUTION_STATUSES:
complaint_params = {
"item_id": None,
"item_type": None,
"complaint_id": complaint_data["id"],
"tender_id": tender_id
}
process_complaint_params.apply_async(
kwargs=dict(complaint_params=complaint_params,
complaint_data=complaint_data))
for item_type in ["qualifications", "awards", "cancellations"]:
for item_data in tender.get(item_type, []):
for complaint_data in item_data.get("complaints", []):
if complaint_data[
"status"] in ALLOWED_COMPLAINT_RESOLUTION_STATUSES:
complaint_params = {
"item_id": item_data["id"],
"item_type": item_type,
"complaint_id": complaint_data["id"],
"tender_id": tender_id
}
process_complaint_params.apply_async(
kwargs=dict(complaint_params=complaint_params,
complaint_data=complaint_data))
def ds_upload(task, file_name, file_content):
session = requests.Session()
mount_retries_for_request(session, status_forcelist=(408, 409, 412, 429, 500, 502, 503, 504))
try:
response = session.post(
'{host}/upload'.format(host=DS_HOST),
auth=(DS_USER, DS_PASSWORD),
timeout=(CONNECT_TIMEOUT, READ_TIMEOUT),
files={'file': (file_name, file_content)},
)
except RETRY_REQUESTS_EXCEPTIONS as exc:
logger.error(exc, extra={"MESSAGE_ID": "DOCUMENT_SERVICE_REQUEST_ERROR"})
raise task.retry(exc=exc)
else:
if response.status_code != 200:
logger.error(
"Invalid status while uploading treasury document to DS",
extra={
"MESSAGE_ID": "TREASURY_DOCUMENT_SERVICE_UNSUCCESSFUL_STATUS",
"STATUS_CODE": response.status_code,
"RESPONSE_TEXT": response.text,
"FILE_NAME": file_name
}
)
raise task.retry(countdown=get_exponential_request_retry_countdown(task, response))
else:
logger.info(
f"{file_name} was successfully saved to Document Service"
)
return response.json()
def test_retries_100(self):
task = Mock()
task.request.retries = 100
request = Mock()
request.headers = {"Retry-After": 11}
countdown = get_exponential_request_retry_countdown(task, request)
self.assertEqual(countdown, EXPONENTIAL_RETRY_MAX)
def test_string(self):
task = Mock()
task.request.retries = 0
request = Mock()
request.headers = {"Retry-After": "12.5"}
countdown = get_exponential_request_retry_countdown(task, request)
self.assertEqual(countdown, 12.5)
def test_retries_2(self):
task = Mock()
task.request.retries = 2
request = Mock()
request.headers = {"Retry-After": 11}
countdown = get_exponential_request_retry_countdown(task, request)
self.assertEqual(countdown, 11 + 5**2)
def get_wsdl_client(task):
transport = Transport(timeout=CONNECT_TIMEOUT,
operation_timeout=READ_TIMEOUT)
try:
client = Client(TREASURY_WSDL_URL, transport=transport)
except RETRY_REQUESTS_EXCEPTIONS as exc:
logger.exception(exc,
extra={"MESSAGE_ID": "TREASURY_REQUEST_EXCEPTION"})
raise task.retry(
exc=exc, countdown=get_exponential_request_retry_countdown(task))
return client
def receive_org_catalog(self, message_id):
response = get_request_response(self, message_id=message_id)
if response is None: # isn't ready ?
logger_method = get_task_retry_logger_method(self, logger)
logger_method(f"Empty response for org catalog request",
extra={"MESSAGE_ID": "TREASURY_ORG_CATALOG_EMPTY"})
raise self.retry(
countdown=get_exponential_request_retry_countdown(self, response))
result = update_organisations(self, parse_organisations(response))
logger.info(f"Updated org catalog: {result}",
extra={"MESSAGE_ID": "TREASURY_ORG_CATALOG_UPDATE"})
def send_request(task, xml, sign="", message_id=None, method_name="GetRef"):
request_data = prepare_request_data(task, xml, sign, message_id,
method_name)
session = Session()
if TREASURY_SKIP_REQUEST_VERIFY:
session.verify = False
try:
response = session.post(
TREASURY_WSDL_URL,
data=request_data,
timeout=(CONNECT_TIMEOUT, READ_TIMEOUT),
headers={'content-type': 'text/xml'},
)
except RETRY_REQUESTS_EXCEPTIONS as exc:
logger.exception(exc,
extra={"MESSAGE_ID": "TREASURY_REQUEST_EXCEPTION"})
raise task.retry(
exc=exc, countdown=get_exponential_request_retry_countdown(task))
else:
if response.status_code != 200:
logger_method = get_task_retry_logger_method(task, logger)
logger_method(
f"Unexpected status code {response.status_code}:{response.content}",
extra={
"MESSAGE_ID": "TREASURY_UNSUCCESSFUL_STATUS_CODE",
"STATUS_CODE": response.status_code,
})
else:
code, text = parse_request_response(response.content)
if code == 0:
return code, text # success
logger.error(
f"Unexpected code {code}:{text} while sending request",
extra={
"MESSAGE_ID": "TREASURY_UNSUCCESSFUL_CODE",
"CODE": code
})
raise task.retry(
countdown=get_exponential_request_retry_countdown(task, response))
def log(self, level, msg, *args, **kwargs):
extra = kwargs.setdefault("extra", self.extra)
task = kwargs.pop("task", None)
payment_data = kwargs.pop("payment_data", None)
message_id = extra.get("MESSAGE_ID", None)
if payment_data and message_id:
try:
push_payment_message(payment_data, message_id, msg)
except PyMongoError as exc:
if task:
countdown = get_exponential_request_retry_countdown(task)
raise task.retry(countdown=countdown, exc=exc)
raise
super(PaymentResultsLoggerAdapter, self).log(level, msg, *args, **kwargs)
def process_complaint_resolution(self, payment_data, complaint_data, *args,
**kwargs):
resolution = get_resolution(complaint_data)
if resolution:
try:
set_payment_resolution(payment_data, resolution)
except PyMongoError as exc:
countdown = get_exponential_request_retry_countdown(self)
raise self.retry(countdown=countdown, exc=exc)
logger.info(
"Successfully saved complaint {} resolution".format(
complaint_data["id"]),
payment_data=payment_data,
task=self,
extra={"MESSAGE_ID": PAYMENTS_CRAWLER_RESOLUTION_SAVE_SUCCESS})
def process_complaint_params(self, complaint_params, complaint_data):
try:
payment = get_payment_item_by_params(complaint_params, [
PAYMENTS_PATCH_COMPLAINT_PENDING_SUCCESS,
PAYMENTS_PATCH_COMPLAINT_NOT_PENDING_SUCCESS
])
except PyMongoError as exc:
countdown = get_exponential_request_retry_countdown(self)
raise self.retry(countdown=countdown, exc=exc)
if payment:
if not payment.get("resolution"):
process_complaint_resolution.apply_async(
kwargs=dict(payment_data=payment.get("payment"),
complaint_data=complaint_data))
else:
logger.warning(
"Payment not found for complaint {} with params".format(
complaint_data["id"], complaint_params),
extra={"MESSAGE_ID": "PAYMENTS_CRAWLER_PAYMENT_NOT_FOUND"})
def recheck_framework(self, framework_id, cookies=None):
url = "{host}/api/{version}/frameworks/{framework_id}".format(
host=API_HOST,
version=API_VERSION,
framework_id=framework_id,
)
try:
response = requests.get(url,
timeout=(CONNECT_TIMEOUT, READ_TIMEOUT),
cookies=cookies or {})
except RETRY_REQUESTS_EXCEPTIONS as exc:
logger.exception(
exc, extra={"MESSAGE_ID": "CHRONOGRAPH_FRAMEWORK_GET_EXCEPTION"})
raise self.retry(exc=exc)
else:
if response.status_code != 200:
logger_method = get_task_retry_logger_method(self, logger)
logger_method(
"Unexpected status code {} while getting framework {}".format(
response.status_code, framework_id),
extra={
"MESSAGE_ID": "CHRONOGRAPH_FRAMEWORK_GET_CODE_ERROR",
"STATUS_CODE": response.status_code,
})
if response.status_code == 412: # Precondition failed
retry_kwargs = dict(**self.request.kwargs)
retry_kwargs["cookies"] = response.cookies.get_dict()
raise self.retry(countdown=0, kwargs=retry_kwargs)
elif response.status_code == 404:
if self.request.retries > CHRONOGRAPH_CHECK_MAX_RETRIES_404:
return
raise self.retry(
countdown=get_exponential_request_retry_countdown(response))
cookies = response.cookies.get_dict()
if "next_check" not in response.json()["data"]:
logger.warning(
"Skip framework {} without next_check".format(framework_id),
extra={
"MESSAGE_ID": "CHRONOGRAPH_FRAMEWORK_SKIP",
})
return
try:
response = requests.patch(
url,
json={"data": {}},
headers={
"Authorization": "Bearer {}".format(CHRONOGRAPH_API_TOKEN),
"X-Client-Request-ID": uuid4().hex
},
timeout=(CONNECT_TIMEOUT, READ_TIMEOUT),
cookies=cookies)
except RETRY_REQUESTS_EXCEPTIONS as exc:
logger.exception(
exc, extra={"MESSAGE_ID": "CHRONOGRAPH_FRAMEWORK_CHECK_EXCEPTION"})
raise self.retry(exc=exc)
else:
if response.status_code != 200:
logger_method = get_task_retry_logger_method(self, logger)
logger_method(
"Unexpected status code {} while checking framework {}".format(
response.status_code, framework_id),
extra={
"MESSAGE_ID": "CHRONOGRAPH_FRAMEWORK_CHECK_CODE_ERROR",
"STATUS_CODE": response.status_code,
})
if response.status_code == 412: # Precondition failed
retry_kwargs = dict(**self.request.kwargs)
retry_kwargs["cookies"] = response.cookies.get_dict()
raise self.retry(countdown=0, kwargs=retry_kwargs)
raise self.retry(
countdown=get_exponential_request_retry_countdown(response))
def get_edr_data(self, code, tender_id, item_name, item_id, request_id=None):
"""
request_id: is deprecated, should be removed in the next releases
"""
meta = {
'id': uuid4().hex,
'author': DOC_AUTHOR,
'sourceRequests': [],
'version': EDR_BOT_VERSION,
}
param = 'id' if code.isdigit(
) and len(code) != ID_PASSPORT_LEN else 'passport'
url = "{host}:{port}/api/{version}/verify?{param}={code}".format(
host=EDR_API_HOST,
port=EDR_API_PORT,
version=EDR_API_VERSION,
param=param,
code=code,
)
try:
response = requests.get(url,
auth=(EDR_API_USER, EDR_API_PASSWORD),
timeout=(CONNECT_TIMEOUT, READ_TIMEOUT),
headers={"X-Client-Request-ID": meta["id"]})
except RETRY_REQUESTS_EXCEPTIONS as exc:
logger.exception(exc, extra={"MESSAGE_ID": "EDR_GET_DATA_EXCEPTION"})
raise self.retry(exc=exc)
else:
meta['sourceRequests'].append(response.headers.get('X-Request-ID', ''))
try:
resp_json = response.json()
except json.decoder.JSONDecodeError as exc:
logger.warning(
"JSONDecodeError on edr request with status {}: ".format(
response.status_code),
extra={"MESSAGE_ID": "EDR_JSON_DECODE_EXCEPTION"})
countdown = get_exponential_request_retry_countdown(self, response)
raise self.retry(exc=exc, countdown=countdown)
data_list = []
if (response.status_code == 404 and isinstance(resp_json, dict)
and len(resp_json.get('errors', "")) > 0
and len(resp_json.get('errors')[0].get('description', '')) > 0
and resp_json.get('errors')[0].get('description')[0].get(
'error', {}).get('code', '') == u"notFound"):
logger.warning('Empty response for {} code {}={}.'.format(
tender_id, param, code),
extra={"MESSAGE_ID": "EDR_GET_DATA_EMPTY_RESPONSE"})
file_content = resp_json.get('errors')[0].get('description')[0]
file_content['meta'].update(meta)
data_list.append(file_content)
elif response.status_code == 200:
document_id = meta["id"]
for i, obj in enumerate(resp_json['data']):
if len(resp_json['data']) > 1:
meta_id = '{}.{}.{}'.format(document_id,
len(resp_json['data']), i + 1)
else:
meta_id = document_id
source_date = None
if len(resp_json['meta']['detailsSourceDate']) >= i + 1:
source_date = resp_json['meta']['detailsSourceDate'][i]
file_content = {
'meta': {
'sourceDate': source_date
},
'data': obj
}
file_content['meta'].update(meta)
file_content['meta']['id'] = meta_id
data_list.append(file_content)
else:
countdown = get_exponential_request_retry_countdown(self, response)
raise self.retry(countdown=countdown)
for data in data_list:
upload_to_doc_service.delay(data=data,
tender_id=tender_id,
item_name=item_name,
item_id=item_id)
def test_wrong_value_type(self):
task = Mock()
task.request.retries = 0
request = Mock()
countdown = get_exponential_request_retry_countdown(task, request)
self.assertEqual(countdown, DEFAULT_RETRY_AFTER)
def process_payment_complaint_search(self,
payment_data,
payment_params,
cookies=None,
*args,
**kwargs):
complaint_pretty_id = payment_params.get("complaint")
client_request_id = uuid4().hex
try:
response = request_cdb_complaint_search(
complaint_pretty_id,
client_request_id=client_request_id,
cookies=cookies,
)
except RETRY_REQUESTS_EXCEPTIONS as exc:
countdown = get_exponential_request_retry_countdown(self)
logger.exception("Request failed: {}, next retry in {} seconds".format(
str(exc), countdown),
payment_data=payment_data,
task=self,
extra={
"MESSAGE_ID": PAYMENTS_SEARCH_EXCEPTION,
"CDB_CLIENT_REQUEST_ID": client_request_id,
})
raise self.retry(countdown=countdown, exc=exc)
cookies = cookies or {}
cookies.update(response.cookies.get_dict())
if response.status_code != 200:
logger.warning(
"Unexpected status code {} while searching complaint {}".format(
response.status_code, complaint_pretty_id),
payment_data=payment_data,
task=self,
extra={
"MESSAGE_ID": PAYMENTS_SEARCH_CODE_ERROR,
"STATUS_CODE": response.status_code,
})
if response.status_code == 412:
raise self.retry(countdown=0,
kwargs=dict(
payment_data=payment_data,
payment_params=payment_params,
cookies=cookies,
))
countdown = get_exponential_request_retry_countdown(self, response)
raise self.retry(countdown=countdown)
search_complaints_data = response.json()["data"]
if len(search_complaints_data) == 0:
logger.warning(
"Invalid payment complaint {}".format(complaint_pretty_id),
payment_data=payment_data,
task=self,
extra={"MESSAGE_ID": PAYMENTS_SEARCH_FAILED})
if self.request.retries >= COMPLAINT_NOT_FOUND_MAX_RETRIES:
logger.warning(
"Invalid payment complaint {}".format(complaint_pretty_id),
payment_data=payment_data,
task=self,
extra={"MESSAGE_ID": PAYMENTS_SEARCH_INVALID_COMPLAINT})
return
countdown = get_exponential_request_retry_countdown(self)
raise self.retry(countdown=countdown)
search_complaint_data = search_complaints_data[0]
complaint_params = search_complaint_data.get("params")
try:
set_payment_params(payment_data, complaint_params)
except PyMongoError as exc:
countdown = get_exponential_request_retry_countdown(self)
raise self.retry(countdown=countdown, exc=exc)
logger.info("Successfully found complaint {}".format(complaint_pretty_id),
payment_data=payment_data,
task=self,
extra={"MESSAGE_ID": PAYMENTS_SEARCH_SUCCESS})
if not check_complaint_code(search_complaint_data, payment_params):
logger.info(
"Invalid payment code {} while searching complaint {}".format(
payment_params.get("code"), complaint_pretty_id),
payment_data=payment_data,
task=self,
extra={"MESSAGE_ID": PAYMENTS_SEARCH_INVALID_CODE})
return
logger.info("Successfully matched payment code {} for complaint {}".format(
payment_params.get("code"), complaint_pretty_id),
payment_data=payment_data,
task=self,
extra={"MESSAGE_ID": PAYMENTS_SEARCH_VALID_CODE})
process_payment_complaint_data.apply_async(
kwargs=dict(complaint_params=complaint_params,
payment_data=payment_data,
cookies=cookies))
def process_payment_complaint_recheck(self,
payment_data,
complaint_params,
patch_data,
cookies=None,
*args,
**kwargs):
tender_id = complaint_params.get("tender_id")
item_type = complaint_params.get("item_type")
item_id = complaint_params.get("item_id")
complaint_id = complaint_params.get("complaint_id")
client_request_id = uuid4().hex
try:
response = request_cdb_complaint_data(
tender_id=tender_id,
item_type=item_type,
item_id=item_id,
complaint_id=complaint_id,
client_request_id=client_request_id,
cookies=cookies,
)
except RETRY_REQUESTS_EXCEPTIONS as exc:
countdown = get_exponential_request_retry_countdown(self)
logger.exception("Request failed: {}, next retry in {} seconds".format(
str(exc), countdown),
payment_data=payment_data,
task=self,
extra={
"MESSAGE_ID":
PAYMENTS_GET_COMPLAINT_RECHECK_EXCEPTION,
"CDB_CLIENT_REQUEST_ID": client_request_id,
})
raise self.retry(countdown=countdown, exc=exc)
cookies = cookies or {}
cookies.update(response.cookies.get_dict())
complaint_id = complaint_params.get("complaint_id")
tender_id = complaint_params.get("tender_id")
if response.status_code != 200:
logger_method = get_task_retry_logger_method(self, logger)
logger_method(
"Unexpected status code {} while getting complaint {} of tender {}"
.format(response.status_code, complaint_id, tender_id),
payment_data=payment_data,
task=self,
extra={
"MESSAGE_ID": PAYMENTS_GET_COMPLAINT_RECHECK_CODE_ERROR,
"STATUS_CODE": response.status_code,
})
if response.status_code == 412:
raise self.retry(countdown=0,
kwargs=dict(
payment_data=payment_data,
complaint_params=complaint_params,
patch_data=patch_data,
cookies=cookies,
))
else:
countdown = get_exponential_request_retry_countdown(self, response)
raise self.retry(countdown=countdown)
else:
complaint_get_data = response.json()["data"]
if complaint_get_data.get("status") == patch_data.get("status"):
if patch_data.get("status") == STATUS_COMPLAINT_PENDING:
message_id = PAYMENTS_PATCH_COMPLAINT_PENDING_SUCCESS
else:
message_id = PAYMENTS_PATCH_COMPLAINT_NOT_PENDING_SUCCESS
logger.info(
"Successfully updated complaint {} of tender {}: {}".format(
complaint_id, tender_id, patch_data),
payment_data=payment_data,
task=self,
extra={"MESSAGE_ID": message_id})
else:
process_payment_complaint_data.apply_async(
kwargs=dict(payment_data=payment_data,
complaint_params=complaint_params,
cookies=cookies))
def process_payment_complaint_data(self,
complaint_params,
payment_data,
cookies=None,
*args,
**kwargs):
tender_id = complaint_params.get("tender_id")
item_type = complaint_params.get("item_type")
item_id = complaint_params.get("item_id")
complaint_id = complaint_params.get("complaint_id")
client_request_id = uuid4().hex
try:
response = request_cdb_complaint_data(
tender_id=tender_id,
item_type=item_type,
item_id=item_id,
complaint_id=complaint_id,
client_request_id=client_request_id,
cookies=cookies,
)
except RETRY_REQUESTS_EXCEPTIONS as exc:
countdown = get_exponential_request_retry_countdown(self)
logger.exception("Request failed: {}, next retry in {} seconds".format(
str(exc), countdown),
payment_data=payment_data,
task=self,
extra={
"MESSAGE_ID": PAYMENTS_GET_COMPLAINT_EXCEPTION,
"CDB_CLIENT_REQUEST_ID": client_request_id,
})
raise self.retry(countdown=countdown, exc=exc)
cookies = cookies or {}
cookies.update(response.cookies.get_dict())
if response.status_code != 200:
logger_method = get_task_retry_logger_method(self, logger)
logger_method(
"Unexpected status code {} while getting complaint {}".format(
response.status_code, complaint_id),
payment_data=payment_data,
task=self,
extra={
"MESSAGE_ID": PAYMENTS_GET_COMPLAINT_CODE_ERROR,
"STATUS_CODE": response.status_code,
})
if response.status_code == 412:
raise self.retry(countdown=0,
kwargs=dict(
complaint_params=complaint_params,
payment_data=payment_data,
cookies=cookies,
))
countdown = get_exponential_request_retry_countdown(self, response)
raise self.retry(countdown=countdown)
else:
logger.info("Successfully retrieved complaint {}".format(complaint_id),
payment_data=payment_data,
task=self,
extra={"MESSAGE_ID": PAYMENTS_GET_COMPLAINT_SUCCESS})
complaint_data = response.json()["data"]
if not check_complaint_status(complaint_data):
logger.warning("Invalid complaint status: {}".format(
complaint_data["status"]),
payment_data=payment_data,
task=self,
extra={"MESSAGE_ID": PAYMENTS_INVALID_STATUS})
return
if not check_complaint_value(complaint_data):
logger.info(
"Invalid complaint value amount or currency for complaint {}".
format(complaint_id),
payment_data=payment_data,
task=self,
extra={"MESSAGE_ID": PAYMENTS_INVALID_COMPLAINT_VALUE})
return
value = complaint_data.get("value", {})
if not check_complaint_value_amount(complaint_data, payment_data):
logger.warning(
"Invalid payment amount for complaint {}: {} not equal {}".format(
complaint_id, payment_data.get("amount"), value.get("amount")),
payment_data=payment_data,
task=self,
extra={"MESSAGE_ID": PAYMENTS_INVALID_AMOUNT})
process_payment_complaint_patch.apply_async(
kwargs=dict(payment_data=payment_data,
complaint_params=complaint_params,
patch_data={"status": STATUS_COMPLAINT_MISTAKEN},
cookies=cookies))
return
if not check_complaint_value_currency(complaint_data, payment_data):
logger.warning(
"Invalid payment amount for complaint {}: {} not equal {}".format(
complaint_id, payment_data.get("currency"),
value.get("currency")),
payment_data=payment_data,
task=self,
extra={"MESSAGE_ID": PAYMENTS_INVALID_CURRENCY})
process_payment_complaint_patch.apply_async(
kwargs=dict(payment_data=payment_data,
complaint_params=complaint_params,
patch_data={"status": STATUS_COMPLAINT_MISTAKEN},
cookies=cookies))
return
logger.info(
"Successfully matched payment for complaint {}".format(complaint_id),
payment_data=payment_data,
task=self,
extra={"MESSAGE_ID": PAYMENTS_VALID_PAYMENT})
process_payment_complaint_patch.apply_async(
kwargs=dict(payment_data=payment_data,
complaint_params=complaint_params,
patch_data={"status": STATUS_COMPLAINT_PENDING},
cookies=cookies))