DESC:FORM 2
THE PATENTS ACT, 1970
(39 of 1970)
&
THE PATENT RULES, 2003
COMPLETE SPECIFICATION
(See Section 10 and Rule 13)

Title of invention:
A SYSTEM AND METHOD FOR VALIDATING A MESSAGE IN AN INPUT FILE

Applicant
Tata Consultancy Services Limited
A Company Incorporated in India under The Companies Act, 1956
Having address:
Nirmal Building, 9th Floor,
Nariman Point, Mumbai 400021,
Maharashtra, India

The following specification describes the invention.

REFERENCE TO RELATED APPLICATIONS
[001] The present application claims priority from provisional application 155/MUM/2013.

FIELD OF INVENTION
[002] The present invention relates to a field of validating a message. More particularly, the present invention relates to a system and method for validating a message in an input file.

BACKGROUND
[003] Many organizations communicate and transact with each other via messaging standards such as Financial Information Exchange (FIX) protocol. Current banking industry faces the problems in testing during the upgradation of industry platforms and processing data in development, production and testing environments. Deployment of capital market product (CMP) in banking industry has been difficult because of non-availability of required tools to test the messaging format.
[004] Based on recent trends in financial markets, the industry tends to identify and implement specific solutions in order to address the requirements of various segments of their businesses. The implementation of such solution results in having more than one vendor product consisting specific set of functionality for set of asset classes such as FX, Equities, Interest Rates and Commodities or specific set of business functions such as For Front Office, Middle Office, Back Office and Risk Management functions.
[005] The current challenge is in developing systems to address the technical architecture that can meet the requirements of one or more vendor products. Further, developing the systems to customize the testing solution and addressing version upgrade requirements for vendor products and respective testing solutions increase cost of development.
[006] Current available tools are designed to test specific capital market products. The existing tools report the detailed test status but do not provide online rectification of errors found in the input file while processing and reprocessing of the data. Further, adding user defined input fields to standard Financial Products Markup Language (FpML) or FIXML tags is not feasible with existing tools. The existing tools also do not support mapping of inputs file format to standard tags available in FpML or FIXML.

SUMMARY
[007] Before the present systems and methods, enablement are described, it is to be understood that this disclosure is not limited to the particular platforms, systems, and methodologies described, as there can be multiple possible embodiments of the present disclosure and which are not expressly illustrated in the present disclosures. It is also to be understood that the terminology used in the description is for the purpose of describing the particular versions or embodiments only, and is not intended to limit the scope of the present disclosure.
[008] In one implementation, a method for validating a message in an input file is disclosed. The method comprises parsing a header in the message to capture a plurality of elements present in the header. An element of the plurality of elements is indicative of at least one of a data type, or an asset class, or an attribute corresponding to the message. The method further comprises mapping the element with a Financial Products Markup Language (FpML) element using a processor based upon the at least one of the data type, or the asset class, or the attribute. The method further comprises generating a javabean instance for the FpML element. The javabean instance comprises information corresponding to the input file mapped. The method further comprises validating the javabean instance using a pre-defined FpML structure. The javabean instance is validated by comparing the javabean instance with the pre-defined FpML structure.
[009] In one implementation, a system for validating a message in an input file is disclosed. The system comprises a processor and a memory coupled to the processor. The processor is capable of executing a plurality of modules stored in the memory. The plurality of modules comprises a parser configured to capture a plurality of elements present in a header of the message. An element of the plurality of elements is indicative of at least one of a data type, or an asset class, or an attribute corresponding to the message. The plurality of modules further comprises a mapping module configured to the map the element with a Financial Products Markup Language (FpML) element based upon the at least one of the data type, or the asset class, or the attribute. The mapping module further is configured to generate a javabean instance for the FpML element. The javabean instance comprises information corresponding to the input file mapped. The plurality of modules further comprises a validation module configured to validate the javabean instance using a pre-defined FpML structure. The javabean instance is validated by comparing the javabean instance with the pre-defined FpML structure.
[010] In one implementation, a computer program product having embodied thereon a computer program for validating a message in an input file is disclosed. The computer program product comprises a program code for parsing a header in the message to capture a plurality of elements present in the header. An element of the plurality of elements is indicative of at least one of a data type, or an asset class, or an attribute corresponding to the message. The computer program product further comprises a program code for mapping the element with a Financial Products Markup Language (FpML) element based upon the at least one of the data type, or the asset class, or the attribute. The computer program product further comprises a program code for generating a javabean instance for the FpML element. The javabean instance comprises information corresponding to the input file mapped. The computer program product further comprises a program code for validating the javabean instance using a pre-defined FpML structure. The javabean instance is validated by comparing the javabean instance with the pre-defined FpML structure.

