Purpose

This method allows to sign a draft of Composition of all types and categories. The final goal of the task is to sign the draft after checking the signed content match, signer match and signature overlay check.

Used in processes:

2.1. МВН - Створення нового

2.2. МВТН - Створення нового

3. Скасування (загальний процес)

5. Продовження / скорочення МВТН

6. Уточнення (preperson -> person) для МВТН

RC_7. Створення МВ “на заміну”

Specification

Link	https://app.swaggerhub.com/apis/ehealthua/compositions/2.32.2#/main/signComposition
Resource	/patients/composition/{compositionId}/sign
Scope	composition:sign
Components	Compositions
Using Dictionaries	eHealth/resources
Using Microservices	API paragraph not found
Protocol type	REST
Request type	PATCH
Sync/Async	Async
Public/Private/Internal	Public

Logic

Sequence:

MIS/Medical employee->Compositions: Create Composition POST/patients/composition
Compositions->Compositions: Check user scopes authorization composition:create
Compositions-->MIS/Medical employee: In case of error HTTP/401
Compositions->Compositions: Async job planning
Compositions->MIS/Medical employee: Async job details
Compositions<->eHealth:data clarification and verification about author, custodian, diagnosis etc
Compositions->Compositions:Create and save Composition according to the XML template
Compositions->Compositions:Async job Completed
MIS/Medical employee->Compositions: GET/patients/composition/job/{asyncJobId}
Compositions->MIS/Medical employee:Async job completed (conclusionAsyncJobListItem.href)
MIS/Medical employee->Compositions:GET/patients/{patientId}/composition/{compositionId}/episode/{episodeId}/encounter/{encounterId}
Compositions->MIS/Medical employee: Composition in PRELIMINARY status
MIS/Medical employee->MIS/Medical employee:Signs document and gives to patient
MIS/Medical employee->Compositions:Sign Composition PATCH /patients/composition/{compositionId}/sign
Compositions->Compositions:Check user scopes authorization composition:sign
Compositions-->MIS/Medical employee: In case of error HTTP/401
Compositions->MIS/Medical employee: HTTP/200 Async job Created
Compositions<->eHealth:Signature and author validation
Compositions->Compositions:Save object on SWIFT/S3
Compositions->Compositions:Schedule of trigger interactions (DIIA,MJU_DRACZ,ERLN,MPI,Closure)
MIS/Medical employee->Compositions:GET /patients/composition/job/{asyncJobId}
Compositions->MIS/Medical employee:Async job completed (conclusionAsyncJobListItem.href)
MIS/Medical employee->Compositions:GET/patients/{patientId}/composition/{compositionId}/episode/{episodeId}/encounter/{encounterId}
Compositions->MIS/Medical employee:Composition in FINAL status

Input parameters

Input parameter

Values

Type

Description

Example

compositionId

String ($uuid)

(path)

Composition object ID

4fd87fa2-1beb-44ff-a7cc-c1759e1c6e9b

Request structure

See on SwaggerHub

Request body

Request body with signed Composition. Signed content must match the existing Composition object

Example

Request body example

{
    "data": "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"
}

Authorize

Check user scopes in order to perform this action (scope = 'composition:sign')

return 401 (Unauthorized) in case of invalid scope(s)

Headers

Content-Type: application/json
Authorization: Bearer {token}
api-key: {secret}

Validation data request

Checking the existence of other Composition tasks for signing
1. Search in task_queue other tasks with SIGN_COMPOSITION type and status isn’t FAILED
  1. In case of error (such task is found) - return 1142 (ANOTHER_SIGN_TASK_ALREADY_EXIST)
Checking the signing delay
1. If signing time does not match with value in EMAL_FILTER_SIGN_CREATE_DELAY_DISABILITY, EMAL_FILTER_SIGN_CREATE_DELAY_NEWBORN - return 1124 (CREATE_SIGN_DELAY_EXCEEDED)
Verification of signature overlay
1. The body of the signature in the request transfers to the DS service by RPC method “decode_signed_content”
  1. If service:
    1. Returned a null field “content” - return error 1019 (SIGVER_FAILED_NO_PAYLOAD) with explanation "content is null or blank"
    2. Did not return a response (or returned a response of an inappropriate structure) - return error 1099 (SIGVER_FAILED_BAD_CONTENT)
    3. Returned any value in the "validation_error_message" field - return error 1020 (SIGVER_FAILED_BAD_CERT)
    4. Did not return any signature - return error 1021 (SIGVER_FAILED_NO_SIGNATURES)
    5. Returned several signatures - return error 1022 (SIGVER_FAILED_MULTIPLE_SIGNATURES)
2. For every signatures that were overlayed
  1. Check the value of the "is_valid field" in the RPC service response
    1. If there is at least one invalid signature - return 1023 (SIGVER_FAILED_INVALID_SIGNATURE)
Validation of signed content
1. Checks the status of the signing object
  1. If the status is not equal to PRELIMINARY - return error 1041 (CANT_SIGN_NON_PRELIMINARY_COMPOSITION)
2. Checks the content in the signed object and compares it to the Composition object
  1. If the content does not match - return 1042 (SIGNING_CONTENT_MISMATCH)
Signer Check. The application receives information about the signer from the certificate of qualified electronic signature from the service (the value of the field corresponding to the RNOCPP(individual tax number) from the certificate)
1. Сompliance check RNOCPP (individual tax number) with data specified in the employee profile (Composition.author)
  1. If employee.party.no_tax_id == true then it is verified that the value of DRFO corresponds to at least one of the documents for employee.party. The rules of transliteration of letters are applied for comparing
    1. If a match isn't found - return 1024 (SIGVER_FAILED_DOCUMENTS_DONT_MATCH)
  2. In all other options - check that the employee.party.tax_id value is equal to the DRFO field in the signer's certificate
    1. if the fields are not equal - return 1025 (SIGVER_FAILED_DRFO_DOESNT_MATCH)

Processing

Checking the existence of other Composition tasks for signing. Logic - to check if there are other tasks in the system for the same Composition waiting for signature verification. Such a procedure is necessary to prevent several parallel requests for signing the same Composition.
Checking the signing delay: Check that allowed delay time between the creation of the draft and the direct signing of the Composition match with current configuration.
Verification of signature overlay: Checks that the signature is overlaid correctly and the signature is valid
Validation of signed content: checks that the signature was applied to the corresponding Composition’s object record without any modifications after creating the draft
Signer Check: Checks the data in the signature certificate against the author data according to Composition.author and Employee data
Checking the related Composition: Check that specified in relatesTo Composition exists and has an appropriate status
Status update: Changes the Composition status in the database and related Composition’s status (in case of refinement Temporary Disability Composition)
Saving Composition: Saves the data of the signed Composition in the object drive (ceph)
For Temporary Disability Composition (for tasks that were successfully completed at this stage): Planning CREATE ERLN RECORD task (in PENDING status)

Response structure

See on SwaggerHub

Example:

Response example

{
  "data": {
    "eta": "2023-01-17T13:55:12.733Z",
    "id": "0b61fe9e-1841-43ef-9108-e8b43a0fa18e",
    "links": [
      {
        "entity": "eHealth/resources",
        "href": "composition/8c696fa4-6607-4aef-bab7-33cabc2dda2c"
      }
    ],
    "status": "PENDING"
  }
}

Post-processing processes

API paragraph not found

HTTP status codes

HTTP status code	Message	What caused the error
200	In the case of successful creation of the task of signing the Composition
400	Invalid request format
401	Unauthorized	In case of invalid scope(s)
500	Subordinate service error	Service error

signComposition