Accessing Documents

val toUpload = DocumentToUpload(
    imagePath = imageFile.absolutePath,
    documentType = DocumentType.RECEIPT
)

final DocumentToUpload toUpload = new DocumentToUpload(
    imageFile.getAbsolutePath(),
    DocumentType.RECEIPT,
    null,
    null
);

val documentsTools = SensibillSDK.headlessTools.documentsTools
val uploadManager = documentsTools.uploadManager

final DocumentsTools documentsTools = SensibillSDK.getInstance().getHeadlessTools().getDocumentsTools();
final DocumentUploadManager uploadManager = documentsTools.getUploadManager();

// Create a list of documents to upload
val documentsToUpload = listOf(toUpload)

lifecycleScope.launch(Dispatchers.IO) {
    // Results are Triple<LocalId(Long), DocumentToUpload, PassedValidation(Boolean)>
    val results = uploadManager.saveAndUploadDocuments(
        context = context,
        documentsToUpload = documentsToUpload
    )
}

// No Java example yet - need workaround for coroutine interoperability issue

capturedImages is List<BareCapturedReceiptData>
val documentsToUpload = capturedImages.map {
    DocumentToUpload(it.receiptFile.absolutePath, DocumentType.RECEIPT)
}

// Continue upload as normal

ArrayList<DocumentToUpload> documentsToUpload2 = new ArrayList<>();
for (BareCapturedReceiptData capturedImage : capturedImages) {
    documentsToUpload2.add(new DocumentToUpload(
            capturedImage.getReceiptFile().getAbsolutePath(),
            DocumentType.RECEIPT,
            null,
            null
    ));
}

// Continue upload as normal

val toUpload = DocumentToUpload(
    imagePath = imageFile.absolutePath,
    documentType = DocumentType.RECEIPT,
    externalAccountTransactionId = "someTransactionId",
    accountId = "someAccountId"
)

final DocumentToUpload toUpload = new DocumentToUpload(
        imageFile.getAbsolutePath(),
        DocumentType.RECEIPT,
        "someExternalAccountTransactionId",
        "someAccountId"
);

// ========== Static Observer ==========
private val observer = DocumentUploadObserver.fromLambda { update ->
    // handle update as desired
}

// After starting the SDK
fun startObservingDocuments() {
    SensibillSDK.addDocumentUploadObserver(observer)
}

// Before stopping the SDK
fun stopObservingDocuments() {
    SensibillSDK.removeDocumentUploadObserver(observer)
}

// ========== Observe from an Activity ==========
class TempActivity : ComponentActivity() {
    private val observer = DocumentUploadObserver.fromLambda(this::onDocumentUploadUpdate)

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContent { DefaultPreview() }
        SensibillSDK.addDocumentUploadObserver(observer)
    }

    override fun onDestroy() {
        super.onDestroy()
        SensibillSDK.removeDocumentUploadObserver(observer)
    }

    private fun onDocumentUploadUpdate(update: DocumentUploadUpdateData) {
        // handle update as desired
    }
}

// ========== Static Observer ==========
public class SensibillSDKManager {
    private static DocumentUploadObserver documentUploadObserver = new DocumentUploadObserver() {
        @Override
        public void notify(@NonNull DocumentUploadUpdateData update) {
            // handle update as desired
        }
    };

    // After starting the SDK
    public static void startObservingDocumentUpdates() {
        SensibillSDK.getInstance().addDocumentUploadObserver(documentUploadObserver);
    }

    // Before stopping the SDK
    public static void stopObservingDocumentUpdates() {
        SensibillSDK.getInstance().removeDocumentUploadObserver(documentUploadObserver);
    }
}

// ========== Observe from an Activity ==========
public class TempActivity extends AppCompatActivity {

    private DocumentUploadObserver documentUploadObserver = new DocumentUploadObserver() {
        @Override
        public void notify(@NonNull DocumentUploadUpdateData update) {
            onDocumentUpdate(update);
        }
    };

    @Override
    protected void onCreate(@Nullable Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        SensibillSDK.getInstance().addDocumentUploadObserver(documentUploadObserver);
    }

    @Override
    protected void onDestroy() {
        super.onDestroy();
        SensibillSDK.getInstance().removeDocumentUploadObserver(documentUploadObserver);
    }

}

private val observer = DocumentUploadObserver.fromLambda { update ->
    // The `localId` will be provided in the return value of `DocumentUploadManager.saveAndUploadDocuments`
    // and will remain unique and consistent throughout a document's uploading and processing process.
    // This id only exists on device and can be used for tracking a document during the upload process.
    val localId = update.localId

    // The `documentId` is determined by the server, and will be available when the status is at least `UPLOADED`.
    // Once a `documentId` exists, changes can be made to the document.  Also, after processing the document will
    // retain its `documentId` and it can be used to reference the document forevermore
    val documentId = update.documentId

    // The `status` part of the update contains the most up to date state of the document in its uploading and
    // processing process.  They can be handled in any way, however the most important states are the final states.
    // Three for various failure states, and one for a "fully uploaded and processed" success state.
    // See the linked reference documentation for details on the flow of states, and explanations on what each
    // state means.
    when (val status = update.status) {
        // Upload/processing in progress
        DocumentStatus.INITIALIZED -> TODO()
        DocumentStatus.UPLOADING -> TODO()
        DocumentStatus.UPLOADING_PAUSED_NO_INTERNET -> TODO()
        DocumentStatus.UPLOADED -> TODO()
        DocumentStatus.UPLOAD_FAILED_RECOVERABLE -> TODO()
        DocumentStatus.POLLING -> TODO()
        DocumentStatus.POLLING_TIMED_OUT -> TODO()
        DocumentStatus.POLLING_PAUSED_NO_INTERNET -> TODO()
        // Permanent Failure
        DocumentStatus.UPLOAD_FAILED_UNRECOVERABLE -> TODO()
        DocumentStatus.REACHED_MAX_RETRY_COUNT -> TODO()
        DocumentStatus.PROCESSED_FAILED -> TODO()
        // Document uploaded and processed
        DocumentStatus.PROCESSED_SUCCESS -> TODO()
    }
}