BRIEF DESCRIPTION OF THE DRAWINGS
[011] The foregoing summary, as well as the following detailed description of preferred embodiments, is better understood when read in conjunction with the appended drawing. For the purpose of illustrating the disclosure, there is shown in the drawing an exemplary construction of the disclosure, however, the disclosure is not limited to the specific methods and system illustrated.
[012] Figure 1 illustrates a network implementation of a system for validating a message in an input file, in accordance with an embodiment of the present disclosure.
[013] Figure 2 illustrates the system, in accordance with an embodiment of the present disclosure.
[014] Figure 3 illustrates a method for mapping the element with the FpML element, in accordance with an embodiment of the present disclosure.
[015] Figure 4 illustrates a method for FpML conversion, in accordance with an embodiment of the present disclosure.
[016] Figure 5 illustrates a method for validating a message in an input file, in accordance with an embodiment of the present disclosure.

DETAILED DESCRIPTION
[017] The present disclosure relates to a system and method for validating a message in an input file. The input file is received from a source. A format of the input file is identified. A plurality of elements is captured from a header in the message by parsing the message. An element of the plurality of elements is indicative of at least one of a data type, or an asset class, or an attribute corresponding to the message. The element is mapped with a Financial Products Markup Language (FpML) element based upon at least one of the data type, or the asset class, or the attribute. The FpML element comprises an FpML javabean instance.
[018] A javabean instance for the FpML element is generated. The javabean instance is validated with a pre-defined FpML structure by comparing the FpML javabean instance with the pre-defined FpML structure. The element is compared with the FpML element. A user is notified when the element is not same as the FpML element. An Extensible Markup Language (XML) data is created by generating an Extensible Markup Language (XML) layout based on the pre-defined FpML structure.
[019] While aspects of described system and method for validating a message in an input file may be implemented in any number of different computing systems, environments, and/or configurations, the embodiments are described in the context of the following exemplary system.
[020] Referring now to FIG.1, a network implementation 100 of a system 102 for validating a message in an input file is illustrated, in accordance with an embodiment of the present disclosure.
[021] Although the present disclosure is explained by considering a scenario that the system 102 is implemented as an application on a server. It may be understood that the system 102 may also be implemented in a variety of computing systems, such as a laptop computer, a desktop computer, a notebook, a workstation, a mainframe computer, a server, a network server, and the like. It will be understood that the system 102 may be accessed by multiple users through one or more user devices 104-1, 104-2…104-N, collectively referred to as user devices 104 hereinafter, or applications residing on the user devices 104. Examples of the user devices 104 may include, but are not limited to, a portable computer, a personal digital assistant, a handheld device, and a workstation. The user devices 104 are communicatively coupled to the system 102 through a network 106.
[022] In one implementation, the network 106 may be a wireless network, a wired network or a combination thereof. The network 106 can be implemented as one of the different types of networks, such as intranet, local area network (LAN), wide area network (WAN), the internet, and the like. The network 106 may either be a dedicated network or a shared network. The shared network represents an association of the different types of networks that use a variety of protocols, for example, Hypertext Transfer Protocol (HTTP), Transmission Control Protocol/Internet Protocol (TCP/IP), Wireless Application Protocol (WAP), and the like, to communicate with one another. Further the network 106 may include a variety of network devices, including routers, bridges, servers, computing devices, storage devices, and the like.
[023] Referring now to FIG.2, the system 102 is illustrated in accordance with an embodiment of the present disclosure. In one embodiment, the system 102 may include at least one processor 202, an input/output (I/O) interface 204, and a memory 206. The at least one processor 202 may be implemented as one or more microprocessors, microcomputers, microcontrollers, digital signal processors, central processing units, state machines, logic circuitries, and/or any devices that manipulate signals based on operational instructions. Among other capabilities, the at least one processor 202 is configured to fetch and execute computer-readable instructions stored in the memory 206.
[024] The I/O interface 204 may include a variety of software and hardware interfaces, for example, a web interface, a graphical user interface, and the like. The I/O interface 204 may allow the system 102 to interact with a user directly or through the user devices 104. Further, the I/O interface 204 may enable the system 102 to communicate with other computing devices, such as web servers and external data servers (not shown). The I/O interface 204 may facilitate multiple communications within a wide variety of networks and protocol types, including wired networks, for example, LAN, cable, etc., and wireless networks, such as WLAN, cellular, or satellite. The I/O interface 204 may include one or more ports for connecting a number of devices to one another or to another server.
[025] The memory 206 may include any computer-readable medium or computer program product known in the art including, for example, volatile memory, such as static random access memory (SRAM) and dynamic random access memory (DRAM), and/or non-volatile memory, such as read only memory (ROM), erasable programmable ROM, flash memories, hard disks, optical disks, and magnetic tapes. The memory 206 may include modules 208 and data 230.
[026] The modules 208 include routines, programs, objects, components, data structures, etc., which perform particular tasks or implement particular abstract data types. In one implementation, the modules 208 may include a parser 210, a mapping module 212, a validation module 214, and other modules 216. The other modules 216 may include programs or coded instructions that supplement applications and functions of the system 102. The data 230, amongst other things, serves as a repository for storing data processed, received, and generated by one or more of the modules 208. The data 230 may also include a system database 232 and other data 234. The other data 234 may include data generated as a result of the execution of one or more modules in the other modules 216.
[027] In one embodiment, an input file comprising at least one message may be received. The input file may be received using a reception module (not shown). The message may be received from one or more sources. The one or more sources may comprise user defined input data, or data from external databases. The message may include, but not limited to at least one of a trade data, or a financial transaction data or a combination thereof. The trade data may comprise information in a specific format. For example, the trade data may comprise at least one of a number format, or a currency or a date format as specified by the Financial Information Exchange (FIX) protocol. The input file may comprise one or more input fields. The one or more input fields may comprise an optional field or a custom field that may be added for organizational processes. In one exemplary embodiment, the input file may be received through a web browser.
[028] The reception module may identify a format of the input file. The reception module may identify the format of the input file such that the input file may be in compliance with the Financial Information Exchange (FIX) protocol format. The input file may include but not limited to a flat file or any other configured file. Further, the input file may comprise an Extensible Markup Language (XML) file. The XML file may comprise input file having extensions that may support .txt, or .xls, or .csv file etc.
[029] The reception module may allow the user to select the input file. The reception module may allow the user to select at least one of input file from a plurality of file formats. For example, the reception module may allow the user to select the input file from the formats including, but not limited to, .txt, or the .xls, or the .csv file. The reception module may identify the input file format by recognizing the extension of the input file. Depending on the extension, the reception module may convert the input file such that the message may be used from the input file for processing.
[030] The input file may be a standard delimited file. The input file may comprise data values having embedded delimiters, for example, quotation marks, commas, and tabs. The delimiter indicates a character that may separate words in a text string that may be used to define beginning or end of a string of character data. The input file may comprise the message in a form of a plurality of rows. The first row of the plurality of rows may comprise a header. In one exemplary embodiment, the input file may preferably be the flat file or the XML file that may be written in scripting language such as JavaScript or the user may define definitions of a script.
[031] In one embodiment, the parser 210 may be configured to capture a plurality of elements present in the message from the header. An element of the plurality of elements is indicative of at least one of a data type, or an asset class, or an attribute corresponding to the message. The asset class may comprise information pertaining at least one of financial information, or equities, or interest rates, or commodities or specific set of business functions or combination thereof.
[032] The element may comprise an input field associated with a data value. Further, the element may comprise at least one of an internal data with respect to name of the input field, or a javabean variable, or identification associated with a number of asset class, or a combination thereof. Further, the element may comprise the asset class, or a business event data related to a trade data from the message received. In one exemplary embodiment, the asset class may comprise a classification a group of messages.
[033] The elements in the message may be parsed by the parser 210 and may be converted to a FIX format. In one embodiment, the parsed message may be disseminated via the network 106 to other parties such as market participants, who may act on the message and consummate a trade.
[034] The parser 210 using the delimiter may split the header of the input file. The header may be split in order to obtain an array of the header. In one embodiment, the header and the input file may be parsed into rows. Each row of the input file may be parsed using different array by the parser 210. The array of the header may be used to present a JList. The JList may be presented to the user with a group of items comprising the message, and may display one or more columns such that the user may select the message from a list.
[035] In one embodiment, the mapping module 212 may be configured to map the element with a Financial Products Markup Language (FpML) element based upon at least one of the data type, or the asset class, or the attribute.
[036] The FpML element may be sort from an FpML schema for at least one of asset class or business events. Corresponding name of the FpML element may be determined along with an associated data. For example, the associated data such as the data type, occurrence, whether the FpML element may be an attribute may be determined for the FpML element. Further, an internal data may also be determined for the FpML element. For example, the FpML element may be determined for at least one of the internal data corresponding to an internal name, or identification number for the asset class, or a deal type, or a combination thereof. In one embodiment, the FpML element may comprise an FpML javabean instance. The FpML element comprising the FpML javabean instance, the internal data, etc, may be collected in an FpML element master database table. In other words, the FpML element master database table may comprise the FpML element.
[037] In one embodiment, a place holder may be created and the place holder may comprise an FpML mapping panel. The FpML mapping panel may comprise at least one of the JList, a JTable, or a file browser, or a combination thereof. The file browser may be used to receive the input file from the memory 206. The JTable may be used to display and edit the FpML element master database table. The JTable may use at least one integer in order to refer to both rows and columns of the FpML element master database table while displaying. In one exemplary embodiment, the columns may be rearranged in the JTable such that arrangement of the columns may appear in a different order for the column in the FpML element master database table. The rearrangement may not affect the mapping when the columns are reordered. The JTable may maintain a new order of the column internally and may convert the column indices before implementation of mapping based on the rearrangement of the column.
[038] The asset class and the business event of the FpML element may be received such that the element of the input file may be mapped using the mapping module 212. The input file may be received through the file browser. In one embodiment, the input file may be received from the external database (not shown) through the file browser. The header parsed by the parser 210 may comprise the element to be mapped in the form of a list. The list may be referred as an input header list for explaining following embodiments.
[039] In order to map the element with the FpML element, the FpML element may be retrieved from the FpML element master database table. An FpML list comprising the FpML element may be created. The FpML list may be referred as an FpML header list for explaining following embodiments.
[040] In one embodiment, the asset class and the business event of the FpML element may be queried in the FpML element master database table. The FpML element may be queried in order to create a hashmap comprising a relationship of the element with respect to the FpML element. The hashmap may be implemented to map the element to the FpML element. The hashmap may be implemented using existing technique as is well known to the persons skilled in the art. The JList may be created for the input header list comprising names of the element corresponding to the input file.
[041] The user may select the element to be mapped with the FpML element. The element from the input field of the input file may be mapped with the FpML field. The element to be mapped may be presented to the user using the JTable. The JTable comprising the FpML element may be referred as a mapping grid. The user may select the element from the input header list to be mapped with the FpML element in the FpML header list. Depending on the selection from the FpML header list, the FpML element may be populated into the mapping grid. For example, from the FpML header list, the FpML element such as the data type, the occurrence may be populated into the mapping grid.
[042] The mapping may be repeated until the FpML field required is mapped. In one embodiment, the mapping module 212 compares the element with the FpML element to verify the mapping. The mapping module 212 may notify the user when the element is not mapped with the FpML element. Further, in one exemplary embodiment, the mapping module 212 may store the FpML element required to be mapped that may be mandatory. The mapping module 212 may verify when the input filed is being mapped to the mandatory fields in the FpML element. The user may store the FpML element corresponding to the element when the mapping module 212 determines that all the input fields have been mapped to the FpML fields. Further, the mapping module 212 may receive the FpML element information from the mapping grid in order to trigger an instruction to the FpML element master database table to store the relationship between the element and the FpML element.
[043] Referring to FIG .3, a method 300 for mapping the element with the FpML element is shown, in accordance with an embodiment of the present disclosure. The order in which the method 300 is described and is not intended to be construed as a limitation, and any number of the described method blocks can be combined in any order to implement the method 300 or alternate methods. Additionally, individual blocks may be deleted from the method 300 without departing from the scope of the disclosure described herein.
[044] At step 302, information may be received on the asset class and the trade deal required for the transaction.
[045] At step 304, the element may be mapped with the FpML element. In one implementation, the asset class and the trade deal may be queried in the FpML element master database table. The FpML element may be queried in order to create the hashmap.
[046] At step 306, the element may be added in the JList for the queried asset class and the trade deal. In one implementation, the user may instruct the element to be considered from the JList.
[047] At step 308, a new row may be added in the JTable comprising information from the JList using the mapping grid for the element added.
[048] At step 310, the mapping of the element with the FpML element may be stored in the FpML element master database table.
[049] Referring to FIG .4, a method 400 for FpML conversion is shown, in accordance with an embodiment of the present disclosure. The order in which the method 400 is described and is not intended to be construed as a limitation, and any number of the described method blocks can be combined in any order to implement the method 400 or alternate methods. Additionally, individual blocks may be deleted from the method 400 without departing from the scope of the disclosure described herein.
[050] The header of the input file may be parsed into the element by the parser 210, as shown at step 402.
[051] The header of the input file may be mapped with the FpML element master database table in order to map the FpML element, as shown at step 404. In one implementation, the mapping module 212 may implement the mapping.
[052] The mapping module 212 may verify if the header is mapped with the FpML element, as shown at 406. If the FpML element is not mapped corresponding to the element, the mapping module 212 may notify the user indicating an error in the mapping of the element, as shown at 408.
[053] Further, if the element is mapped corresponding to the FpML element, the element may be converted into the FpML element, as shown at step 410.
[054] Further, if the element is mapped with the FpML element, the mapping module 212 may convert the element into the FpML schema or to a pre-defined FpML structure. In one implementation, a class from the asset class may perform the FpML conversion process. In one exemplary embodiment, the class may be an input file reader. The input file reader may identify the input fields in the input file. The input file reader may identify the data type of the messages, for example, the format or case sensitive of the message received in the input file.
[055] In one embodiment, if the mapping is present for the FpML element, the mapping module 212 may generate a javabean instance for the FpML element. The javabean instance may comprise a variable associated with a data value corresponding to the FpML element. The javabean instance may comprise at least one of a workerbean class variable or a tradebean object corresponding to the FpML element. The workerbean class variable comprises information for each of the FpML element present in the FpML element master database table. The tradebean object may comprise information regarding required transaction to be performed using the FpML element. In one embodiment, the tradebean object may be instantiated. Further, the workerbean class may be loaded with information corresponding to the FpML element.
[056] The workerbean class and the tradebean object may be passed into a decision block. The decision block may comprise the internal names of the element that may have been mapped in the FpML element master database table such that the FpML element master database table may comprise the internal names of the element in the FpML element. Further, in the decision block, the internal names corresponding to the element may be compared with the internal names in the FpML element using a pre-defined internal name.
[057] In one embodiment, the header and the input file may be parsed in rows. Each row of the input file may be parsed using different array by the parser 210. Further, with respect to number of columns present in the input file, a loop may be created. When parsing each row, the header may be passed to the decision block. If the element matches with the FpML element, the respective tradebean object may be mapped with the header of the input file. Each header may be parsed to match the header with the tradebean object until the entire header in the input file is mapped.
[058] In one embodiment, the tradebean object comprising information may be validated for all the FpML fields. In one implementation, the validation module 214 may be configured to validate the javabean instance. The tradebean objects may be validated to verify the presence of a value in the FpML field. If the required fields do not contain the value, notification may be generated indicating an error. Further, if the FpML filed contains the value, the value may be validated with a pre-defined FpML structure. The javabean instance may be validated by comparing the javabean instance with the pre-defined FpML structure.
[059] The validation may comprise verifying the message received in the input file. The input fields may be verified for presence of the value. The validation may comprise a basic validation or a business validation or a schema validation or a technical validation. The basic validation may comprise validating the number format, or the currency validation, or the date format. The number format validation may comprise validating presence of a decimal number with respect to position of dot(.) and comma(,). The presence of the dot(.) and comma(,) may be determined by selecting locale by the user. Further, the number format validation may comprise verifying of the number containing negative value or not. The business validation may comprise validating the trade date such that the date is not less than current date.
[060] In one exemplary embodiment, considering a number 12345.67 in a string format. The number format may be parsed by selecting the locale. If the number is present as 12345.67 or 1234567, then the validation module 214 may verify whether decimal indexer is used more than once or if character, other than numbers has been used. Upon validating the number, the validation module 214 may declare the value of the input field as invalid.
[061] The currency validation may comprise validating presence of currency value in three-letter form. For example, the currency value USD may represent currency of United States of American Dollar. The presence of currency value may be determined by selecting locale by the user. Further, the date format validation may comprise validating presence of a date field as may be defined by the FpML standard. The validation module 214 may accept other format of dates and may convert the date format to yyyy-mm-dd. In one exemplary embodiment, a dateformatclass may be used to verify the date format and parse the value. If any invalid value exists in the input field, an error may be presented to the user.
[062] The pre-defined FpML structure may comprise the FpML schema as may be defined by an FpML standard. The javabean instance generated for the FpML element may be validated by comparing with the pre-defined FpML structure.
[063] In one exemplary embodiment, the validation module 214 may validate the input field specific to foreign exchange rate as may be defined by the FpML standard. The validation module 214 may notify the user if the element is not same as the FpML element. For example, for the foreign exchange rate, the value for the currency must have to be positive. If the value in the input field is negative, the validation module 214 may notify the user indicating the negative value in the currency rate.
[064] Further, for the foreign exchange rate, if a forward point exists, then spot rate must exist. The validation module 214 may compare the value for the FpML field with the FpML standard value.
[065] In one embodiment, the validation module 214 may validate the FpML element with the standard FpML schema. Presence of the value in the FpML element is compared with the mandatory elements such as the data type and a layout of the FpML standard schema may validate the FpML element.
[066] In one embodiment, the validation module 214 may allow modifying the validations i.e. creating or editing validation for the FpML element. In one exemplary embodiment, the validation module 214 may validate the element as per a custom instruction by the user. The custom instruction may be performed in addition to the basic validation and business validation. For example, if the business validation indicates that the trade date can be any other date before current date, the user may add the custom instruction that the trade date cannot be less than one week prior to the current date. The validation module 214 may notify the user if any other date is before the one week from the current date as defined by the user.
[067] Further, upon validating the FpML element, the mapped FpML element may be presented to the user. The user may select the custom instructions and store in the FpML element master database table. Further, the custom instruction created may be added in the FpML field and may add the data type, or operators used and the value in a new asset class. Further, if the data type is determined by the custom instruction, the value may be verified for the tradebean object with the value stored in the FpML element master database table.
[068] In one embodiment, the validation module 214 may create an Extensible Markup Language (XML) data by generating an Extensible Markup Language (XML) layout based on the pre-defined FpML structure. The XML data may be created for a trade data using an Xstream class available from com.thoughtworks.xstream package. Further, the XML may be generated based on the FpML element and the pre-defined FpML structure using a transformer class available from javax.xml.transform package.
[069] The XML data may be compared with the pre-defined FpML structure or the FpML schema. The XML data may be compared using a validator class of javax.xml.validation package. Further, if an error exists while comparing, the user may be notified. Further, the XML data may be stored in the memory 206 upon validation.
[070] In one embodiment, the validation module 214 may generate a report comprising the validation performed on the FpML element.
[071] Referring now to FIG. 5, a method 500 for validating a message in an input file is shown, in accordance with an embodiment of the present disclosure. The method 500 may be described in the general context of computer executable instructions. Generally, computer executable instructions can include routines, programs, objects, components, data structures, procedures, modules, functions, etc., that perform particular functions or implement particular abstract data types. The method 500 may also be practiced in a distributed computing environment where functions are performed by remote processing devices that are linked through a communications network. In a distributed computing environment, computer executable instructions may be located in both local and remote computer storage media, including memory storage devices.
[072] The order in which the method 500 is described and is not intended to be construed as a limitation, and any number of the described method blocks can be combined in any order to implement the method 500 or alternate methods. Additionally, individual blocks may be deleted from the method 500 without departing from the scope of the disclosure described herein. Furthermore, the method can be implemented in any suitable hardware, software, firmware, or combination thereof. However, for ease of explanation, in the embodiments described below, the method 500 may be implemented in the above-described system 102.
[073] At step 502, the message may be received in the input file one or more sources.
[074] At step 504, a header in the message may be parsed to capture a plurality of elements present in the header. An element of the plurality of elements is indicative of at least one of a data type, or an asset class, or an attribute corresponding to the message. In one implementation, the header may be parsed by the parser 210.
[075] At step 504, the element may be mapped with a Financial Products Markup Language (FpML) element based upon at least one of the data type, or the asset class, or the attribute. In one implementation, the element may be mapped using the mapping module 212.
[076] At step 508, a javabean instance for the FpML element may be generated. The javabean instance comprises information corresponding to the input file mapped. In one implementation, the javabean instance may be generated by the mapping module 212.
[077] At step 510, the javabean instance may be validated using a pre-defined FpML structure by comparing the javabean instance with the pre-defined FpML structure. In one implementation, the validation may be performed by the validation module 214.
[078] The system 102 may be implemented in Financial Markets industry standard message formats such as Financial Products Markup Language (FpML) or FIXML based on FIX protocol. The system 102 may be integrated with the Financial Markets Solution or Capital Markets Products (CMP) in order to test specific and/or end-to-end functionality of the product, thereby enabling the implementation of the CMP in production. Further, the system 102 may be implemented as an application for Windows, LINUX, UNIX and any JAVA enabled environment.
[079] Although implementations of system and method for validating a message in an input file have been described in language specific to structural features and/or methods, it is to be understood that the appended claims are not necessarily limited to the specific features or methods described. Rather, the specific features and methods are disclosed as examples of implementations for validating a message in an input file. ,CLAIMS:WE CLAIM:

