# InsureMO ICS Introduction ## What is InsureMO ICS? InsureMO Insurance Common Services (ICS) provides foundational capabilities essential for developing insurance services and applications. ### Core Capabilities * **Adaptable and Scalable:** A metadata-driven design and microservices architecture enable easy adaptation to evolving requirements and the ability to scale for increased demands. * **Comprehensive Feature Set:** ICS offers a rich set of features, including meta-modeling (DD), internationalization (i18n), configurable tables (iTables), user role permission (URP), workflow engine, rating engine, rule engine, global transaction management, search, and a batch scheduler, satisfying diverse insurance business needs. * **Secure User and Data Management:** Robust user, role, and permission management, coupled with efficient document and data handling, ensures secure and organized operations. * **Layered Master Data Management:** Enhances distribution and reuse through a layered approach: platform, business core, business region, and tenant. * **Configuration-Driven Customization:** Highly customizable through configuration, minimizes the need for code changes. * **Foundational Services:** ICS is not directly business-facing. Instead, it serves as a fundamental component supporting business services within InsureMO products like GIMO, LIMO, Gemini, iDocs, and various tenant applications. ### Key Components * iTables (Configurable Tables) * DD (Data Dictionary / Meta-Modeling) * iRules (Rule Engine) * Batch Scheduler * URP (User, Role, Permission Management) * Workflow Engine * Search * Global Transaction * DataIO (Master Data Export / Import) ### Common Services in InsureMO ![Common Services](./image/app_dev_overview/microservices_based_architecture.png) In above microservices based architecture, ICS is the **Common Services**. ## iTables iTables provide a flexible framework for managing configuration data, enabling dynamic system behavior without code changes. They consist of four main types: Code Tables, Data Tables, Configurable (Rate) Tables, and Global Configuration Tables. ### Code Tables and Data Tables Code Tables and Data Tables facilitate the management of dynamic dropdown lists and data validation, enhancing system flexibility. For more detailed information, please refer to the [Code Table and Data Table documentation](https://docs.insuremo.com/itables/app_framework/code_table). **Key Features:** * **Code Tables:** Predefined, selectable lists sourced from Data Tables, services, services, or database (deprecated) tables. Support internationalization and cascading filters. * **Data Tables:** Flexible tables for storing master data (limits, descriptions, etc.) without requiring physical database tables. * Multilingual support. * Import/Export capabilities. * Override functionality for tenant-specific customizations. * Remote record updates. * Scalable solutions for handling large datasets (standard, big data, ES code tables). **Advantages:** * Dynamic and extensible design. * Scalable for large datasets. * Tenant-specific overrides. **Typical Use Cases:** * Managing dropdown lists (vehicle makes/models). * Managing master 2-dimensions table data, such as province / city * Supporting multilingual data requirements. **Best Practice Recommendations:** * Use runtime service methods with caching for front-end data consumption. * Re-check all products when modifying tables with multiple contexts. * Define logical index fields for large data tables to improve query performance. * Consider ES code tables for searching beyond 1,000 records. * Enable "Update Records Remotely" for those tables that need active updates in runtime environment. * Differentiate between small and big data table implementations. ### Configuration Tables (Rate Tables) Configuration Tables enable the configuration of dynamic logic, primarily for insurance-related settings, without requiring code modifications. For more detailed information, please refer to the [Configuration Table documentation](https://docs.insuremo.com/itables/app_framework/parameter). **Key Features:** * Table versioning. * UI operations for management. * Table and column context for targeted application. * Keywords and scope/range restrictions for flexible definitions. * Remote record updates. * Lookup functions for data retrieval. * Memory-based (V1) and database-backed (V2) modes (V2 recommended for large datasets). **Advantages:** * Dynamic logic configuration without code changes. * Simplified management of complex configurations. * Version control. * Flexible deployment options. * Scalable for large datasets (V2). **Typical Use Cases:** * Configuring premium rate tables. * Implementing decision tables. * Creating mapping tables. **Best Practice Recommendations:** * Use V2 tables for large datasets. * Split large tables into smaller, more manageable units. * Consider common vs. product-specific logic when defining table and column context. * Enable "Update Records Remotely" for tables that need actively update in runtime environment * Perform version upgrades in the MC environment. * Use array configurations to compress data. ### Global Parameter Global Parameter provides a centralized location for managing key/value pairs that modify system behaviors. For more detailed information, please refer to the [Global Parameter documentation](https://docs.insuremo.com/itables/app_framework/global_parameter). **Advantages:** * Flexibility in customizing system behavior without code changes. * Tenant-specific configurations. * Centralized management of system parameters. **Typical Use Cases:** * Customizing UI elements and behavior using `UIConfig`. * Extending backend system behavior using `SystemConfigTable`. ## Metadata Modeling The Data Dictionary (DD) is a centralized tool for metadata management, enabling data model extension without code changes. It serves as a configuration hub for business modules and data models. For more detailed information, please refer to the [Data Dictionary documentation](https://docs.insuremo.com/ics/app_framework/dd). **Key Features:** * **Organization:** * Module division by business domain. * Grouping by sub-domain (Configuration Group). * Context-specific models (product code). * **Elements:** * Data Models and Objects. * Model relationships (Object Relation). * Field assignments (Field Binding). * **Data Access:** Standard field retrieval using "Field Name," "Model," and "Object Code." * **Model Inheritance:** Reusable, standardized models. * **Field Binding:** Standardized field usage via code table binding. * **UI Guidance:** Clear instructions for DD UI operations. **Technical Highlights:** * Separation of configuration tool and managed data. * **Business Model** (category) vs. **Business Object** (entity) concepts. * Dynamic field extensions and layered data management. * Standard data access interface. * Tenant-level overrides for platform mappings. **Advantages:** * Centralized code and field management. * Consistent data access. * Simplified data access for business and technical users. * Abstracted technical complexity. * Flexible field extensions. **Typical Use Cases:** * Extending data models for core modules (policy, claims, billing). * Managing data models for different insurance lines of business. * Handling product variations using Context. * Implementing rules and calculations based on policy data. **Best Practice Recommendations:** * Start with generic, policy-based models. * Understand common policy models (policy, invoices, agents, customers). * Examine configured products to understand technical vs. policy structures. * Define fields in the library before binding. * When overriding, avoid changing "Max Length" for fixed fields. ## iRules ### Rule Engine A configurable system for managing insurance business rules, enabling dynamic updates to logic without code releases. For more detailed information, please refer to the [Rule Engine V1 documentation](https://docs.insuremo.com/irules/app_framework/rule), [Rule Engine V2 documentation](https://docs.insuremo.com/irules/app_framework/rule-v2). **Key Features:** * UI-based maintenance and configuration. * Real-time modification, testing, and publishing. * Versioning with effective/expiry dates. * Rule tracking for debugging and troubleshooting. * Rule library copy for copying rules from other tenants. * **Components:** Rule, Rule Set, Rule Domain. * **Rule Engine V2 Enhancements:** * Script UI for parameter selection. * Improved runtime engine performance. * Dynamic rule label search and filter configuration. * Simplified rule management structure. * Groovy-like custom DSL syntax + custom functions. * Visual Rule editing. * Model/field analysis in the data dictionary. * Table usage analysis within the Rule. * Enhanced security. * Improved performance through code compilation. **Technical Highlights:** * Groovy scripting (V1) / Groovy-like DSL (V2) for rules. * Rule Groups/Sets for rule categorization. * Rule Events/Domains as API-triggered execution points. * DSL integration. * Message Codes integration. * Configuration Tables integration. **Advantages:** * Flexibility and adjustability. * Dynamic configuration without code deployment. * Improved maintainability. * Improved performance (V2). * Simplified management (V2). **Typical Use Cases:** * Underwriting rules. * Validation rules. * Auto clause/form attachment. * Endorsement content generation. **Best Practice Recommendations:** * Use Rule Labels for proposal status. * Parameterize rules using configuration tables. * Separate rules by usage into separate domains. * Disable tracking for performance-demanding clients. * Use versioning with effective/release dates. * Adopt a team approach with technical consultants and business users. ### Rating Engine A rating engine for configuring complex insurance calculations. For more detailed information, please refer to the [Rating Engine documentation](https://docs.insuremo.com/irules/app_framework/rating). **Key Features:** * Configurable calculation logic. * Groovy + DSL scripting. * Calculation sequence management. * Rate table integration. * Debugging and tracking. * Versioning. * Standalone mode. #### Typical Use Cases * Product premium calculation. * Tax and fee calculation. * Commission calculation. * Sum insured calculation. * Endorsement calculation. * Standalone rating. #### Best Practice Recommendations * Organize calculations. * Define clear sequences. * Utilize rate tables. * Implement versioning. * Test and debug. * Optimize performance. * Consider standalone mode. * Follow naming conventions. * Handle multi-currency scenarios. * Implement rounding accuracy. ### DSL (Domain Specific Language) and Snippets Domain Specific Language (DSL) and Snippets for implementing application domain behavior. DSLs are used for insurance-related actions like retrieving field values (premium, coverage) and triggering underwriting. Snippets orchestrate Groovy and DSL operators to achieve sample function logic. Both DSL and Snippets can be maintained via UI. For more detailed information, please refer to the [DSL and Snippet documentation](https://docs.insuremo.com/irules/app_framework/dsl). **Advantages:** * Fast-starting and easy-to-use. * Flexible and dynamic scenarios. * Simplified configuration. * Extensible. **Typical Use Cases:** * Rating engine * Rule engine (underwriting, attach element, attach form, complex validation rules) * Numbering template * Index field * Model filtering **Best Practice Recommendations:** * Validate vehicle age. * Set policy duration. * Handle null values. * Validate effective dates. * Calculate insured age. * Validate field lengths. * Update multiple fields. * Reusable logic across rules and formulas. ## Batch Scheduler The **Batch-V2** Framework is a scheduling component that automates the execution of system programs at scheduled times. It uses Spring Batch SDKs to streamline batch program development. For more detailed information, please refer to the [Batch-V2 Framework documentation](https://docs.insuremo.com/ics/app_framework/batch-v2). **Key Features:** * Scheduled and manual (ad-hoc) batch execution. * Job dependency management. * Batch window control (restricting execution to specific time periods). * Monitoring and reporting (execution details, status, and history). * Alarming for failures and timeouts. * Multi-language support for job display names. * Time offset support for future timing testing. **Technical Highlights:** * Based on the Spring Batch framework. * Provides a standard SDK for rapid integration. * Supports single-threaded and multi-threaded step execution. * Uses Cron expressions for scheduling. * Offers a Dependency View function to visualize job dependencies. * Integration with GIT for exporting and deploying batch definitions. **Advantages:** * Automates system tasks. * Improves system performance through asynchronous processing. * Simplifies batch program development. * Provides comprehensive monitoring and reporting capabilities. * Enables proactive issue detection through alarms and patrol reports. **Typical Use Cases:** * Importing policy issuing data into Excel and sending it to salesmen daily. * Any scenario requiring scheduled execution of system programs. * Automated renewal of policies. **Best Practice Recommendations:** * Use the Spring Batch framework for client processing. * Utilize the provided SDK for rapid integration. * Define batch jobs in the master configuration (MC) environment. * Monitor batch execution status and history regularly. * Configure alarms and patrol reports for proactive issue detection. * For multi-threaded steps, use the platform-overloaded task executor for better context and stability. * Use time offsets carefully for testing and disable them after verification. ## Workflow Engine A workflow engine is based on Activiti, facilitating workflow control and management. It orchestrates task sequences to achieve business goals, offering a way for third-party applications to extend behavior without impacting core business flows. For more detailed information, please refer to the [Workflow Engine documentation](https://docs.insuremo.com/ics/app_framework/workflow). **Key Features:** * BPMN 2.0 standard compliance. * Activiti-based workflow management. * APIs for process instance creation, task completion, and querying. * DataIO deployment support. * Workflow task index definitions. **Technical Highlights:** * **BPMN:** Visual business process modeling using BPMN 2.0. * **Deployment:** Workflow definition deployment via DataIO. * **Index Definition:** Minimum index field sets for workflow tasks. * **API Calls:** Workflow microservice APIs for business process management. * **Search:** Enhanced search capabilities. **Advantages:** * Handles processes with many nodes. * Manages flow node changes without code modification. * Simplifies complex workflows. **Typical Use Cases:** * Automating complex business processes. * Managing approval workflows. * Integrating different systems and applications. **Best Practice Recommendations:** * Use `queryTasksByBusinessKey` API for querying tasks. * Use control variables to manage multiple workflow paths. ## Index Management & Search The Index Management module enables users to perform data-related actions (add, update, delete, query) using a search engine (Elastic Search). It provides a generic search API and UI for expanding index fields. For more detailed information, please refer to the [Index Management documentation](https://docs.insuremo.com/ics/app_framework/search). **Key Features:** * Dynamic extension of index fields using a data dictionary. * ESCodeTable mechanism for large configuration data. * Index Management consists of *Index* and *Index Field*. * Base Query and Advanced Query options. * Ability to add, update, and delete business data via Search API. * Case-insensitive search. * Saving and searching multiple values for one index field. **Technical Highlights:** * Utilizes Elastic Search (ES) Engine on the backend. * Provides both Base Query and Advanced Query search criteria with detailed examples (JSON, SQL, Groovy). * Includes code examples for various search operations (Base Query, Advanced Query, ES CodeTable). * Details on handling multiple values in a single index field using "multiLineExact". **Advantages:** * User-friendly search capabilities compared to generic search engines. * Suitable for transactions involving large datasets and fuzzy search requirements. * Offers flexibility in customizing search criteria. **Typical Use Cases:** * Expanding or customizing search criteria within the platform. * Domain-based business queries (Policy, Endorsement, Claim, etc.). * Generating reports with more than 1,000 records using search engine-powered APIs (requires iteration logic). **Best Practice Recommendations:** * Use DB search instead of ES for low-frequency transactions. * Be aware of the 1,000-record limit for the Search API and implement iteration logic for larger datasets. * Contact the InsureMO operations team for guidance before adding a new index. * Use "**.caseInsensitive**" for case-insensitive queries. * Use "multiLineExact" for exact searches on multi-valued index fields. * Check ES mapping after deploying business data. ## URP (User, Role, Permission Management) AppURP manages system access and permissions, ensuring security and user isolation. It controls menu, data, and API access. This section focuses on AppURP, not the InsureMO portal URP. For more detailed information, please refer to the [AppURP documentation](https://docs.insuremo.com/iam/urp). **Key Features:** * **User Management:** Create and manage user accounts. * **Role Management:** Define permission sets for business units using roles as groups or templates. * **Permission Management:** Control access to data (backend/API) and UI elements. * **Admin Roles:** Implement layered admin authority (Super, System, Ordinary/Branch). * **Business Permission Extension:** Allow business modules to implement custom permissions. * **Import/Export:** Deploy configuration data from the MC portal. * **API Authority:** Configure API access for all or specific users. * **UI Navigation:** Control system menu access, supporting different UI projects and third-party systems. * **Menu Hiding:** Hide specific permission codes. * **Read/Write Separation:** Control element display based on permissions. * **User Synchronization:** Assign default roles and user information upon first login. **Advantages:** * Supports data and UI permissions. * Offers flexible role management (groups or templates). * Provides layered administrator authority. * Enhances security and user isolation. * Offers customizable permission structures. * Streamlines UI operations. * Provides flexible API authority configuration. **Typical Use Cases:** * Developing applications with controlled user permissions. * Managing access to sensitive data and APIs. * Implementing single sign-on (SSO). * Multi-layered permission structure for claim authorities. **Best Practice Recommendations:** * Configure permission menus and APIs for front-end applications. * Disable the ADMIN user in production and create limited-authority admin users. * Hide specific permission codes using the global parameter table. * Integrate user synchronization for consistent settings across systems. ## Branch Management The Branch module manages organizational hierarchies and access control within InsureMO. For more detailed information, please refer to the [Branch documentation](https://docs.insuremo.com/ics/app_framework/branch). **Key Features:** * **Hierarchy Management:** Define and maintain organizational structures via UI. * **Data Access:** Retrieve branch information using the API. * **Configuration Deployment:** Import/export configuration data. * **User Assignment:** Assign users to specific branches. **Technical Highlights:** * **Core Attributes:** Focuses on basic branch definitions. * **Access Control:** Front-end applications use URP and the branch API for business authority control. * **Hierarchy:** Supports single or multiple parent nodes. * **Branch Removal:** API available for deleting branches. **Advantages:** * **Role-Based Access Control:** Access control based on branch affiliation. * **Flexible Organization:** Supports diverse organizational structures. * **Simplified Deployment:** Streamlines configuration deployment. **Typical Use Cases:** * Manage internal company branches. * Represent external partner organizations. * Configure access permissions. **Best Practice Recommendations:** * **Environment:** Define branches in the appropriate environment (runtime vs. MC). * **Hierarchy:** Carefully consider single vs. multiple parent nodes. ## Global Transaction Management The Global Transaction management uses Seata Server within a microservice architecture. It addresses the challenge of maintaining transaction consistency across multiple microservices where network instability can lead to lost calls. The solution involves using Seata Server with code annotations to record unfinished transactions, following the Try/Confirm/Cancel (TCC) process. It also covers AT transaction compensation mode, reliable message mode and TCC transaction mode. For more detailed information, please refer to the [Global Transaction documentation](https://docs.insuremo.com/ics/app_framework/global_transaction). **Key Features:** * **Distributed Transaction Management:** Ensures data consistency across microservices. * **Seata Server Integration:** Utilizes Seata Server to manage and track transactions. * **TCC (Try/Confirm/Cancel) Support:** Implements a three-phase commit process for transaction control. * **AT Transaction Compensation Mode:** Provides a high-performance, simple compensation mechanism using reverse operations at the persistence layer. * **Reliable Message Mode:** Ensures reliable message delivery, particularly for MQ messages and calls to third-party interfaces without compensation capabilities. * **Global Transaction-Level Locking:** Prevents concurrent updates to compensable objects by different global transactions. * **HTTP API for Global Transaction Management:** Offers APIs to start, commit, and rollback global transactions, useful for applications without the InsureMO Appframework. * **TCC Compensation Retry:** Supports retrying failed TCC transactions through a management system. **Technical Highlights:** * **AT Mode Compensation:** Relies on reverse operations (Create/Update) at the persistence layer, with automatic rollback method invocation by the framework. * **Undo Data Recording:** Service provider APIs record rollback information during execution for AT mode. * **Reliable Message Mode Implementation:** Internally transformed into Seata TCC mode, executing TxOutCommand after the global transaction. * **Annotations:** `@LocalTCC` and `@TwoPhaseBusinessAction` are used for TCC transaction mode. * **HTTP APIs:** `/seata-server/seata-server/beginGlobal`, `/seata-server/seata-server/commitGlobal`, and `/seata-server/seata-server/rollbackGlobal` for managing transactions via HTTP calls. **Advantages:** * **Ensured Transaction Consistency:** Guarantees data integrity across microservices. * **Simplified Compensation Implementation (AT Mode):** Offers a straightforward approach to handling rollbacks. * **Minimal Impact on Procedure Flow (AT Mode):** Synchronous calls ensure no disruption to existing processes. * **Flexibility:** Supports multiple transaction modes (AT, TCC, Reliable Messages) to suit different scenarios. * **Retry Mechanism:** Provides a way to recover from failed TCC transactions. **Typical Use Cases:** * **Core System REST API Calls (AT Mode):** Suitable for managing transactions involving key business objects like policies, endorsements, and payments. * **MQ Message Sending (Reliable Message Mode):** Ensures messages are reliably sent as part of a transaction. * **Third-Party Interface Calls (Reliable Message Mode):** Manages transactions involving external systems without built-in compensation. * **BFF Layer without InsureMO Appframework:** Manages global transactions when calling InsureMO atomic APIs from a custom BFF layer. **Best Practice Recommendations:** * **Use AT Mode:** Preferred for most core systems due to its performance and simplicity. * **Implement Compensation Capabilities:** Ensure all business operations within a global transaction have compensation mechanisms (AT/TCC/reliable messages). * **Handle Delete Operations as Updates:** Convert delete operations to logical deletions for AT mode compatibility. * **Merge Multiple Operations:** Consolidate multiple Create/Update operations on the same business object in AT mode. * **Utilize Proposal Number/Order Number:** In customer portals, use a unique transaction identifier (proposal/order number) and retry with the same number to prevent duplicate policy issuances. * **Retry Failed TCC Transactions in Order:** When retrying failed TCC transactions, process them from the earliest to the latest. * **Set Appropriate Timeouts:** Configure `seata.defaultGlobalTransactionTimeout` and `ribbon.ReadTimeout` based on the environment (shorter for production, longer for development). * **Search by DB Level:** Rely on DB-level searches instead of ES for enhanced search accuracy when creating or updating proposals. ## Event Bridge Event Bridge is an event bus service enabling loosely coupled, distributed event-driven architectures. It connects applications using standardized events, allowing third-party extensions without impacting core business flows. For more detailed information, please refer to the [Event Bridge documentation](https://docs.insuremo.com/ics/app_framework/event_bridge). **Key Features:** * **Event-Driven Architecture:** Connects applications via events. * **Standardized Events:** Ensures loose coupling. * **Event Bus Service:** Relays events. * **Filtering & Transformation:** Routes and modifies events using rules. * **Integration:** Supports third-party systems. * **Schema:** Defines event structure. * **Multiple Event Sources:** GIMO, Baseline, Tenant. * **Various Event Targets:** InsureMO Mail Service, Platform RabbitMq, Preset Http Client, Http, User Message. * **Event Trace:** Tracks event processing. * **API Destinations & Connections:** Integrates with external services via HTTP endpoints with configurable authentication. **Technical Highlights:** * **Event Filtering:** Supports various matching criteria (specified value, prefix, suffix, exclusion, numeric, IP address, multi-pattern, array, null, existing, equals-ignore-case, wildcard). * **Event Conversion:** Supports complete/partial events (JSONPath), constant, template (string, JSON, nested JSON), and environment variable conversions. * **Retry Strategies:** Includes backoff and exponential decay. * **Fault Tolerance:** Configurable with dead message queue support. * **Schema Validation:** Uses JSON schema. **Advantages:** * **Loose Coupling:** Enables independent development and deployment. * **Real-Time Integration:** Eliminates the need for regular jobs or UI triggers. * **Customization:** Allows clients to customize platform behavior. * **Simplified Integration:** Streamlines third-party integration via HTTP and pre-built connections. **Typical Use Cases:** * **Product Management:** Notifying claim systems of product updates. * **Batch Alert:** Sending email notifications upon batch failure. * **Third-Party Integration:** Calling external HTTP interfaces. **Best Practice Recommendations:** * **Use Standardized Events:** Ensure consistent data exchange. * **Leverage Event Filtering:** Route events based on criteria. * **Utilize Event Conversion:** Transform events for target systems. * **Configure Retry Strategies:** Ensure reliable delivery. * **Monitor Event Processing:** Track event flow. * **Secure Connections:** Use appropriate authentication for external integrations (Basic Auth, OAuth, API Key). ## DMS (Document Management) The DMS API enables users to upload, retrieve, and manage business documents, associating them with specific business entities. For more detailed information, please refer to the [Document Management documentation](https://docs.insuremo.com/ics/app_framework/dms). **Key Features:** * Storage in Cloud Object Storage Service, with document indexing in a database. * Business data correlation using `EntityType` and `DmsEntityId`. * Document properties like `DmsDocId`, `EntityType`, `DmsEntityId`, `BusinessCategory`, `OriginalFileName`, `DisplayName`, `AdditionalFileMeta`, `S3Bucket`, `S3Key`, `ThumbnailS3Bucket`, `ThumbnailS3Key`, and `SubDir`. * Thumbnail generation and download for images. * Safety permissions including ID tamper-proofing, business EntityID verification, file type whitelisting, and file size limits. * Configuration via code tables (`DmsEntityType`, `DmsBusinessCategory`) and platform parameters. * API access through the portal. **Technical Highlights:** * Storage in Cloud Object Storage Service with tenant segregation via separate buckets. * Database storage of document indexing information. * Use of `EntityType` and `DmsEntityId` for business data correlation. * Thumbnail generation for image documents. * Safety permissions implementation. **Advantages:** * Effortless document uploading and retrieval. * Association of documents with business entities. * Secure storage and access control. * Configurable and extensible through code tables and parameters. **Typical Use Cases:** * Storing and retrieving policy documents. * Managing claim-related documents. * Handling customer identification documents. * Archiving endorsement documents. **Best Practice Recommendations:** * Utilizing the `EntityType` and `DmsEntityId` fields consistently for accurate business data correlation. * Adhering to file type whitelisting and size limits for security. * Leveraging thumbnails for efficient image preview and download. * Regularly reviewing and updating code tables and configuration parameters. ## Transaction Numbering The Numbering Template functionality within the platform. This feature allows users to configure various number formats (quotation, policy, claim numbers, etc.) based on client-specific rules. For more detailed information, please refer to the [Numbering documentation](https://docs.insuremo.com/ics/app_framework/pubnumbering). **Key Features:** * Customizable numbering templates with predefined variables (PRODUCT\_CODE, TRANS\_YEAR, TRANS\_MONTH) and rule-based variables. * Support for variables affecting the numbering itself, the numbering sequence, and sequence factors (for skipping numbers). * Integration with rule engine for complex numbering logic. * API for generating numbers based on the template and factors. * Numbering sequence maintenance. **Advantages:** * Flexibility to adapt to diverse client numbering requirements. * Centralized configuration of numbering rules. * Reduced manual effort in generating and managing numbers. **Typical Use Cases:** * Including product codes in policy numbers. * Generating different proposal number formats for different product types. * Implementing sequence skipping based on specific criteria. * Sharing numbering sequences across different products or modules. **Best Practice Recommendations:** * Use the `NotSeqFlg` keyword appropriately to control sequence sharing. * Leverage the rule engine for complex numbering logic and variable derivation. * Use the provided APIs for number generation and integration with business processes. * Follow the described steps for Numbering Sequence Maintenance when needing to start from a user-defined number. ## Context, Module & Group Management The Context module manages module and context type grouping and message translation. It enables dynamic grouping of configuration data for improved management and deployment. For more detailed information, please refer to the [Context documentation](https://docs.insuremo.com/ics/app_framework/context). **Key Features:** * Categorizes configuration data. * Allows grouping by Context, Module, Resource, and Resource Relationship. * Supports adding new modules and configuration groups. * Facilitates translation for modules and groups using i18n. * Provides export functionality for context data. **Advantages:** * Better management of configuration data. * Improved deployment across different environments. * More specific management through configuration group segmentation. * User-friendly display names for modules/groups in dropdowns via translation. **Typical Use Cases:** * Categorizing configuration data for product-related or common configurations. * Defining business modules and segmenting them further with configuration groups. **Best Practice Recommendations:** * Perform operations in the MC environment. * Use the export functionality to move context data. * Well organize configuration data by group for better isolation ## Multi-language Support I18n (internationalization) is a configuration module for managing multilingual translations (UI, code tables, messages) in a centralized manner within the InsureMO platform. For more detailed information, please refer to the [I18n Translation documentation](https://docs.insuremo.com/ics/app_framework/i18n) and [Message Code documentation](https://docs.insuremo.com/ics/app_framework/message). **Key Features:** * Centralized management of UI labels, code table values, and system messages. * UI for managing translations, including single record editing, Excel upload/download. * Support for tenant-level translation overrides. * Automatic help text loading for UI labels. * AI-powered translation suggestions (from version 25.01). * Integration with Rainbow UI framework. * I18n support in both UI and service applications. **Advantages:** * Centralized translation management reduces redundancy and inconsistencies. * Simplified UI development with direct I18n integration. * Improved user experience through multilingual support. * AI translation capabilities speed up the translation process. **Typical Use Cases:** * Translating UI labels and messages for a global user base. * Localizing drop-down list options based on user language. * Providing multilingual help text for UI elements. * Supporting multilingual menus in UI applications. * Displaying system messages in the user's preferred language. * Displaying validation messages when rules fail. * Displaying messages related to endorsements or issuance. * Displaying messages with variables such as age and product. ## Master Data Export/Import (DataIO) DataIO is a core component of InsureMO that addresses configuration data deployment across multiple environments and tenants in a microservice architecture. It facilitates the release of business data by exporting it from a central configuration environment (MC/Portal) and importing it into runtime environments. For more detailed information, please refer to the [DataIO Export/Import documentation](https://docs.insuremo.com/ics/app_framework/dataio). **Key Features:** * Supports deployment of configuration data (products, ratings, etc.) and conditionally instance data (branches, roles). * Differentiates between tenant and platform configuration data. * Offers features for data export, check-in (manual and automated), build & deploy (using CICD), and status monitoring. * Supports incremental deployment for performance. * Provides UI operations for configuration deployment, including auto check-in to Git. **Advantages:** * Avoids data redundancy by importing only necessary data. * Enables independent data management for each microservice. * Supports multi-tenant publishing with tenant isolation. * Facilitates cross-environment and cross-version releases. * Enables fast iteration of configuration through a standard process (Configuration > Test > Online). **Typical Use Cases:** * Configuration data deployment from MC environment to other environments (test, production). * Multi-tenant data publishing. * Cross-environment and cross-version releases. **Best Practice Recommendations:** * Always start configuration from the MC environment before exporting. * Do not modify the structure or data within exported files after unzipping. * Ensure proper check-in to the configuration data Git repository. * Pay attention to the order of deployment steps, especially for data with dependencies. * For large tables, segregate the configuration data into separate configuration groups and potentially separate Git repositories. * When changing a table's group, be aware of the risks and potential data inconsistencies. * Use the provided troubleshooting steps to identify and resolve deployment issues. ## Integration Management The Integration Management feature aims to streamline integration processes between different systems (e.g., carriers and channels) in insurance transactions. It captures integration request and response data automatically, reducing repetitive work for technical teams. For more detailed information, please refer to the [Integration Management documentation](https://docs.insuremo.com/ics/app_framework/integration_adapter). **Key Features:** * Automatic capture of integration request and response bodies, out-of-the-box UI for viewing historical records, automatic retries for failures, and asynchronous call support. * Uses a standard integration pattern (Prepare Request, Send Request, Set Response), a standard interface (`TransactionSyncAdapterService`), and a configuration data table (`AdapterServiceCfg`). * It supports integration with both InsureMO app framework and iComposer. **Advantages:** * Reduces the need for technical teams to create custom integration-related tables for reconciliation. * Provides a UI to view historical records and trigger retries. * Offers an alternative to MQ for asynchronous integrations with manual retry capabilities. **Typical Use Cases:** * Policy transactions requiring integration between carriers and channels. * Sending emails using the InsureMO email service as an example. * Asynchronous calls for tasks like email, SMS, or print generation. **Best Practice Recommendations:** * For high-volume integrations, MQ is still recommended. * For other integrations, assess the business scenario and choose between MQ and Integration Management. * Regularly archive integration logs to S3 using the `integrationAdapterArchiveBatch` to prevent infrastructure issues. * Adopt either InsureMO app framework or iComposer. * Separate the integration implementation into the three steps: Prepare Request, Send Request, Set Response. ## Print Management Print Task Management is a service within InsureMO that allows users to search, manage, and reprint insurance-related documents like policies, claims letters, and invoices. It works in conjunction with the Document Generation service, which physically generates the PDF files. For more detailed information, please refer to the [Print Management documentation](https://docs.insuremo.com/ics/app_framework/print). **Key Features:** * Searching for print tasks * Single/Online Printing: Printing documents one by one in real-time. * Batch Printing: Selecting multiple print tasks for bulk printing. * Reprinting existing documents. * Downloading existing PDF documents. * Printing history tracking. **Technical Highlights:** * Powered by Print Task API. * Integrates with Document Generation service. * Supports Print Task V1 and V2 APIs (V2 is recommended). * Provides a UI for managing print tasks. * Allows users to use platform Print Task and Document Generation API or integrate with their own document generation APIs. **Advantages:** * Provides a centralized management service for print tasks. * Enables efficient searching and reprinting of documents. * Supports both single and batch printing. * Offers flexibility in document generation (InsureMO's service or integration with existing tools). * Supports Word document generation using Aspose templates. **Typical Use Cases:** * Initial printing of policy documents upon issuance. * Reprinting documents for customers or internal use. * Batch printing of invoices or statements. * Downloading documents for record-keeping. * Accident reporting **Best Practice Recommendations:** * Embed a print task generation trigger point API during business processes. * Use V2 API for generating print tasks. * Migrate from V1 to V2 API if currently using V1. * Use DD capabilities to quickly convert code tables when using InsureMO GI policy API for printing. * Leverage configuration tables for product and template mapping. ## Upload The upload framework facilitates parsing Microsoft Excel data (xls, xlsx, csv) into a database. It uses a standard API and is configured via Structs and Nodes. For more detailed information, please refer to the [Upload documentation](https://docs.insuremo.com/ics/app_framework/upload). **Key Features:** * Supports various Excel formats. * Allows maintenance and deployment of Excel templates with features like date formats, dropdown lists, and VBA validation. * Uses Structs (abstract template) and Nodes (Excel file and data structure representation) for mapping Excel data to policy objects. * Supports dynamic mapping based on data dictionary configuration and coding mapping based on BFF program. * Structs and Nodes define the parsing behavior. * Integration with business batch jobs via `vela-upload-sdk`. * REST API for file upload and download. **Advantages:** * Handles large data uploads, especially risk and schedule information for group policies. * Reduces user errors by supporting business-oriented Excel templates. * Provides a mapping layer between Excel and policy objects. **Typical Use Cases:** * Uploading large amounts of data to the platform. * Scenarios requiring the use of pre-defined Excel templates with specific formats and validations. **Best Practice Recommendations:** * Configure upload templates via Public Setting > Upload Template. * Invoke the upload file RestAPI from the UI or a backend service. * Add the `vela-upload-sdk` dependency to business batch projects. * Utilize Structs and Nodes to define the mapping between Excel columns and data objects. ## App Foundation Features The App Foundation provides a suite of foundational services that empower microservices built upon the InsureMO AppFramework. Refer to the [Service Development Quick Guide](https://docs.insuremo.com/quick_start_appframework_development/app_development_quick_guide) for more information. **Key Features:** * Admin UI: A centralized interface for managing various configurations and tasks. * Audit Logs: Tracks changes to configuration data (products, ratings, rules, etc.) made via UI/API or configuration deployments. * Calendar: Configures workdays and holidays for business validation and batch processing. * User Preferences: Customizes the UI (e.g., search criteria, columns) at user and tenant levels. * Local Cache Management * JFR Online Profiling: For performance tuning. * Exchange Rate Configuration: Manages daily exchange rates. * Other features. ### Security Features Security features protect sensitive data and ensure compliance. Refer to the [Security](https://docs.insuremo.com/ics/app_framework/security) for more information. **Key Features:** * API Authority: Restricts API access to authorized users. * Sensitive Data Masking: Masks sensitive data in API responses. * Data Signature: Prevents unauthorized data access by signing sensitive data. * Log Encryption: Encrypts sensitive data in logs. * Data Storage Encryption: Encrypts sensitive data stored in databases. ### JFR Collect and analyze diagnostic and profiling data for performance tuning. Refer to the [JFR](https://docs.insuremo.com/ics/app_framework/jfr) for more information. **Key Features:** * Web UI for JFR operations. * InsureMO extensions for JDBC and Rest API call analysis. ### Admin UI A backend UI framework that allows embedding new UI functionalities via iframe. Refer to the [UI Admin Framework](https://docs.insuremo.com/ics/app_framework/quicksearch) for more information. **Key Features:** * Language switching. * System Message Center: For conveying business or system messages quickly, allowing users to receive and handle them conveniently within the UI.