If you’re managing SAP Vendor Invoice Management (VIM) and Capture solutions, ensuring compatibility between different software versions is critical. Open Text provides an invaluable resource—the „Orange Compatibility Matrix“—to simplify this.
What is the Orange Compatibility Matrix?
The Orange Compatibility Matrix is an essential document provided by Open Text that outlines which versions of OpenText Vendor Invoice Management for SAP Solutions (VIM) are compatible with various Open Text Capture solutions. It clearly displays supported configurations, ensuring you always pair compatible software versions to maintain system stability and optimize performance.
You’ll be directed to the article with a download link for the latest „Orange Compatibility Matrix for VIM and Capture for SAP Solutions“.
Download and refer to the matrix when planning software updates or troubleshooting compatibility issues.
Why is the Orange Compatibility Matrix Useful?
System Stability: Ensures your system operates reliably by confirming compatibility between VIM and Capture solutions.
Support Assurance: OpenText Support verifies compatibility using this matrix. Unsupported combinations are not eligible for official support, potentially leaving your organization without assistance during critical issues.
Simplifies Upgrade Planning: Clearly see what combinations of VIM and Capture solutions are certified to work together.
Regularly checking the Orange Compatibility Matrix will keep your SAP VIM environments running smoothly.
This article is intended for informational purposes only and does not supersede or replace the official documentation provided by OpenText. It serves as supplementary guidance to assist with common challenges that may arise during installation and upgrades. For authoritative instructions and compliance requirements, refer to OpenText’s official documentation.
The capture component used in conjunction with OpenText Vendor Invoice Management for SAP Solutions (SAP VIM) is usually Intelligent Capture for SAP Solutions (short: IC4S; on premise) or Core Capture for SAP Solutions (short: CC4S; hosted in the OpenText Cloud).
Continuous feedback allows the capture component of VIM to read and interpret more and more incoming .pdf-documents fully or partly. In some systems, however, it is simply never switched on. As a result, the automatic recognition of data on the documents never improves and a high manual validation effort is required. This is not only annoying but also expensive.
How does the learning work?
In simple terms, the process for continuous learning works like this:
The system (IC4S or CC4S) extracts as much data as possible from the document
The extracted data is corrected and supplemented by users in the validation client.
The corrected results are sent back to the capture component via the so-called feedback link, which expands the set of rules for extracting data and generally delivers a better result for the next similar document.
What is an Archive Link Document Type?
An Archive Link Document Type refers to a classification used for documents that are stored in an external archive system but linked to SAP transactions via SAP ArchiveLink. ArchiveLink is an SAP technology that enables the connection of external document management systems (DMS) to SAP applications.
In the simplest case, there is one archive link document type in a VIM project for storing, for example invoices, let’s call it “ZINVOICE”. Whether the learning is executed or not depends on the settings assigned for this archive link document type.
In VIM projects, usually one or more archive link document types are created for both invoicing and non-invoicing processes. These allow you to create your own scenarios independently of the document types supplied with the product.
My recommendation here is always to create your own archive link document types. This makes customization easier and you don’t run the risk of accidentally resetting all possible settings during the next VIM upgrade. However, this also opens the door for the customizing mistake which I describe in this article.
Is my system learning or is it standing still?
You can find out in just a few minutes whether your system is learning, or at least is encouraged to learn (in addition to this setting, there are also other reasons that can prevent learning).
First we find out which Archive Link document type we are using, the quickest way to do this is in transaction /OTX/PF03_WP (VIM Central Workplace) in the work center Inbound administration.
/otx/pf03_wp
Select the „Processed“ note and select the line of a recently processed document.
In the line you can scroll to the right until you see the column „Document type“. Note all the Document types you are using. For example „ZINVOICE“.
The next step ist to check the customizing in /OTX/PF00_IMG.
/otx/pf00_img
Navigate to Inbound Configuration > Capture > Feedback:
In the table you should see all active archive link document types you are using with an active checkbox next to them:
In case you archive link document type is missing here there will be no learning taking place after validating documents. This means that your validation process does not generate a sustainable learning effect but is only valid for the current document.
My learning is not activated, how do I solve the problem?
The problem is quickly solved. Add the missing entry in the development system, test, transport and the issue is resolved (learning will only take place for newly processed documents).
Why didn’t we realize this earlier?
In the case of non-invoice-related document processes, the problem is usually immediately apparent because without learning results, not a single field (with the exception of business entities) is recognized and therefore an exorbitantly high validation effort is required.
The situation is different for invoice-related processes, where the product standard already provides basic recognition results, which are then improved by validation. Therefore you already have a basis of recognition results and do not initially notice that the feedback is missing.
Conclusion
This setting is very simple but unfortunately easy to overlook. The system does not complain about the missing setting and everything initially appears to be working. If this article has helped you to resolve a big problem in a simple way, I would be happy if you share it!
This article is intended for informational purposes only and does not supersede or replace the official documentation provided by OpenText. It serves as supplementary guidance to assist with common challenges that may arise during installation and upgrades. For authoritative instructions and compliance requirements, refer to OpenText’s official documentation.
A data enrichment is a logic or learning based data manipulation which can run, for example, at the begin of a process. From a usage point it is very comparable with a logic module in the VIM Invoice process.
Please note that this article is not about the VIM Invoice process but VIM Solutions Beyond Invoice which is, for example, used to process sales orders, quotations, remittance advices, order confirmations or fully custom document processes (including capture & recognition using OpenText Intelligent Capture for SAP Solutions [IC4S]).
To be precise, Solutions Beyond Invoice describes the supplied solution packages, while the Foundation describes the creation of customised solutions, actions, rules and so on. For the sake of simplicity, I will refer to both as Solutions Beyond Invoice.
VIM Solutions Beyond Invoice is formerly known as Business Center and sometimes referred to as VIM Beyond.
In earlier versions, data was changed with the help of business rules. This is becoming obsolete today and should therefore be avoided. Business rules check data, data enrichments change data. It is easy to convert old business rules into data enrichments.
Creating a data enrichment ABAP class
The initial step in this process is to create a new class that is both appropriately named and described, while adhering to the relevant naming conventions. You case use for example SE24 or SE80 to achieve this.
It is essential to add the correct interface for data enrichments. In the version I am working with, this is /OTX/PF04_IF_DATA_ENRICH_EX.
/OTX/PF04_IF_DATA_ENRICH_EX
The implementation is carried out in method /OTX/PF04_IF_DATA_ENRICH_EX~DATA_ENRICH_LOGIC.
/OTX/PF04_IF_DATA_ENRICH_EX~DATA_ENRICH_LOGIC
I use the following minimalist template for my projects. It already declares the structures, table and field symbol which are needed for processing header and line information. In addition, the success marker is set, if you forget this, the data enrichment is not even executed.
As the naming conventions for variables and the tables used change from project to project, I recommend creating this template once for each project.
If the data enrichment is only executed at the start of the process, it will be helpful to use a debug loop. But beware: If only the VIM Solutions Beyond Invoice Invoices solution is used in the system, but not the packages for invoice processing, a custom debug table in the style of /opt/cp_debug must be created.
ABAP TYPE […]_pli. “ line item table
lt_pli = pct_item.
* ls_plh = pcs_head.
pe_success = ‚X‘.
LOOP AT lt_pli ASSIGNING .
[…]
ENDLOOP.
IF pe_success = ‚X‘.
* pcs_head = ls_plh. “ update header information
pct_item[] = lt_pli[]. “ update item information
ENDIF.
ENDMETHOD.“ style=“color:#657B83;display:none“ aria-label=“Copy“ class=“code-block-pro-copy-button“>
METHOD/otx/pf04_if_data_enrich_ex~data_enrich_logic.* Optional: Debug loopDATA: ls_plh TYPE [...]_plh, " header table lt_pli TYPE TABLE OF [...]_pli, " line item table ls_msg TYPE bapiret2.FIELD-SYMBOLS: TYPE [...]_pli. " line item table lt_pli = pct_item.* ls_plh = pcs_head. pe_success ='X'. LOOP AT lt_pli ASSIGNING. [...] ENDLOOP. IF pe_success ='X'.* pcs_head = ls_plh. " update header information pct_item[] = lt_pli[]. " update item information ENDIF.ENDMETHOD.
Whenever data is changed, I recommend issuing a helpful and transparent message to users so that they know what has been changed and why. Here is an example of what such a message could look like in the code. You can of course also assemble the messages (ls_msg) manually, but I find the option mentioned here easier to read.
ABAPmessage_return_build
EXPORTING
pi_type = ‚S‘ “ „S“ = Success / „E“ = Error / „I“ = Info
pi_cl = ‚Z…‘ “ name of your message class
pi_number = 019 “ your message number.
pi_par1 = “ message parameter 1
pi_par2 = “ message parameter …
“ […]
IMPORTING
pes_return = ls_msg.
APPEND ls_msg TO pet_return.“ style=“color:#657B83;display:none“ aria-label=“Copy“ class=“code-block-pro-copy-button“>
DATA ls_msg TYPE bapiret2." [...]CALLMETHOD /otx/pf02_cl_error_message=>message_return_buildEXPORTING pi_type ='S'" "S" = Success / "E" = Error / "I" = Info pi_cl ='Z...'" name of your message class pi_number =019" your message number. pi_par1 =" message parameter 1 pi_par2 =" message parameter ..." [...]IMPORTING pes_return = ls_msg.APPEND ls_msg TO pet_return.
Customizing for a SAP VIM Solutions Beyond Invoice Data Enrichment
Now we have created the class for our data enrichment and still have to create the corresponding customising, which can be done very quickly in the transaction /otx/pf00_img.
/otx/pf00_img
Navigate to Process Configuration > Profiles:
Select your Profile Configuration and navigate to the corresponding Version Definition and then Data Enrichment Configuration. Here you can now create a Data Enrichment ID with a speaking name and description.
The enrichment point decides when a data enrichment should be executed. For my example I select ALL to execute it at all enrichment points.
Even if a data enrichment should only run at the beginning of the process, I like to use ALL at the beginning of my implementation because the jump to the debugger is super quick. Simply set a breakpoint in the class, execute the Enrich Data action and you are already in the ABAP Debugger and can analyse if everything is working according to plan.
The last step is often forgotten in data enrichments because it was not necessary in earlier versions. The newly created Data Enrichment ID must still be assigned to the corresponding Characteristics Configuration and given a sequence.
I have created a data enrichment but it is not working
If your data enrichment does not work, please check the following points:
Is the success marker pe_success returned with true (‘X’)?
Is the newly created Data Enrichment Configuration active? There is a checkbox on the far right which can easily be overlooked.
Have you perhaps overlooked the last point Assign Data Enrichments?
Perhaps your debug loop can help you here? If this is not activated, this can also be a finding.
Conclusion
When using SAP VIM Solutions Beyond Invoice, there is no getting round the use of data enrichments. Only with these can the process be properly tidied up and optimised.
Don’t forget to issue transparent and helpful messages for the users and make sure that the data enrichments run in a sensible sequence.
This article is intended for informational purposes only and does not supersede or replace the official documentation provided by OpenText. It serves as supplementary guidance to assist with common challenges that may arise during installation and upgrades. For authoritative instructions and compliance requirements, refer to OpenText’s official documentation.
When upgrading or installing OpenText Vendor Invoice Management for SAP Solutions (SAPVIM), it is often necessary to activate so-called BC Sets (Business Configuration Sets). A BC Set (Business Configuration Set) in SAP is a tool that allows users to store, manage, and transport configuration settings efficiently. It acts as a template for predefined customizing settings that can be applied to an SAP system, ensuring consistency and reducing manual effort in system configuration.
Check all the available documentation before starting with the activation
Compiling a list of the necessary BC Sets and activating them in the correct order can be challenging, especially given the current state of the VIM documentation.
To ensure a smooth process, it is essential to not only refer to the Installation Guide but also carefully review the Configuration Guides and Release Notes. Also refer to the documentation for all service packs included in the upgrade, not only the latest one.
Never forget to export the table comparison
One of the most critical steps when performing an upgrade—especially in complex SAP environments—is to conduct a thorough comparison between the BC Set and the existing table contents before activation. This step ensures that no essential configurations are overwritten, lost, or modified unexpectedly, which could lead to system inconsistencies or functional disruptions.
During an upgrade, new BC Sets introduced by OpenText may contain updated settings that enhance functionalities or align with new system requirements. However, they may also overwrite existing custom configurations, potentially impacting workflows, document processing, or approval rules. A careful comparison allows you to identify discrepancies, retain necessary custom settings, and selectively adopt only the relevant changes.
To prevent accidental data loss, it is highly recommended to create a complete backup of the table contents before making any modifications. This backup acts as a safety net, allowing you to restore previous configurations if unexpected issues arise during or after the activation of new BC Sets.
Taking the time to perform this verification process not only safeguards critical system settings but also minimizes downtime and troubleshooting efforts in case of unintended changes. In the following section, we will go through the exact steps to compare BC Sets with table contents and securely back up configurations before proceeding with the upgrade.
Exporting the SCPR20 table comparison to .html (without cutting off important tables by mistake)
Entering the comparison in SCPR is easy by clicking on the button below:
The displayed list usually shows you all the data which is different (yellow) or new (green).
In general, the export of the table comparison is often forgotten. However, if the export is carried out, there is another pitfall that should not be overlooked, otherwise data may be lost. We have to go into the output options for this.
The output width is set to 150 by default, increase the number to 800. if tables, labels and content exceed 150 characters, they will otherwise be cut off and important information may be lost. Please also check whether 800 is sufficient here, I have not noticed any data loss in the exported files with this number. Do not change anything else in these settings.
Now that we have prevented the file from being truncated, we can continue with the export. To do this, we go to List, Save/send and then to File.
I prefer to save the comparison files as .html. This is small, clear and universally applicable. In addition, I don’t have to worry about Microsoft Excel versions and separators.
For the file name I recommend using the BC Set name with „/“ replaced by „_“. Also creating a folder per service pack level does help to keep the overview. I also recommend to replace the suggested .htm with .html. At least on my computer this helps with directly opening in my browser on double click.
The export gives you a .html file which is lightweight and provides a very good overview. I recommend storing all the BC-Set comparisons together with your documentation. This is applicable for every single BC-Set in every service pack level.
If you have paid very close attention, you will notice that in the screenshot above the BC sets of VIM 7.6 SP 5 are compared with the table contents of VIM 7.6 SP 6. This is of course not a realistic scenario and the BC sets should never be activated as shown in the comparison.
One of the main reasons I prefer using .html as an export format is that it allows for seamless copying and pasting into Excel while preserving the structure and formatting of the data. Unlike plain text or CSV files, which may require additional adjustments, HTML tables often retain proper column alignment, making the data immediately usable for further processing, analysis, or reporting in Excel. This method helps avoid common issues like misaligned columns, missing delimiters, or incorrect data types, ensuring a smooth workflow when handling exported information.
Conclusion
This may seem like a lot of effort, but failing to carefully verify BC Sets before activation can lead to serious issues. If a BC Set overwrites an important configuration, and you only realize it after deploying transport requests into the production system, it becomes extremely difficult to trace back what was changed and when. At that point, identifying the root cause of the issue can be time-consuming and complex, often requiring manual comparisons, system rollbacks, or troubleshooting unexpected system behavior. Taking the time to perform a thorough review and backup beforehand can save countless hours of debugging and help avoid disruptions in critical business processes.
With that in mind, I hope this guide helps make your VIM upgrade process smoother and more efficient. Wishing you great success with your upgrade.
When analysing problems in OpenText Vendor Invoice Management for SAP Solutions (SAP VIM), depending on the system architecture and authorisations, there are parts of the source code that are very difficult to access with the ABAP debugger. This is the case, for example, with data enrichments (e.g. logical modules) executed by a background user at the start of the process.
A debug loop is an endless loop in the code which you can activate when required. The infinite loop allows you to find and debug the running code in the process monitor.
Adding a debug loop to your ABAP code
In order to be able to use a debug loop, it is first necessary for it to exist. This is the case in many parts of the product standard, but should not be forgotten in custom developments either. A debug loop can look like this, for example:
ABAP
DO. SELECTSINGLEvalueFROM /opt/cp_debug INTO @DATA(lv_debug) WHERE debugarea ='Z_LOGIC_MODULE'. " keep text below 20 chars IF lv_debug ISINITIAL. EXIT. ENDIF. ENDDO.
Activating a debug loop using the ABAP Editor SE38
The table /opt/cp_debug has some advantages over self-built tables. It is used in the product standard and the loop can be activated and deactivated with the ABAP Editor (SE38) using the program /OPT/VIM_DEBUG.
If a debugging area is activated, the system remains in an infinite loop until it is deactivated again or until the infinite loop is exited manually in the debugger.
But be careful, the debug loop runs for all users on the system, so this tool should only be used with caution. In the production system only in absolutely exceptional cases and only for a short time in consultation with the system supervisor.
Some consultants even comment out the coding for debug loops before productive operation, but I find that the possibility of debugging in the P system can be a great advantage for tracking down tricky errors.
Tip: As you often spend a long time in the code when debugging, I suggest that the debugging loop is always exited via /OPT/VIM_DEBUG. This way you cannot forget to deactivate the loop.
Starting the debugger in Work process overview (SM50)
If your debug loop is active, you are ready to go: Provoke the system to run the loop, for example by processing a new document.
As soon as the corresponding line in the source code is run through, the process stops and we have the opportunity to jump to the debugger, for which we use the transaction code SM50.
To make it easy to find our process, we switch to the Active Work Processes view.
If you cannot find your process, have a look at the System-Wide List. The process you are looking for may be running on a different application server.
Now we can select our process and start it via Administration > Program > Debugging in the ABAP Debugger and eliminate the error.
Do you have any tips or best practices for dealing with debug loops in ABAP? Let us know in the comments!
Stop training the system incorrectly and finally get what you hoped for from the capture component of VIM.
⋆⋆⋆⋆⋆
„Highly recommended to any OT consultant. Informative, precise and quick.“ – Dana K.
As an SAP VIM consultant, I have analysed OpenText’s capture products and the associated validation in numerous projects around the world. Over the course of time, I have noticed numerous points that are misunderstood, done incorrectly and often set up incorrectly.
In some cases, the training does not work because the training is wrong or because different users train differently and thereby confuse the system. In some cases, the training does not work because the training was simply forgotten to be activated or because it does not work for technical reasons. Whatever the reason, the situation is disappointing for users, project management, IT and management. The potential of the solution cannot be realised and the question is why. Interested in some answers?
In this course you will learn how to use the Validation Client to train the system properly and sustainably without doing the same thing over and over again.
Do any of the following problems sound familiar?
The system doesn’t feel like it learns anything, even though the same layout has already been trained 4 or more times
Suppliers, customers, company codes and other business entities have to be re-learnt for each document without the system learning anything.
The system does not recognise line data at page breaks and does not learn.
Some values can not be trained correctly in the validation client as they stand too close to other information
You have a document which needs to be validated all the time even tough it gets extracted perfectly every time
Learn the basics of the Validation Client and how to train documents quickly and easily and achieve improved training results.
In a nutshell: Who am I, where do I live (perhaps you can already guess from my accent), what do I do, what is my background and why can I help you?
Official Manuals
This may sound boring at first, but it can quickly and easily lead to better results, usually free of charge. In this chapter, I will briefly explain how you can access the official product documentation, download it in .pdf format and share it with the team if this is not already the case.
Depending on whether your solution was purchased through SAP or OpenText, the path will look slightly different, but I’ll show you how to do it.
Using the Validation Client
We start with the absolute basics with dos and donts and best practice approaches. This will give every new user a kickstart and experienced users will learn some important subtleties.
We’ll explain why you should never mix head and position training data again.
With challenging formats and line breaks, we’ll look at how to validate most effectively and how to save a lot of work when entering tables.
There are many misunderstandings when identifying business entities (e.g. company codes, suppliers, customers, etc.). Often the correct business partner is selected in the validation client but the system never seems to learn. There is a reason for this!
In some cases you validate documents with excellent recognition results over and over again … that does not have to be! There are ways and means of reducing the validation effort step by step. Step one however is correct training.
Administration
Administrators, but also key users and interested validators can find a lot of background information in the Inbound Administration, a sub-item in the VIM Central Workplace (/OTX/PF03_WP). For example, what does the email from which this document originates look like? Why can’t I find my document?
In some cases it makes sense to reset the learning results for a specific document layout. With all newer versions this can be done quickly and easily (but not necessarily intuitively). In most cases, the reset is done by IT while the business department recognizes when a layout should be reset. I’ll show you how to build effective communication to start from scratch when it makes sense.
Finally, we’ll look at how to actually assign edits to specific documents for validation. And that without a transport request. We will also look at the possibilities for advanced processing.