1. A method for validating a message in an input file, the method comprising:
parsing a header in the message to capture a plurality of elements present in the header, wherein an element of the plurality of elements is indicative of at least one of a data type, or an asset class, or an attribute corresponding to the message;
mapping, by a processor, the element with a Financial Products Markup Language (FpML) element based upon at least one of the data type, or the asset class, or the attribute;
generating a javabean instance for the FpML element, wherein the javabean instance comprises information corresponding to the input file mapped; and
validating, by the processor, the javabean instance using a pre-defined FpML structure, wherein the javabean instance is validated by comparing the javabean instance with the pre-defined FpML structure.

2. The method of claim 1, further comprising identifying a format of the input file.

3. The method of claim 1, wherein the mapping further comprises:
comparing the element with the FpML element; and
notifying a user when the element is not same as the FpML element.

4. The method of claim 1, further comprising creating an Extensible Markup Language (XML) data, the creating comprises:
generating an Extensible Markup Language (XML) layout based on the pre-defined FpML structure; and
transforming the XML layout to the XML data using the FpML element.

5. The method of claim 1, wherein the validating further comprises:
comparing the element with the pre-defined FpML structure; and
notifying the user when the element is not same as the pre-defined FpML structure.

6. The method of claim 1, wherein the javabean instance comprises a variable associated with a data value corresponding to the FpML element.