private DocumentUploadObserver documentUploadObserver = new DocumentUploadObserver() {
    @Override
    public void notify(@NonNull DocumentUploadUpdateData update) {
        // The `localId` will be provided in the return value of `DocumentUploadManager.saveAndUploadDocuments`
        // and will remain unique and consistent throughout a document's uploading and processing process.
        // This id only exists on device and can be used for tracking a document during the upload process.
        final long localId = update.getLocalId();

        // The `documentId` is determined by the server, and will be available when the status is at least `UPLOADED`.
        // Once a `documentId` exists, changes can be made to the document.  Also, after processing the document will
        // retain its `documentId` and it can be used to reference the document forevermore
        final String documentId = update.getDocumentId();

        // The `status` part of the update contains the most up to date state of the document in its uploading and
        // processing process.  They can be handled in any way, however the most important states are the final states.
        // Three for various failure states, and one for a "fully uploaded and processed" success state.
        // See the linked reference documentation for details on the flow of states, and explanations on what each
        // state means.
        final DocumentStatus status = update.getStatus();
        switch (status) {
            // Upload/processing in progress
            case INITIALIZED:
                break;
            case UPLOADING:
                break;
            case UPLOADING_PAUSED_NO_INTERNET:
                break;
            case UPLOADED:
                break;
            case UPLOAD_FAILED_RECOVERABLE:
                break;
            case POLLING:
                break;
            case POLLING_TIMED_OUT:
                break;
            case POLLING_PAUSED_NO_INTERNET:
                break;
            // Permanent Failure
            case UPLOAD_FAILED_UNRECOVERABLE:
                break;
            case REACHED_MAX_RETRY_COUNT:
                break;
            case PROCESSED_FAILED:
                break;
            // Document uploaded and processed
            case PROCESSED_SUCCESS:
                break;
        }
    }
};

val documentsTools = SensibillSDK.headlessTools.documentsTools
val dataProvider = documentsTools.dataProvider

final DocumentsTools documentsTools = SensibillSDK.getInstance().getHeadlessTools().getDocumentsTools();
final DocumentDataProvider dataProvider = documentsTools.getDataProvider();

val dataProvider = SensibillSDK.headlessTools.documentsTools.dataProvider

lifecycleScope.launch(Dispatchers.IO) {
    // ========== Fetch document list ==========
    val listResult = dataProvider.getDocumentList(DocumentListRequestParams())

    // `DataProvider` return values will almost always come in the form of a `DataProviderResponse`.
    // These sealed classes will make it easy to identify if the call has failed or succeeded, and in
    // each case the relevant data is easily extracted.
    val documentList: List<DocumentListItem>? = when (listResult) {
        is DataProviderResponse.Success -> {
            // In the success case, the resulting object is available at `.responseObject`
            val documents = listResult.responseObject.documents

            // Return the list of documents to be used
            documents
        }
        is DataProviderResponse.Failure -> {
            // In the failure case, the reason for failure can be extracted and acted upon accordingly.
            val cause = listResult.failReason

            // Failure reasons always extend `RequestError`, which itself extends `Exception` and can be
            // thrown if execution should stop on a failed request.
            if (shouldThrowOnFail) {
                throw cause
            }

            // There are a number of `RequestError` subclasses that convey additional information about the
            // cause of the request failure.  Viewing the "Inheritors" tab of the reference documentation
            // for `RequestError` will provide details into each subclass
            if (cause is Http404Error) {
                // In this case, the requested resource was not found
            }

            // If deeper investigation or detail is required, `RequestError` carries some extra information.
            // This includes a string summary of the request itself
            val requestSummary = cause.requestSummary
            // As well as access to the raw retrofit response object
            val rawResponse: Response<*>? = cause.response

            // Return null as there is no resulting list of documents at this point
            null
        }
    }


    // ========== Fetch a filtered document list ==========
    // All results where the total is above 5 units
    val params = DocumentListRequestParams(
        filters = DocumentListRequestParams.Filters(
            totalGte = BigDecimal(5)
        )
    )
    val filteredListResult = dataProvider.getDocumentList(params)
    // Handle result...


    // ========== Update a Document ==========
    val updatePayload = EditDocumentBody(/* Created with desired document properties... */)
    val updateResult = dataProvider.editDocument("documentId", updatePayload)
    // Handle result...


    // ========== Delete a Document ==========
    val deleteResult = dataProvider.deleteDocuments("docId1", "docId2")
    // Handle result...
}