7. A system for validating a message in an input file, the system comprising:
a processor;
a memory coupled to the processor, wherein the processor is capable of executing a plurality of modules stored in the memory, and wherein the plurality of modules comprising:
a parser configured to capture a plurality of elements present from a header in the message, wherein an element of the plurality of elements is indicative of at least one of a data type, or an asset class, or an attribute corresponding to the message;
a mapping module configured to the map the element with a Financial Products Markup Language (FpML) element based upon at least one of the data type, or the asset class, or the attribute, wherein the mapping module further configured to:
generate a javabean instance for the FpML element, wherein the javabean instance comprises information corresponding to the input file mapped; and
a validation module configured to validate the javabean instance using a pre-defined FpML structure, wherein the javabean instance is validated by comparing the javabean instance with the pre-defined FpML structure.
The system of claim 7, wherein the plurality of modules further comprises a reception configured to receive the input file from a source.

8. The system of claim 8, wherein the reception module is configured to identify a format of the input file.

9. The system of claim 7, wherein the mapping module further configured to:
compare the element with the FpML element; and
notify a user when the element is not same as the FpML element.

10. The system of claim 7, wherein the validation module further configured to create an Extensible Markup Language (XML) data.

11. The system of claim 7, wherein the validation module further configured to:
compare the element with the pre-defined FpML structure; and
notify the user when the element is not same as the pre-defined FpML structure.

12. The system of claim 7, wherein the FpML javabean instance comprises a variable associated with a data value corresponding to the FpML element.

13. A computer program product having embodied thereon a computer program for validating a message in an input file, the computer program product comprising:
a program code for parsing a header in the message to capture a plurality of elements present in the header, wherein an element of the plurality of elements is indicative of at least one of a data type, or an asset class, or an attribute corresponding to the message;
a program code for mapping the element with a Financial Products Markup Language (FpML) element based upon at least one of the data type, or the asset class, or the attribute;
a program code for generating a javabean instance for the FpML element, wherein the javabean instance comprises information corresponding to the input file mapped; and
a program code for validating the javabean instance using a pre-defined FpML structure, wherein the javabean instance is validated by comparing the javabean instance with the pre-defined FpML structure.