Hierarchies on Segments

Do you have to use FSG's to build hierarchies over the segments..
Example Segment 1 = Business... I need a multi level hierarchy to group business'

Perhaps you are refering to the account group .csv file that is used ot decide how to group the chart of accounts. However, that does not include the multi-level hierarchy which is stored in
W_HIERARCHY_D.
Have you tried incoreporating the Essbase data in form of flattended hierarchy in W_HIERARCHY_D and use that for roll up of balances?
Thanks

Similar Messages

  • Shouldn't the direct interaction happen at logical level?

    hiya
    “An internal schema is an organization of data according to the technology being used to record it. This includes the terms for components recognized by each kind of data manipulation technology: relational database management system (DBMS) "tables," hierarchical DBMS "segments," object "classes," etc. It also includes the terms for the internal physical storage of data on the computer (cylinder, track, etc.). In the past, the DBMS terms have comprised the logical schema, and the physical storage terms have comprised the physical schema. The internal schema is really two: the logical schema which represents data in terms appropriate to a particular data manipulation approach as usually expressed in a database management system or DBMS (the "designer's view") and the internal schema which is concerned with the physical characteristics of storage on a storage device ("builder's view").Internal schema ( and thus logical schema ) is at level three of the ANSI / SPARC architecture.”
    Since I only know ( a little ) about relational database, I’m going to ask the following question in the context of relational database:
    Anyways, the way I understand the above paragraph is that logical schema is actually a level with which administrator directly interacts when he / she is creating new tables, keys etc. I assume this since conceptual level doesn’t know about tables, instead it knows only of objects ( entities ). Point I’m trying to make is that according to above definition of logical level the DDL statements such as:
    CREATE TABLE UH ( … )
    should operate at logical and not conceptual level, since conceptual level doesn’t know about tables! 
    Yet, as far as I know if there is clear distinction between conceptual and logical levels, then DDL operates at conceptual and SDL and logical level. That doesn’t make sense!
    BTW – I realize that most DBMS don’t have a clear separation between conceptual and logical level
    thank you

    I too assumed the phone mute button would silence the speaker in all places. I thought that's what it's for. But I wrote to EA for the Scrabble issue. I got a dumb generic response. Now today I got a servey asking me to rate their serivce response. Oy!

  • Error in outbound processing:ALE/IDOC

    Dear all,
    I am getting an error in outbound processing as follows(I have extended the BD12 IDOC for customer master).
    The issue is that there is no hierarchie of segments in IDOC transaction we05.(Thogh the hierarchie can be observed in WE30)
    EDI: Syntax error in IDoc (segment cannot be identified)
    Message no. E0078
    Diagnosis
    The segment Z1KNA1M_ADRC does not occur at the current level of the basic type DEBMAS06 (extension ).
    This error can have several reasons:
    u2022     The segment Z1KNA1M_ADRC is assigned to a group whose header segment does not occur.
    u2022     The segment Z1KNA1M_ADRC does not exist in the syntax description of the basic type DEBMAS06 (extension ).
    u2022     The sequence of segments in the group in which the segment appears is incorrect.
    Previous errors ('mandatory' segment or group missing) may be due to this error.
    Procedure
    Please check the IDoc or the syntax description of the basic type DEBMAS06 (extension ).
    I will be thankful if anybody can help resolve the issue.
    thanks.
    Edited by: sanjivrd on Aug 4, 2009 2:17 PM

    hi,
    after adding those segments you need to release it.
    check it menu you can see the release option, you need to release it.
    then only it will work
    [Refer following link|EDI: Syntax error in IDoc (segment cannot be identified)]
    In the menu edit-> set release
    click on it and release
    Even check If the Hierrarchy of the segment is correct. This also will result in Syntax Errors.
    thanks & Regards,
    ShreeMohan

  • DIFFERENCE BETWEEN iDOC MESSAGING AND bDOC MESSAGING

    hI
    gurus what is the diffrence between idoc messaging and bdoc messaging?
    K. Mangalum

    Hi Kumara,
    BDOC:
    Container of business data that belongs together, for example customer, contact person, order or activity. This means that it contains all required information for a business process. The technical representation of a BDoc type is completely independent. There are many possible representations for a BDoc type.
    For example, a BDoc type can be represented as follows:
    as a collection of internal ABAP table structures (on the CRM Server),
    by ADO record sets (on mobile clients),
    as an XML form (for non-SAP systems), or,
    as an IDoc.
    Therefore a BDoc type is a semantic collection of business data and not a syntactical description.
    There are three classes of BDoc types:
    BDoc types exclusively used for mobile applications
    They consist of a hierarchical data segment structure with assignment to database tables.
    BDoc types for synchronization between the consolidated database in the CRM Server and mobile applications
    They consist of a hierarchical segment structure with assignment to database tables.
    BDoc types exclusively used for non-mobile applications
    They consist of:
    a hierarchical segment structure with no assignment to database tables,
    additional data (complex data type modeled in the ABAP Dictionary)
    Standard BDoc types are provided by SAP. Additional BDoc types can be modeled by customers.
    Idoc:
    IDOC: An intermediate document, container for exchanging data between R/3 and other SAP and non-SAP applications. Structured collection of segments. Segments are structured collection of data elements.
    General Structure
    IDocs contain administration information for technical processing, as well as the actual application data, which is stored in segments. A segment comprises segment fields as the smallest unit of the IDoc - comparable with the data elements from the EDIFACT standard.
    In the SAP System, the processing status ("what has happened to the IDoc before now?") is stored in the IDoc status information. The status information also contains details about errors and indicates the data in which the error occurred. This status information is not forwarded as part of the IDoc but separately using "status processing".
    IDoc types (special structure)
    An IDoc type is defined through its permitted segments. Segments can be dependent on each other (parent and child segments). For example, segment E1EDPT1 (document item text identification) is a child segment of segment E1EDP01 (document item data, general) in IDoc type EXPINV01 (export billing) and a child segment of E1EDP07 (order data shipping notification) in IDoc type DESADV01 (shipping notification). The segment, therefore, is used in several contexts and is the "child" of several "parents".
    CRM Bdoc and IDoc are both persisted data structures.
    Idoc works on a particular technology called ALE and is used for data exchange between two R/3 systems
    Regards,
    Satish Mathala

  • Support for Multiple Hierarchies defined for the same GL Segment

    Hi,
    In our eBS setup, we have multiple hierarchies defined for a GL Segment.
    OOTB, BI Apps 7.9.6.3 provides support for 10 Segments, and it's corresponding Hierarchies (1 Hierarchy for each Segment).
    My question here is whether OOTB BI Apps 7.9.6.3 supports Multiple Hierarchies for the same Segment?+
    Thanks,
    Ab

    no it is not supported OOTB as of today
    you need to customize ETL mappings and OBIEE metadata to include hierarchy identifiers from the EBS segment definitions.
    Then you have to consider that filtering a hierarchy identifier becomes mandatory during query execution to avoid aggregation of duplicated values.

  • Segment number &  Numer of hierarchically higher SAP segment

    experts
    how to know the segment number &  Num of hierarchically higher SAP segment
    of the idocs?
    edi_dd-segnum -Number of SAP segment
    edi_dd-psgnum -Num of hierarchically higher SAP segment
    i have the problem in populating the hierarchy  and number of segment for orders05 idoc?
    ORDERS05                       Purchasing/Sales
           E1EDK01  IDoc: Document header general data
           E1EDK14  IDoc: Document Header Organizational Data
           E1EDK03  IDoc: Document header date segment
           E1EDK04  IDoc: Document header taxes
           E1EDK05 IDoc: Document header conditions
           E1EDKA1  Doc: Document Header Partner Information
               E1EDKA3                        IDoc: Document Header Partner Information Additional Data
           E1EDK02                        IDoc: Document header reference data
           E1EDK17                        IDoc: Document Header Terms of Delivery
           E1EDK18                        IDoc: Document Header Terms of Payment
           E1EDK35                        IDoc: Document Header Additional Data
           E1EDK36                        IDOC: Doc.header payment cards
           E1EDKT1                        IDoc: Document Header Text Identification
               E1EDKT2                        IDoc: Document Header Texts
           E1EDP01                        IDoc: Document Item General Data
           E1CUCFG                        CU: Configuration data
           E1EDL37                        Handling unit header
           E1EDS01                        IDoc: Summary segment general.

    thanks for the reply Alexander.
    i checked in we30, after clicking on the segment in the pop up box we can see
    the herichey level ie hlevel of the segment.
    Now how to know the segnum(segment number) of the segment?
    actually i am populating EDI_DD40, so i need the segnum.
    In edi_dd40 we have following
    SEGNAM = name of segment ex E1EDK01
    MANDT = sy-mandt
    DOCNUM = no need because i am generating idoc
    SEGNUM = ? I want to know from where i can get this
    PSGNUM = ? I want to know from where i can get this
    HLEVEL= this can be seen in we30
    SDATA = this is the fields we need to fill .
    so experts tell me from where i need to get psgnum and segnum?

  • Financial Analytics - segment and FSG hierarchies

    Is it possible to define 6 segments and then additionally define FSG hierarchies in the same implementation of financial analytics ?
    We have 6 segments defined in our Oracle EBS application so I have set the gl_account_segment_config to include those segments.
    I have also modified the BMM to use the correct segment_lov_id for all 6 segments. This all works correctly no problems.
    I am now setting up the FSG hierarchies required by the business.
    I have modified file_gl_hierarchy_assignment_ora.csv to include 4 of my FSG hierarchies...
    Unfortunately I do not see these coming into the database tables. I have the following set in the DAC -
    Oracle - Extract FSG hierarchies -
    Oracle - Extract Value Set Hierarchies - inactive.
    Any help greatly appreciated....

    See My Oracle Support note 1050724.1. Engineering have stated that using the two hierarchy methods is not supported.

  • Code Combinations for Segment Hierarchies

    Dear Members,
    I have one question on Hierarchies in GL Accounting Flex fields. I read the documentation on Flexfield hierarchies, in which its said that generally hierarchies are used for only GL accounting flexfields.
    Suppose One of the Accounting Flexfield Segment Value hierarchy structure is like this :
    1000
    _________|_______
    100 200 300
    ____|____ ____|______
    101 102 301 302 303
    _______|______
    303A 303B 303C
    __|__
    303BB
    This hierarchy is not coming properly when i post it so i am explaining it in detail here :
    Parent Child
    1000 ---> 100 200 300
    100 ----> 101 102
    300 ---> 301 302 303
    303 ---> 301A 303B 303C
    303B --> 303BB
    Here 1000 is the parent which has childs and they inturn have childs. This is used maily for reporting purpose in GL. I do not understand how a code combination is generated for the above structure in gl_code_combination table.
    Suppose we have 5 segments in our accounting flexfield structure
    ex: seg1,seg2,seg3,seg4,seg5 and 1000 in the above mentioned structure is seg3.
    how does a combination is generated if we want the information pertaining to 303BB which is the leaf node value in the hierarchy.
    seg1.seg2.seg3.seg4.seg5 --> how does this change if we have hierarchies.
    It would be great if you can help me out in this.
    Thanks
    Sandeep
    Message was edited by:
    user340
    Message was edited by:
    user340
    Message was edited by:
    user340

    Hi :
    1000 is a parent ---> 100 200 300 are chid
    100 is a parent ----> 101 102 are chid
    300 is a parent ---> 301 302 303 are chid
    303 is a parent ---> 301A 303B 303C are chid
    303B is a parent --> 303BB
    Here 1000 is the parent which has childs and they inturn have childs. This is used maily for reporting purpose in GL. I do not understand how a code combination is generated for the above structure in gl_code_combination table.
    seg1,seg2,seg3,seg4,seg5 and 1000 in the above mentioned structure is seg3.
    a combination is generated for every single combination oif child values (child valued should be posting allowed = yes meanwhile parent values should be posting allowed = no) for every segment
    so at the end the combination is created whenever you use child value for every single segment
    if you have rollup groups associated to the parent values, you can define summary accounts and balances are going to be automatically updated for parent values so even you can query onbalances on parent values
    I hope this gives you some light

  • GL Balances with segment Hierarchies in Discoverer

    Does anyone here have the need to report on GL balances using the Account segment hierarchies?
    The only way users can utilize the GL segment hierarchies is through FSG reporting and some other products such as DBI and EPF.
    Each segment in GL accounting flexfield can have one or multiple hierarchies and the hierarchies are defined as parent child relationship in the FND_FLEX_NORM_HIERARCHY table. Because of the nature of the way these hierarchy is defined in GL it cannot be directly consumed for Discoverer reporting.
    To take advantage of these hierarchies in Discoverer, I have developed a solution that flattens the hierarchies in one go and the flattened hierarchy can then be mapped to Discoverer hierarchies. Once this is established, users can truly benefit from Drilling down and rolling up feature of discoverer hierarchy and I have seen users just love this feature. I am sure this can be adapted to OBIEE too.
    If you would like to know more about this solution, please let me know njethwa @ gmail . com
    Thanks and Regards
    Nilesh
    http://www.infocaptor.com

    You can find the code and documentation here
    http://www.infocaptor.com/dashboard/gldisco
    Design Dashboards

  • How to go to a particular node in a hierarchical tree?

    I want to do this simple thing with a Forms hierarchical tree.
    Since tree has lots of levels and branches I want to give a search box.
    User types the label and press a button. The form then has to query the tree node and expand ONLY the path where the node is (if found) and highlight it. If a node with a label is NOT found I give an error message to the user.
    I got hold of a code segment to explode a tree and modified it, but it does not work. The entire tree is expanded and you don't know where you are.
    Any help will be greatly appreciated?
    PROCEDURE Expand_All_Nodes_in_Tree IS
         node ftree.node;
         htree ITEM;
         state varchar2(30);
    BEGIN
         -- Search the tree identifiant --
         htree := Find_Item('menu.tree');
         -- Search the root --
         node := Ftree.Find_Tree_Node(htree, '');
         -- Expand all nodes --
         WHILE NOT Ftree.ID_NULL(node) LOOP
         state := Ftree.Get_Tree_Node_Property(htree, node, Ftree.NODE_STATE);
         IF state = Ftree.COLLAPSED_NODE THEN
         Ftree.Set_Tree_Node_Property(htree, node, Ftree.NODE_STATE, Ftree.EXPANDED_NODE);
         END IF;
         node := Ftree.Find_Tree_Node(htree, '', ftree.find_NEXT,Ftree.NODE_LABEL,'', node);
    IF Ftree.Get_Tree_Node_Property(htree, node, Ftree.NODE_LABEL) = :ctrl.node_lable_to_search THEN
    EXIT;
    END IF;     
         END LOOP;
    END;

    Hi Channa,
    Try this code with you tree i am using the same situation and this code is working perfect with me.
    PROCEDURE find_node_in_tree(search_string varchar2, find_type varchar2) IS
    htree ITEM;
    search_start_node ftree.node;
    find_node ftree.node;
    BEGIN
    htree := Find_Item('blk_tree.main_tree');
         search_start_node := nvl(ftree.get_tree_selection(htree,1),ftree.root_node);
         find_node := ftree.find_tree_node(htree,upper(search_string)||'%',ftree.find_next,ftree.node_label,ftree.root_node,search_start_node-1);
         if find_node = 0 then
              find_node := 1;
    end if;
    Ftree.Set_Tree_selection(htree, find_node, Ftree.SELECT_ON);
    exception
         when others then
              NULL;
    END;
    -Ammad

  • Hierarchical structure to Flat Structure mapping in Message mapping

    Hi Experts,
       I need to map the below hierarchical segments of SHPMNT03 IDOC XML to  repitative stucture G_SHL of 857 EDI XML.
    Segments from IDoc.
    E1EDT20(Shipment)
    E1EDL20(Delivery)
    E1EDL24(Delivery Line Item)
    E1EDL44(IDoc: Handling Unit Item Delivery) for Pack)
    Required Target Segment:
    SHIPMENT HL (BOL)
    DELIVERY HL (PO NUMBER 1)
    ITEM HL (PART A)                       
    PACK HL (1ST BUNDLE)
    PACK HL (2ND BUNDLE) 
    ITEM HL (PART B)
    PACK HL (1ST BUNDLE)
    DELIVERY HL (PO NUMBER 2)
    ITEM HL (PART A)
    PACK HL (1ST BUNDLE)
    PACT HL (2ND BUNDLE)
    PACK HL (3RD BUNDLE)
    Please let me know how to achive this.
    I tried to achive this by changing the context of the target field, but in that case I am loosing the sequence. I get all delivery together, all Item together..like this.Please tell me how to retain the sequence.
    Please reply ASAP.
    Thanks in advance,
    Shweta.

    Hi Sushama,
    Could you be bit more elaborative on the problem. What exactly is the error ?? what is the source/target structure ? with this information one would be able diagnose the scenario assist you!!!
    Regards
    Manju

  • Adding field in standard IDOC Segment E1EDL24

    Hello Friends,
    I have an urgent requirement that I have to extend IDOC segment E1EDL24 with two fields PABNR and LFSNR.
    When I tries to change the segment in WE31, it shows an error message that you can only modify the segments of customer namespace and cannot modify Standard IDOC Segments.
    Can we modify the standard IDOC segments, and if yes, how can we modify the standard IDOC segments. Please clarify.
    Points will be rewarded generously.
    Regards,
    Navin

    Hi Naveen,
    We cannot Modify the Standard segments. But we have to Create a new Segment and Add these fields.
    Then Create an Extended Idoc type
    Implement User Exits in Outbound And Inbound ..
    This is the Complete Steps and Info on this...with an Example...
    Enhancing ALE
    For example, if in an outbound interface you find that the IDOC type does not contain all the data you need to pass to the other system, you can extend the IDOC to accommodate the additional fields and enhance the ALE function modules to populate the fields. Similarly, if in an inbound interface, there is additional data that needs to be posted to the R/3 application, you can extend the IDOC type to have additional fields populated by the external system or translator or the other R/3 system and then enhance the inbound ALE function modules to post the additional data to the R/3 application.
    let us use the SAP Customer Master application as an example. Specifically, letâs focus on the IDOC extension and ALE function module enhancement of IDOC type DEBMAS02 and message type DEBMAS (Customer Master) and the IDOC reduction of message type MATMAS.
    IDOC EXTENSIONS
    Letâs first look at the concept of IDOC extension. SAP delivers Basic IDOC types such as DEBMAS02, MATMAS02, ORDERS02, and WMMBID01. By extending the Basic IDOC type, you are actually creating a new IDOC type. You create a new segment with the additional fields. This new segment has to be associated with one of the existing Basic IDOC segments. Then you create a new extension type, which is associated with the Basic IDOC type. This results in a new IDOC type. In order for ALE function modules to relate to this new IDOC type, the IDOC type is linked to the corresponding message type.
    Note that you should not add fields to existing segments but should create a new segment and associate it with an existing segment. This, in a nutshell, is the process of creating IDOC extensions.
    In our example, the Basic IDOC type DEBMAS02 is used to communicate Customer Master data to the SAP Customer Master application. Even though the application has a screen to enter and store a contact personâs business address (see Figure 1), DEBMAS02 does not have a segment or fields that communicate the contact personâs business address. If your business requires that this business address be communicated to the other system through the ALE interface for Customer Master, then you have to extend the DEBMAS02 IDOC type, and enhance the corresponding ALE function module.
    In DEBMAS02 the contact person fields are present in segment E1KNVKM and the business address of the contact person is stored on the SADR SAP table. You need to create a new segment, Z1SADRX, that is associated with E1KNVKM. This will be done in the process of creating an extension type ZDEBMASX. This extension type will then be associated with a new IDOC type, ZDEBMASZ. IDOC type ZDEBMASZ will be linked to message type DEBMAS for Customer Master. The final step in the IDOC extension process is to check the new objects. This check also verifies the structural integrity of the IDOC type. Letâs look at each of these steps in more detail.
    1. Create an Extension Type and a New Segment.
    Determine the fields on table SADR that you are going to provide for in the new segment Z1SADRX. You need fields for name, street, city, region, and country to give the business address of the contact person. You also need fields for the address number. ADRNR is a field in SAP tables such as SADR that uniquely identifies the address of an entity. This field is cross-referenced from other tables to the SADR table to obtain the full description of the address. Because this is an IDOC type for master data, the first field of the new segment will be MSGFN. The message function field informs the receiving system of the action to be taken for that particular segment. In the code that you write for populating the new segment, the value of the message function is the same as that of the parent segment E1KNVKM. In all, you will have 12 fields in segment Z1SADRX (see Table 1).
    To create an extension type and new segment:
    • Use transaction WE30 or from WEDI go to Development -> IDOC types.
    • Enter ZDEBMASX for Object Name.
    • Choose Extension Type.
    • Click on Create.
    • You will see a pop-up screen. Choose Create New, and enter a description. For version 4.x, enter DEBMAS02 in the Linked Basic Type field. Enter.
    • You will see a screen with ZDEBMASX and its description in the first line. Click on this line, and press Create. For version 4.x, expand the tree of segments, and place the cursor on E1KNVKM.
    • You will see a pop-up screen. Enter E1KNVKM as the reference segment. Enter.
    • For 4.x, press Create after placing the cursor on segment E1KNVKM.
    • You will see a line appear with E1KNVKM hierarchically below ZDEBMASX, with a description "Customer Master contact person (KNVK)."
    • Click on this line and press Create. You will receive a message indicating that the new segment being created will be a child segment of E1KNVKM. Enter. A pop-up box appears for the new segment.
    • Enter Z1SADRX as the segment type, 1 for Minimum, 1 for Maximum. Leave Mandatory segment unchecked. These entries imply that there is only one Z1SADRX segment for every occurrence of the E1KNVKM segment, and also that this segment is not mandatory. Note that if the parent segment is not mandatory, then the child segment should not be mandatory, because this could result in a syntax error during the creation or processing of the IDOC.
    • For 4.x, you must first create the IDOC segment Z1SADRX (Iâll explain why in a moment) from the menu path WEDI -> IDOC -> Development -> IDOC Segment.
    • Click on Segment Editor.
    • On the next screen, click on Create.
    • Enter a development class for the object. Enter.
    • This will take you to the screen for segment definition. Enter a description for the segment. Enter the field name, data element, and the data element documentation name. In most cases, all three fields may have the same values. If you are using a field in the segment that is not present in the ABAP/4 data dictionary, you must first create the domain, data element, field, and appropriate documentation before using it in the new segment.
    • Enter these three columns for all 12 fields. Save.
    • Click on Generate/Activate, F3 to step back.
    • From screen Maintain Segment, go to Segment Type -> Release. A checkbox now appears beside the segment definition Z1SADRX (see Figure 2). Check this box. Save.
    • Save again to store the descriptions of the segment, F3 to step back.
    • Save the extension type.
    It is possible to have several new segments with relevant Basic IDOC type parent segments in a single extension type. However, you can form only one IDOC type based on a single extension type.
    2. Create an IDOC Type.
    The next step is to create an IDOC type by associating the extension type that you created with the Basic IDOC type. This is a simple process:
    • From transaction WE30 or WEDI go to Development -> IDOC Types.
    • Enter ZDEBMASZ for Object Name.
    • Click on IDOC Type.
    • Click on Create.
    • Enter DEBMAS02 for Basic IDOC type.
    • Enter ZDEBMASX for extension type.
    • Enter a description.
    • Enter.
    • You will see a display of the composite IDOC type with all segments, including Z1SADRX (see Figure 3).
    It is possible to associate only one extension type with a Basic IDOC type for a given IDOC type. However, you can have multiple new segments in an extension type.
    3. Link IDOC Type to Message Type.
    The next step is to link the new IDOC type to its corresponding message type. This is important, because this relationship is referenced in the partner profile parameters where you specify the message type and IDOC type to be used for that particular representative system. To link the message type:
    • Use transaction WE82, or from WE30, go to Environment -> IDOC Type / Message Type, or from WEDI go to Development -> IDOC Type -> Environment Î IDOC Type / Message Type.
    • Click on Display <-> Change.
    • Click on New Entries.
    • Enter DEBMAS for message type.
    • Enter DEBMAS02 for Basic IDOC type.
    • Enter ZDEBMASX for extension type.
    • Enter your SAP R/3 release number for Release.
    • Save.
    This data is stored on the EDIMSG table and is accessed by several ALE processes to relate the message type to the IDOC type.
    4. Check the IDOC Type.
    Before checking the IDOC type for consistency, it is important to perform another step that releases the extension type to the IDOC type:
    • From WEDI go to Development -> IDOC Types -> Extras -> Release Type, or from transaction WE30 go to Extras -> Release Type.
    • For the Object Name ZDEBMASX and radio button Extension Type, click Yes.
    • The extension type has now been "released."
    You canât edit the extension type once itâs released. To cancel the release for further editing or deactivation, go to WE30 Î Extras Î Cancel release. The final step in the IDOC extension process is checking the validity of the IDOC type:
    • From transaction WE30 or WEDI go to Development -> IDOC types.
    • Enter ZDEBMASX for Object name.
    • Click on Extension Type.
    • From the Development Object menu select Check.
    • Repeat the operation for IDOC type ZDEBMASZ.
    • A check log will be generated for each run with details of correctness or errors (see Figure 4).
    In some situations it is possible to receive errors during the check process, especially segment length errors. The incorrect IDOC segment can be repaired and corrected by executing program RSEREPSG. This program checks the formal consistency and repairs incorrect segments. In test mode it will generate a log of formal correctness for the specified segment only. For the program to repair segments in normal mode, the underlying IDOC structures (DDIC structures) must be active. This program rectifies the lengths of the DDIC structures and not the fields themselves. RSEREPSG can also be used to change the person responsible for the object and the release flag.
    Menu paths may vary slightly depending on the release/version of SAP R/3, but the procedures and the principles are the same.
    ALE FUNCTION MODULE ENHANCEMENTS
    Having extended the IDOC type to contain additional fields for an inbound or outbound application, you now want to enhance ALE function modules for populating the additional segment on the outbound or applying the additional segment data on the inbound application.
    The core working code for ALE processes for a given application area is always encapsulated in ABAP/4 function modules. These function modules are associated with such control information as message types and process codes. So the ALE process checks this control information and derives the name of the function module to invoke for that particular IDOC processing from certain database tables. These function modules contain objects known as customer functions, which can be considered SAP Enhanced user exits. A function module is called at a particular point during the processing of the main program or function module, and it can be used to influence data processing at that point by adding code to the customer function. The customer function behaves like a normal function module and has import and export parameters, tables (internal tables) statement, and exception processing. Unlike a conventional user exit, customer functions give you the ability to modify only data available to you by the function moduleâs parameters and internal tables. While most ALE/EDI function modules are supported by customer functions, there are ALE/EDI processes that still use conventional user exits. There are a few ways to determine which function module to enhance for a given message type/process code:
    • For master data distribution, from SALE go to Extensions -> Master data distribution -> Setup additional data for message types. Search for message type DEBMAS in this example. You see an entry for DEBMAS associated with function module MASTERIDOC_CREATE_SMD_DEBMAS. This data is stored on table TBDME. The function module names for all master data message types follow this pattern: MASTERIDOC_CREATE_SMD_messagetype. This function module calls another function module of name MASTERIDOC_CREATE_DEBMAS or MASTERIDOC_CREATE_messagetype. Search for the words customer function, and you find several hits that can be used to add code to the function module.
    • From WEDI got to Control -> Inbound process codes -> Inbound with ALE service -> Processing by function module (transaction WE42), or from WEDI go to Control -> Outbound process codes -> Outbound with ALE service -> With function module (transaction WE41). There will be function modules associated with the process codes. For inbound, the function modules usually follow this pattern: IDOC_INPUT_messagetype: for example, IDOC_INPUT_CHRMAS for inbound characteristics master.
    • Use transaction WE57 or from WEDI go to Development -> Message/Application Object. The entries list the function module, Business Object, message type, and IDOC type that are used for inbound ALE/EDI interfaces.
    Customer functions are not specific only to ALE and EDI but also to all programs/modules in SAP R/3. Customer function is a SAP enhancement component; the other two types are menu and screen enhancements.
    All customer function exits are maintained in SAP enhancements and are found by using transaction SMOD. After executing transaction SMOD, pull down (F4) on the enhancement name field, and execute again. This provides you with a list of all SAP enhancements available. SAP enhancements are grouped by development class pertaining to an application area. Choose Application development R/3 SD master data distribution for development class VSV to lead to a screen that lists VSV00001 as an enhancement (see Figure 5). Press Component +/- to display its function exit components. There are four possible components listed, all of which are function exits (and are function modules) that are called from the ALE function modules in the form Call Customer Function Î001â. This is a special occurrence of the ABAP statement Call. Go to item Exit_SAPLVV01_ 001, which you need to enhance for the Customer Master outbound example of an IDOC extension. In the ALE-function module MASTERIDOC_CREATE_DEBMAS, the statement CALL Customer Function 001 is translated in the background to call component EXIT_SAPLVV01_001. Although this function exit can be edited using transaction SE37, you will use a simpler approach.
    When you use SAP enhancements and their components, you manage them with an SAP object known as a project, which is like an envelope containing the selected enhancements and their components. A project can be used to control the execution of components and to transport them to other clients and instances in SAP. Basically, the process involves creating a project, including enhancements and components that are to be enhanced, editing the components, and then activating the project. The following process creates a project for our example Customer Master IDOC extension:
    • Execute transaction CMOD.
    • Enter name of project, say CSTMAST1.
    • Click on Create.
    • Enter a description of the project.
    • Save.
    • Click on SAP Enhancements.
    • Enter VSV00001 for Enhancement.
    • Save.
    Once youâve created the project, edit the function exit components and activate the project. Remember that the code in the function exit enhancement will execute only if the project is activated. In fact, this is a convenient SAP enhancements feature, whereby the work in progress (developing code in the customer function) will not affect users of that application. When the code is completed, the project can be activated so the enhanced functionality takes effect. It can also be deactivated for maintenance.
    As mentioned earlier, customer functions (function exits) are embedded in ALE function modules and can be used to influence the creation and modification of IDOC data on an outbound application or to post additional or modified IDOC data to an inbound R/3 application. Function exits are similar to regular function modules, with import/export parameters, tables (internal tables), and exceptions.
    The two important factors to consider while developing the customer function are:
    1. The point in the ALE function module where the function exit occurs
    2. The data made available by the customer function that can be modified or posted to the R/3 application, based on the direction.
    Because some function modules have several customer functions, it is critical to choose the function exit best suited for that particular enhancement. Do not attempt to perform activities that the function exit is not designed for. The importance of this point is illustrated by the following description of enhancing function modules for outbound and inbound ALE interfaces.
    Outbound interfaces. In an outbound ALE interface you use function exits (customer functions) to populate additional segments created by an IDOC extension or to modify the existing IDOC data segments as per business requirements. Previously, you identified that enhancement VSV00001 has a component EXIT_SAPLVV01_001 (function exit), which can be used for populating the additional data segment Z1SADRX that you created in the IDOC extension ZDEBMASX (IDOC type ZDEBMASZ, based on Basic IDOC type DEBMAS02). You also learned that the ALE function module that calls this function exit is MASTERIDOC_CREATE_DEBMAS, which has a statement Call Customer Function 001.
    Browse the function module MASTERIDOC_CREATE_DEBMAS using transaction SE37. You will find that this customer function is invoked for every segment of IDOC type DEBMAS02. In fact, the function exit is called soon after the creation of an existing segment has been populated with data and appended to the IDOC data table (internal table). Also, the function exit is exporting the message type, IDOC type, and the segment name and is importing the IDOC extension type. It is also passing the IDOC data internal table. This indicates that the ALE function module is allowing you to populate additional segments for every existing segment and modify the existing segmentâs data.
    Letâs write ABAP/4 code to accomplish the task of populating IDOC segment Z1SADRX with a contact personâs business address:
    • From SE37, display function module MASTERIDOC_CREATE_ DEBMAS.
    • Find Customer Function 001.
    • Double-click on 001.
    • The function EXIT_SAPLVV01_001 will be displayed.
    • Double-click on INCLUDE ZXVSVU01.
    • You will be asked to create a new include object. Proceed as desired.
    • Enter code (as in Listing 1).
    • Be sure to perform a main program check (Function Module -> Check -> main program) and extended program check (Function module -> Check -> Extended check).
    Now that you have extended the IDOC and enhanced the ALE function module based on the requirements for the contact personâs business address on the Customer Master, letâs test the interface. You should create a logical system and define a port for this interface. You should also configure the Customer Distribution Model to indicate that message type DEBMAS is being distributed to this logical system. The only difference in configuration between a regular outbound ALE interface and an enhanced one is the partner profile definition. While maintaining the outbound parameters of the partner profile, make sure the IDOC type is ZDEBMASZ. The fields for Basic IDOC type and extension type are automatically populated with DEBMAS02 and ZDEBMASX, respectively.
    To maintain the contact personâs business address of a customer:
    • Use transaction BD12 or from BALE go to Master Data ->Customer -> Send and send that Customer Master record by executing the transaction after filling in the relevant fields such as customer number, message type, and logical system.
    • Use transaction WE02 or WE05 to verify the IDOC created. You should see the new segment Z1SADRX populated with the correct data.
    With SAP releases below 4.5B, you cannot capture changes to business address through change pointers because a change document object is not available for capturing business address changes, and also earlier releases have not been configured to write change documents for a contact personâs business address. If you would like this functionality, you can either create change document objects, generate function modules to create change documents, and perform ALE configuration to tie it in, or make a cosmetic change to the contact person screen data while changing the contact personâs business address so that it gets captured as a change to the Customer Master. Subsequently, the ALE enhancement that you performed captures the contact personâs business address.
    Inbound interfaces. The process for enhancing inbound ALE interfaces is similar for outbound, with a few exceptions; specifically in the coding of customer functions (function exits) for the ALE/EDI function modules.
    The first step is to create an IDOC extension for the specific Basic IDOC type by adding new segments at the appropriate hierarchy level: that is, associated to the relevant existing segment. Populate the data fields on the new segments with application data by the translator or external system/program before importing them into the R/3 System. Then, find the ALE function module that is invoked by the inbound processing. By browsing through the code or reading the documentation on the function exit enhancements using the SMOD transaction, identify the function exit in which you should place your code. The technique used in the code to post the additional or modified IDOC data to the application can vary based on the application rules and requirements, the data available at that point in processing, and the application function modules available to update the application tables. It is important to search first for application modules that process the data and see if they can be called within the function exit. If the additional data in the extended segments in specific to a custom table or resides in nonkey fields of a single or small set of tables, you may be able to update it directly by SQL statements in the function exit. This approach should be carefully evaluated and is certainly not highly recommended.
    Another option is to use Call Transaction from within the function exit to process the additional data. For example, in the case of message type WMMBXY for inbound goods movements from a warehouse management system, the standard interface creates batches for materials, but does not update its characteristics. In such a case, you can use Call Transaction MSC1 to create the batch and assign characteristic values to it from within the function exit provided.
    Error handling is a very important consideration when making enhancements to inbound ALE/EDI objects. In ALE and EDI inbound processing, workflow is used for handling errors at different levels such as technical and application. If workflow has been configured for the interface, the error messages and workflow items flow to the inbox of the named recipient(s).
    It is also critical to enhance the workflow that handles notifications of the inbound ALE/EDI process. In most scenarios this is not a very difficult task because SAP lets you influence the workflow parameters and messages in function exits (customer functions). You typically do this using flags and message codes to trigger certain workflow actions. If you conform to the status codes and flags stipulated for workflow processing, the enhancement could be error-free and seamless. In the case of an inbound IDOC with an extension, you should populate the EDIDC fields IDOCTYP (new IDOC type) and CIMTYP (extension type) accordingly.
    Reward if Helpful

  • Drill with multiple Hierarchies

    Hi,
    I have defined multiple hierarchies in an OLAP universe (like state>region>customer>product or state>region>customer segmentation>Product or state>region>product ...) in order to use the drill functionnality in webi.
    In our scenario, each webi report should use only one hierarchy and we don't want the user to have the choice between the different hierarchies when he drills down. So is there a way to define in a webi report what hierarchy should be used?
    Thanks,
    Gabriel

    hi,
    As 'State' object is the starting point for both the Hierarchies,
    Please duplicate the state object and place it in other class. (as two objects with same name shouldn't exist in same class)
    Now edit  the second hierarchy such that new State Object will be the starting point.
    Also , please ensure that 2nd WEBI report uses new State Object in Query Pane.
    This will prevent 1st hierarchy in 2nd webi report.
    I tried this out and it's working.
    Regards,
    Vamsee

  • Segment reporting

    (We are using ECC 6.0, new GL)
    Is there any standard report in SAP for reporting of financial statements (balance sheet and income statement) by segments? I cant find any... If there is, please give me a guidance.
    Or it must be created using queries or report painter?

    Hello
    Reporting for Open Item Accounting
    Use
    The SAP standard delivery contains some drilldown reports enabling you to check the origin of payables or receivables for profit centers (or profit center groups) or segments. These drilldown reports are:
    ·        Receivables: Profit Center
    ·        Payables: Profit Center
    ·        Receivables: Segment
    ·        Payables: Segment
    You can use the delivered standard reports as templates for your own reports. Generally, you can use the reports for any account assignment object contained in New General Ledger Accounting.
    Prerequisites
    For you to be able to use the delivered standard reports, Document Splitting must be active. In this way, postings from accounts receivable and accounts payable to the corresponding reconciliation account in General Ledger Accounting are distributed on the basis of the offsetting accounts for the G/L account.
    Features
    Open item accounting is only possible for normal items, that is, it is not possible for noted items and parked items because there are no line items in General Ledger Accounting for these items.
    If you use hierarchies as report selections, the hierarchy you choose is only used to select the data if you have not restricted the characteristic at the same time (for example, using custom selections). You can only apply a hierarchy for data selection in the case of small hierarchies because this does not involve the data being divided internally into data blocks of a manageable size. Using hierarchies with many elements can cause the system to terminate. If selections are used to restrict the characteristic, the hierarchy is only used for display purposes.
    Activities
    You find the reports on open item accounting from the SAP Easy Access menu under Accounting ® Financial Accounting ® General Ledger ® Information System ® General Ledger Reports (New) ® Line Items ® Open Items.
    Regards

  • Mapping FlatStructure from FileAdapter to Hierarchical IDOC

    We want to map the following  FLAT-Structure to an Hierarchical IDOC-Structure
    ZUECH_0210
    recordset
        H1
        H2
        H6
        D1  (1 to unbounded)
        D2  (1 to unbounded)
            Meterno1
        D3  (1 to unbounded)
             Q1
        D3
             Q2
        D2
           Meterno2
        D3
            Q1
        D3
            Q2
        D3
            Q3
    /recordset
    IDOC_ZUECH_210
      IDOC
           HEADER
                 H1
                 H2
                 H6
            /HEADER
            D1  (1:1)
                 D2 (1:99)
                     D3 (1:99)
        /IDOC
    We tried  D3 splitbyvalue to D3  => below  D2 there is only one D3 mapped?
    Any ideas how to keep the values from D3 below the according D2?
    We went through
    http://help.sap.com/saphelp_nw70/helpdata/en/ab/bdb13b00ae793be10000000a11402f/frameset.htm.
    It didn't help us very much

    Here the <b>source structure</b>
    <?xml version="1.0" encoding="UTF-8"?>
    <!-- edited with XMLSpy v2007 (http://www.altova.com) by d2k (-) -->
    <!--W3C Schema generated by XMLSpy v2007 (http://www.altova.com)-->
    <xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema" targetNamespace="urn:rwe-nl:xi:interfaces_ext:global">
         <xs:element name="ZUECH_0210">
              <xs:complexType>
                   <xs:sequence>
                        <xs:element name="recordset" maxOccurs="unbounded">
                             <xs:complexType>
                                  <xs:sequence>
                                       <xs:element name="H1">
                                            <xs:complexType>
                                                 <xs:sequence>
                                                      <xs:element name="KH1" type="xs:string"/>
                                                      <xs:element name="H1" type="xs:string"/>
                                                 </xs:sequence>
                                            </xs:complexType>
                                       </xs:element>
                                       <xs:element name="H2">
                                            <xs:complexType>
                                                 <xs:sequence>
                                                      <xs:element name="KH2" type="xs:string"/>
                                                      <xs:element name="H2" type="xs:string"/>
                                                 </xs:sequence>
                                            </xs:complexType>
                                       </xs:element>
                                       <xs:element name="H3">
                                            <xs:complexType>
                                                 <xs:sequence>
                                                      <xs:element name="KH3" type="xs:string"/>
                                                      <xs:element name="H3" type="xs:string"/>
                                                 </xs:sequence>
                                            </xs:complexType>
                                       </xs:element>
                                       <xs:element name="H4">
                                            <xs:complexType>
                                                 <xs:sequence>
                                                      <xs:element name="KH4" type="xs:string"/>
                                                      <xs:element name="H4" type="xs:string"/>
                                                 </xs:sequence>
                                            </xs:complexType>
                                       </xs:element>
                                       <xs:element name="H5">
                                            <xs:complexType>
                                                 <xs:sequence>
                                                      <xs:element name="KH5" type="xs:string"/>
                                                      <xs:element name="H5" type="xs:string"/>
                                                 </xs:sequence>
                                            </xs:complexType>
                                       </xs:element>
                                       <xs:element name="H6">
                                            <xs:complexType>
                                                 <xs:sequence>
                                                      <xs:element name="KH6" type="xs:string"/>
                                                      <xs:element name="H6" type="xs:string"/>
                                                 </xs:sequence>
                                            </xs:complexType>
                                       </xs:element>
                                       <xs:element name="MEDTD1" maxOccurs="unbounded">
                                            <xs:complexType>
                                                 <xs:sequence>
                                                      <xs:element name="KMEDTD1" type="xs:string"/>
                                                      <xs:element name="REQUEST_ID" type="xs:string"/>
                                                      <xs:element name="TRANSACTION_ID" type="xs:string"/>
                                                      <xs:element name="CONNECT_EAN" type="xs:string"/>
                                                      <xs:element name="REASON_ID" type="xs:string"/>
                                                      <xs:element name="PERIOD_STARTDATE" type="xs:string"/>
                                                      <xs:element name="PERIOD_ENDDATE" type="xs:string"/>
                                                      <xs:element name="SUBMITTED_DATE" type="xs:string"/>
                                                      <xs:element name="MARKET_SEGMENT" type="xs:string"/>
                                                      <xs:element name="NETOP_EAN" type="xs:string"/>
                                                      <xs:element name="REQUEST_REFERENCE" type="xs:string"/>
                                                 </xs:sequence>
                                            </xs:complexType>
                                       </xs:element>
                                       <xs:element name="MEDTD2" maxOccurs="unbounded">
                                            <xs:complexType>
                                                 <xs:sequence>
                                                      <xs:element name="KMEDTD2" type="xs:string"/>
                                                      <xs:element name="METERNO" type="xs:string"/>
                                                      <xs:element name="NO_DIALS" type="xs:string"/>
                                                 </xs:sequence>
                                            </xs:complexType>
                                       </xs:element>
                                       <xs:element name="MEDTD3" maxOccurs="unbounded">
                                            <xs:complexType>
                                                 <xs:sequence>
                                                      <xs:element name="KMEDTD3" type="xs:string"/>
                                                      <xs:element name="QUANTITY" type="xs:string"/>
                                                      <xs:element name="QUANTITY_TYPE_ID" type="xs:string"/>
                                                      <xs:element name="QUANTITY_DATE" type="xs:string"/>
                                                      <xs:element name="QUANTITY_DATE_TYPE" type="xs:string"/>
                                                      <xs:element name="MEASURE_UNIT_ID" type="xs:string"/>
                                                      <xs:element name="TIMEFRAME_ID" type="xs:string"/>
                                                      <xs:element name="QUALIFICATION" type="xs:string"/>
                                                      <xs:element name="NO_DIGITS" type="xs:string"/>
                                                 </xs:sequence>
                                            </xs:complexType>
                                       </xs:element>
                                       <xs:element name="F1">
                                            <xs:complexType>
                                                 <xs:sequence>
                                                      <xs:element name="KF1" type="xs:string"/>
                                                      <xs:element name="F1" type="xs:string"/>
                                                 </xs:sequence>
                                            </xs:complexType>
                                       </xs:element>
                                  </xs:sequence>
                             </xs:complexType>
                        </xs:element>
                   </xs:sequence>
              </xs:complexType>
         </xs:element>
    </xs:schema>
    And here the <b>Target Structure</b> of the IDOC
    <?xml version="1.0" encoding="UTF-8"?>
    <xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema">
         <xsd:element name="ZUECH_0210">
              <xsd:complexType>
                   <xsd:sequence>
                        <xsd:element name="IDOC" type="ZUECH_0210.ZUECH_0210" maxOccurs="unbounded"/>
                   </xsd:sequence>
              </xsd:complexType>
         </xsd:element>
         <xsd:complexType name="EDI_DC40.ZUECH_0210.ZUECH_0210">
              <xsd:sequence>
                   <xsd:element name="TABNAM" type="xsd:string" fixed="EDI_DC40">
                        <xsd:annotation>
                             <xsd:documentation>Table Structure Name</xsd:documentation>
                        </xsd:annotation>
                   </xsd:element>
                   <xsd:element name="MANDT" minOccurs="0">
                        <xsd:annotation>
                             <xsd:documentation>Client</xsd:documentation>
                        </xsd:annotation>
                        <xsd:simpleType>
                             <xsd:restriction base="xsd:string">
                                  <xsd:maxLength value="3"/>
                             </xsd:restriction>
                        </xsd:simpleType>
                   </xsd:element>
                   <xsd:element name="DOCNUM" minOccurs="0">
                        <xsd:annotation>
                             <xsd:documentation>IDoc Number</xsd:documentation>
                        </xsd:annotation>
                        <xsd:simpleType>
                             <xsd:restriction base="xsd:string">
                                  <xsd:maxLength value="16"/>
                             </xsd:restriction>
                        </xsd:simpleType>
                   </xsd:element>
                   <xsd:element name="DOCREL" minOccurs="0">
                        <xsd:annotation>
                             <xsd:documentation>SAP IDoc Release</xsd:documentation>
                        </xsd:annotation>
                        <xsd:simpleType>
                             <xsd:restriction base="xsd:string">
                                  <xsd:maxLength value="4"/>
                             </xsd:restriction>
                        </xsd:simpleType>
                   </xsd:element>
                   <xsd:element name="STATUS" minOccurs="0">
                        <xsd:annotation>
                             <xsd:documentation>IDoc Status</xsd:documentation>
                        </xsd:annotation>
                        <xsd:simpleType>
                             <xsd:restriction base="xsd:string">
                                  <xsd:maxLength value="2"/>
                             </xsd:restriction>
                        </xsd:simpleType>
                   </xsd:element>
                   <xsd:element name="DIRECT">
                        <xsd:annotation>
                             <xsd:documentation>Direction</xsd:documentation>
                        </xsd:annotation>
                        <xsd:simpleType>
                             <xsd:restriction base="xsd:string">
                                  <xsd:enumeration value="1">
                                       <xsd:annotation>
                                            <xsd:documentation>Outbound</xsd:documentation>
                                       </xsd:annotation>
                                  </xsd:enumeration>
                                  <xsd:enumeration value="2">
                                       <xsd:annotation>
                                            <xsd:documentation>Inbound</xsd:documentation>
                                       </xsd:annotation>
                                  </xsd:enumeration>
                             </xsd:restriction>
                        </xsd:simpleType>
                   </xsd:element>
                   <xsd:element name="OUTMOD" minOccurs="0">
                        <xsd:annotation>
                             <xsd:documentation>Output Mode</xsd:documentation>
                        </xsd:annotation>
                        <xsd:simpleType>
                             <xsd:restriction base="xsd:string">
                                  <xsd:maxLength value="1"/>
                             </xsd:restriction>
                        </xsd:simpleType>
                   </xsd:element>
                   <xsd:element name="EXPRSS" minOccurs="0">
                        <xsd:annotation>
                             <xsd:documentation>Overriding in Inbound Processing</xsd:documentation>
                        </xsd:annotation>
                        <xsd:simpleType>
                             <xsd:restriction base="xsd:string">
                                  <xsd:maxLength value="1"/>
                             </xsd:restriction>
                        </xsd:simpleType>
                   </xsd:element>
                   <xsd:element name="TEST" minOccurs="0">
                        <xsd:annotation>
                             <xsd:documentation>Test Flag</xsd:documentation>
                        </xsd:annotation>
                        <xsd:simpleType>
                             <xsd:restriction base="xsd:string">
                                  <xsd:maxLength value="1"/>
                             </xsd:restriction>
                        </xsd:simpleType>
                   </xsd:element>
                   <xsd:element name="IDOCTYP" type="xsd:string" fixed="ZUECH_0210">
                        <xsd:annotation>
                             <xsd:documentation>Basic Type Name</xsd:documentation>
                        </xsd:annotation>
                   </xsd:element>
                   <xsd:element name="CIMTYP" minOccurs="0">
                        <xsd:annotation>
                             <xsd:documentation>Enhancement (Customer-Defined)</xsd:documentation>
                        </xsd:annotation>
                        <xsd:simpleType>
                             <xsd:restriction base="xsd:string">
                                  <xsd:maxLength value="30"/>
                             </xsd:restriction>
                        </xsd:simpleType>
                   </xsd:element>
                   <xsd:element name="MESTYP" type="xsd:string" fixed="ZUECH_0210">
                        <xsd:annotation>
                             <xsd:documentation>Message Type</xsd:documentation>
                        </xsd:annotation>
                   </xsd:element>
                   <xsd:element name="MESCOD" minOccurs="0">
                        <xsd:annotation>
                             <xsd:documentation>Message Variant</xsd:documentation>
                        </xsd:annotation>
                        <xsd:simpleType>
                             <xsd:restriction base="xsd:string">
                                  <xsd:maxLength value="3"/>
                             </xsd:restriction>
                        </xsd:simpleType>
                   </xsd:element>
                   <xsd:element name="MESFCT" minOccurs="0">
                        <xsd:annotation>
                             <xsd:documentation>Message Function</xsd:documentation>
                        </xsd:annotation>
                        <xsd:simpleType>
                             <xsd:restriction base="xsd:string">
                                  <xsd:maxLength value="3"/>
                             </xsd:restriction>
                        </xsd:simpleType>
                   </xsd:element>
                   <xsd:element name="STD" minOccurs="0">
                        <xsd:annotation>
                             <xsd:documentation>EDI Standard, Flag</xsd:documentation>
                        </xsd:annotation>
                        <xsd:simpleType>
                             <xsd:restriction base="xsd:string">
                                  <xsd:maxLength value="1"/>
                             </xsd:restriction>
                        </xsd:simpleType>
                   </xsd:element>
                   <xsd:element name="STDVRS" minOccurs="0">
                        <xsd:annotation>
                             <xsd:documentation>EDI Standard, Version, and Release</xsd:documentation>
                        </xsd:annotation>
                        <xsd:simpleType>
                             <xsd:restriction base="xsd:string">
                                  <xsd:maxLength value="6"/>
                             </xsd:restriction>
                        </xsd:simpleType>
                   </xsd:element>
                   <xsd:element name="STDMES" minOccurs="0">
                        <xsd:annotation>
                             <xsd:documentation>EDI Message Type</xsd:documentation>
                        </xsd:annotation>
                        <xsd:simpleType>
                             <xsd:restriction base="xsd:string">
                                  <xsd:maxLength value="6"/>
                             </xsd:restriction>
                        </xsd:simpleType>
                   </xsd:element>
                   <xsd:element name="SNDPOR">
                        <xsd:annotation>
                             <xsd:documentation>Sender Port (SAP System, External Subsystem)</xsd:documentation>
                        </xsd:annotation>
                        <xsd:simpleType>
                             <xsd:restriction base="xsd:string">
                                  <xsd:maxLength value="10"/>
                             </xsd:restriction>
                        </xsd:simpleType>
                   </xsd:element>
                   <xsd:element name="SNDPRT">
                        <xsd:annotation>
                             <xsd:documentation>Sender Partner Type</xsd:documentation>
                        </xsd:annotation>
                        <xsd:simpleType>
                             <xsd:restriction base="xsd:string">
                                  <xsd:maxLength value="2"/>
                             </xsd:restriction>
                        </xsd:simpleType>
                   </xsd:element>
                   <xsd:element name="SNDPFC" minOccurs="0">
                        <xsd:annotation>
                             <xsd:documentation>Sender Partner Function</xsd:documentation>
                        </xsd:annotation>
                        <xsd:simpleType>
                             <xsd:restriction base="xsd:string">
                                  <xsd:maxLength value="2"/>
                             </xsd:restriction>
                        </xsd:simpleType>
                   </xsd:element>
                   <xsd:element name="SNDPRN">
                        <xsd:annotation>
                             <xsd:documentation>Sender Partner Number</xsd:documentation>
                        </xsd:annotation>
                        <xsd:simpleType>
                             <xsd:restriction base="xsd:string">
                                  <xsd:maxLength value="10"/>
                             </xsd:restriction>
                        </xsd:simpleType>
                   </xsd:element>
                   <xsd:element name="SNDSAD" minOccurs="0">
                        <xsd:annotation>
                             <xsd:documentation>Sender Address (SADR)</xsd:documentation>
                        </xsd:annotation>
                        <xsd:simpleType>
                             <xsd:restriction base="xsd:string">
                                  <xsd:maxLength value="21"/>
                             </xsd:restriction>
                        </xsd:simpleType>
                   </xsd:element>
                   <xsd:element name="SNDLAD" minOccurs="0">
                        <xsd:annotation>
                             <xsd:documentation>Logical Sender Address</xsd:documentation>
                        </xsd:annotation>
                        <xsd:simpleType>
                             <xsd:restriction base="xsd:string">
                                  <xsd:maxLength value="70"/>
                             </xsd:restriction>
                        </xsd:simpleType>
                   </xsd:element>
                   <xsd:element name="RCVPOR">
                        <xsd:annotation>
                             <xsd:documentation>Receiver Port</xsd:documentation>
                        </xsd:annotation>
                        <xsd:simpleType>
                             <xsd:restriction base="xsd:string">
                                  <xsd:maxLength value="10"/>
                             </xsd:restriction>
                        </xsd:simpleType>
                   </xsd:element>
                   <xsd:element name="RCVPRT" minOccurs="0">
                        <xsd:annotation>
                             <xsd:documentation>Receiver Partner Type</xsd:documentation>
                        </xsd:annotation>
                        <xsd:simpleType>
                             <xsd:restriction base="xsd:string">
                                  <xsd:maxLength value="2"/>
                             </xsd:restriction>
                        </xsd:simpleType>
                   </xsd:element>
                   <xsd:element name="RCVPFC" minOccurs="0">
                        <xsd:annotation>
                             <xsd:documentation>Receiver Partner Function</xsd:documentation>
                        </xsd:annotation>
                        <xsd:simpleType>
                             <xsd:restriction base="xsd:string">
                                  <xsd:maxLength value="2"/>
                             </xsd:restriction>
                        </xsd:simpleType>
                   </xsd:element>
                   <xsd:element name="RCVPRN">
                        <xsd:annotation>
                             <xsd:documentation>Receiver Partner Number</xsd:documentation>
                        </xsd:annotation>
                        <xsd:simpleType>
                             <xsd:restriction base="xsd:string">
                                  <xsd:maxLength value="10"/>
                             </xsd:restriction>
                        </xsd:simpleType>
                   </xsd:element>
                   <xsd:element name="RCVSAD" minOccurs="0">
                        <xsd:annotation>
                             <xsd:documentation>Receiver Address (SADR)</xsd:documentation>
                        </xsd:annotation>
                        <xsd:simpleType>
                             <xsd:restriction base="xsd:string">
                                  <xsd:maxLength value="21"/>
                             </xsd:restriction>
                        </xsd:simpleType>
                   </xsd:element>
                   <xsd:element name="RCVLAD" minOccurs="0">
                        <xsd:annotation>
                             <xsd:documentation>Logical Receiver Address</xsd:documentation>
                        </xsd:annotation>
                        <xsd:simpleType>
                             <xsd:restriction base="xsd:string">
                                  <xsd:maxLength value="70"/>
                             </xsd:restriction>
                        </xsd:simpleType>
                   </xsd:element>
                   <xsd:element name="CREDAT" minOccurs="0">
                        <xsd:annotation>
                             <xsd:documentation>Creation Date</xsd:documentation>
                        </xsd:annotation>
                        <xsd:simpleType>
                             <xsd:restriction base="xsd:string">
                                  <xsd:maxLength value="8"/>
                             </xsd:restriction>
                        </xsd:simpleType>
                   </xsd:element>
                   <xsd:element name="CRETIM" minOccurs="0">
                        <xsd:annotation>
                             <xsd:documentation>Creation Time</xsd:documentation>
                        </xsd:annotation>
                        <xsd:simpleType>
                             <xsd:restriction base="xsd:string">
                                  <xsd:maxLength value="6"/>
                             </xsd:restriction>
                        </xsd:simpleType>
                   </xsd:element>
                   <xsd:element name="REFINT" minOccurs="0">
                        <xsd:annotation>
                             <xsd:documentation>Interchange File (EDI Interchange)</xsd:documentation>
                        </xsd:annotation>
                        <xsd:simpleType>
                             <xsd:restriction base="xsd:string">
                                  <xsd:maxLength value="14"/>
                             </xsd:restriction>
                        </xsd:simpleType>
                   </xsd:element>
                   <xsd:element name="REFGRP" minOccurs="0">
                        <xsd:annotation>
                             <xsd:documentation>Message Group (EDI Message Group)</xsd:documentation>
                        </xsd:annotation>
                        <xsd:simpleType>
                             <xsd:restriction base="xsd:string">
                                  <xsd:maxLength value="14"/>
                             </xsd:restriction>
                        </xsd:simpleType>
                   </xsd:element>
                   <xsd:element name="REFMES" minOccurs="0">
                        <xsd:annotation>
                             <xsd:documentation>Message (EDI Message)</xsd:documentation>
                        </xsd:annotation>
                        <xsd:simpleType>
                             <xsd:restriction base="xsd:string">
                                  <xsd:maxLength value="14"/>
                             </xsd:restriction>
                        </xsd:simpleType>
                   </xsd:element>
                   <xsd:element name="ARCKEY" minOccurs="0">
                        <xsd:annotation>
                             <xsd:documentation>External Message Archive Key</xsd:documentation>
                        </xsd:annotation>
                        <xsd:simpleType>
                             <xsd:restriction base="xsd:string">
                                  <xsd:maxLength value="70"/>
                             </xsd:restriction>
                        </xsd:simpleType>
                   </xsd:element>
                   <xsd:element name="SERIAL" minOccurs="0">
                        <xsd:annotation>
                             <xsd:documentation>Serialization</xsd:documentation>
                        </xsd:annotation>
                        <xsd:simpleType>
                             <xsd:restriction base="xsd:string">
                                  <xsd:maxLength value="20"/>
                             </xsd:restriction>
                        </xsd:simpleType>
                   </xsd:element>
              </xsd:sequence>
              <xsd:attribute name="SEGMENT" type="xsd:string" use="required" fixed="1"/>
         </xsd:complexType>
         <xsd:complexType name="ZUECH_0210._-RWENL_-U_MEDTD2">
              <xsd:annotation>
                   <xsd:documentation>MEDTD2</xsd:documentation>
              </xsd:annotation>
              <xsd:sequence>
                   <xsd:element name="METERNO" minOccurs="0">
                        <xsd:annotation>
                             <xsd:documentation>MeterNo</xsd:documentation>
                        </xsd:annotation>
                        <xsd:simpleType>
                             <xsd:restriction base="xsd:string">
                                  <xsd:maxLength value="18"/>
                             </xsd:restriction>
                        </xsd:simpleType>
                   </xsd:element>
                   <xsd:element name="NO_DIALS" minOccurs="0">
                        <xsd:annotation>
                             <xsd:documentation>No_Dials</xsd:documentation>
                        </xsd:annotation>
                        <xsd:simpleType>
                             <xsd:restriction base="xsd:string">
                                  <xsd:maxLength value="2"/>
                             </xsd:restriction>
                        </xsd:simpleType>
                   </xsd:element>
                   <xsd:element name="_-RWENL_-U_MEDTD3" type="ZUECH_0210._-RWENL_-U_MEDTD3" maxOccurs="99"/>
              </xsd:sequence>
              <xsd:attribute name="SEGMENT" type="xsd:string" use="required" fixed="1"/>
         </xsd:complexType>
         <xsd:complexType name="ZUECH_0210._-RWENL_-U_EDSN_HEADER">
              <xsd:annotation>
                   <xsd:documentation>EDSN Header information</xsd:documentation>
              </xsd:annotation>
              <xsd:sequence>
                   <xsd:element name="H1" minOccurs="0">
                        <xsd:annotation>
                             <xsd:documentation>Not More Closely Defined Area, Possibly Used for Patchlevels</xsd:documentation>
                        </xsd:annotation>
                        <xsd:simpleType>
                             <xsd:restriction base="xsd:string">
                                  <xsd:maxLength value="4"/>
                             </xsd:restriction>
                        </xsd:simpleType>
                   </xsd:element>
                   <xsd:element name="H2" minOccurs="0">
                        <xsd:annotation>
                             <xsd:documentation>Character 100</xsd:documentation>
                        </xsd:annotation>
                        <xsd:simpleType>
                             <xsd:restriction base="xsd:string">
                                  <xsd:maxLength value="100"/>
                             </xsd:restriction>
                        </xsd:simpleType>
                   </xsd:element>
                   <xsd:element name="H3" minOccurs="0">
                        <xsd:annotation>
                             <xsd:documentation>Character field 13 digits</xsd:documentation>
                        </xsd:annotation>
                        <xsd:simpleType>
                             <xsd:restriction base="xsd:string">
                                  <xsd:maxLength value="13"/>
                             </xsd:restriction>
                        </xsd:simpleType>
                   </xsd:element>
                   <xsd:element name="H4" minOccurs="0">
                        <xsd:annotation>
                             <xsd:documentation>Character Field Length = 10</xsd:documentation>
                        </xsd:annotation>
                        <xsd:simpleType>
                             <xsd:restriction base="xsd:string">
                                  <xsd:maxLength value="10"/>
                             </xsd:restriction>
                        </xsd:simpleType>
                   </xsd:element>
                   <xsd:element name="H5" minOccurs="0">
                        <xsd:annotation>
                             <xsd:documentation>Supplier_EAN</xsd:documentation>
                        </xsd:annotation>
                        <xsd:simpleType>
                             <xsd:restriction base="xsd:string">
                                  <xsd:maxLength value="13"/>
                             </xsd:restriction>
                        </xsd:simpleType>
                   </xsd:element>
                   <xsd:element name="H6" minOccurs="0">
                        <xsd:annotation>
                             <xsd:documentation>Supplier_EAN</xsd:documentation>
                        </xsd:annotation>
                        <xsd:simpleType>
                             <xsd:restriction base="xsd:string">
                                  <xsd:maxLength value="13"/>
                             </xsd:restriction>
                        </xsd:simpleType>
                   </xsd:element>
              </xsd:sequence>
              <xsd:attribute name="SEGMENT" type="xsd:string" use="required" fixed="1"/>
         </xsd:complexType>
         <xsd:complexType name="ZUECH_0210.ZUECH_0210">
              <xsd:annotation>
                   <xsd:documentation>Received Metered data E</xsd:documentation>
              </xsd:annotation>
              <xsd:sequence>
                   <xsd:element name="EDI_DC40" type="EDI_DC40.ZUECH_0210.ZUECH_0210"/>
                   <xsd:element name="_-RWENL_-U_EDSN_HEADER" type="ZUECH_0210._-RWENL_-U_EDSN_HEADER"/>
                   <xsd:element name="_-RWENL_-U_MEDTD1" type="ZUECH_0210._-RWENL_-U_MEDTD1"/>
              </xsd:sequence>
              <xsd:attribute name="BEGIN" type="xsd:string" use="required" fixed="1"/>
         </xsd:complexType>
         <xsd:complexType name="ZUECH_0210._-RWENL_-U_MEDTD3">
              <xsd:annotation>
                   <xsd:documentation>MEDTD3</xsd:documentation>
              </xsd:annotation>
              <xsd:sequence>
                   <xsd:element name="QUANTITY" minOccurs="0">
                        <xsd:annotation>
                             <xsd:documentation>Quantity</xsd:documentation>
                        </xsd:annotation>
                        <xsd:simpleType>
                             <xsd:restriction base="xsd:string">
                                  <xsd:maxLength value="15"/>
                             </xsd:restriction>
                        </xsd:simpleType>
                   </xsd:element>
                   <xsd:element name="QUANTITY_TYPE_ID" minOccurs="0">
                        <xsd:annotation>
                             <xsd:documentation>Quantity_Type_ID</xsd:documentation>
                        </xsd:annotation>
                        <xsd:simpleType>
                             <xsd:restriction base="xsd:string">
                                  <xsd:maxLength value="3"/>
                             </xsd:restriction>
                        </xsd:simpleType>
                   </xsd:element>
                   <xsd:element name="QUANTITY_DATE" minOccurs="0">
                        <xsd:annotation>
                             <xsd:documentation>Quantity_Date</xsd:documentation>
                        </xsd:annotation>
                        <xsd:simpleType>
                             <xsd:restriction base="xsd:string">
                                  <xsd:maxLength value="8"/>
                             </xsd:restriction>
                        </xsd:simpleType>
                   </xsd:element>
                   <xsd:element name="QUANTITY_DATE_TYPE" minOccurs="0">
                        <xsd:annotation>
                             <xsd:documentation>Quantity_Date_Type</xsd:documentation>
                        </xsd:annotation>
                        <xsd:simpleType>
                             <xsd:restriction base="xsd:string">
                                  <xsd:maxLength value="3"/>
                             </xsd:restriction>
                        </xsd:simpleType>
                   </xsd:element>
                   <xsd:element name="MEASURE_UNIT_ID" minOccurs="0">
                        <xsd:annotation>
                             <xsd:documentation>Measure_Unit_ID</xsd:documentation>
                        </xsd:annotation>
                        <xsd:simpleType>
                             <xsd:restriction base="xsd:string">
                                  <xsd:maxLength value="3"/>
                             </xsd:restriction>
                        </xsd:simpleType>
                   </xsd:element>
                   <xsd:element name="TIMEFRAME_ID" minOccurs="0">
                        <xsd:annotation>
                             <xsd:documentation>TimeFrame_ID</xsd:documentation>
                        </xsd:annotation>
                        <xsd:simpleType>
                             <xsd:restriction base="xsd:string">
                                  <xsd:maxLength value="3"/>
                             </xsd:restriction>
                        </xsd:simpleType>
                   </xsd:element>
                   <xsd:element name="QUALIFICATION" minOccurs="0">
                        <xsd:annotation>
                             <xsd:documentation>Qualification</xsd:documentation>
                        </xsd:annotation>
                        <xsd:simpleType>
                             <xsd:restriction base="xsd:string">
                                  <xsd:maxLength value="3"/>
                             </xsd:restriction>
                        </xsd:simpleType>
                   </xsd:element>
                   <xsd:element name="NO_DIGITS" minOccurs="0">
                        <xsd:annotation>
                             <xsd:documentation>No_Digits</xsd:documentation>
                        </xsd:annotation>
                        <xsd:simpleType>
                             <xsd:restriction base="xsd:string">
                                  <xsd:maxLength value="2"/>
                             </xsd:restriction>
                        </xsd:simpleType>
                   </xsd:element>
              </xsd:sequence>
              <xsd:attribute name="SEGMENT" type="xsd:string" use="required" fixed="1"/>
         </xsd:complexType>
         <xsd:complexType name="ZUECH_0210._-RWENL_-U_MEDTD1">
              <xsd:annotation>
                   <xsd:documentation>MEDTD1</xsd:documentation>
              </xsd:annotation>
              <xsd:sequence>
                   <xsd:element name="REQUEST_ID" minOccurs="0">
                        <xsd:annotation>
                             <xsd:documentation>Request_ID</xsd:documentation>
                        </xsd:annotation>
                        <xsd:simpleType>
                             <xsd:restriction base="xsd:string">
                                  <xsd:maxLength value="10"/>
                             </xsd:restriction>
                        </xsd:simpleType>
                   </xsd:element>
                   <xsd:element name="TRANSACTION_ID" minOccurs="0">
                        <xsd:annotation>
                             <xsd:documentation>Transaction_ID</xsd:documentation>
                        </xsd:annotation>
                        <xsd:simpleType>
                             <xsd:restriction base="xsd:string">
                                  <xsd:maxLength value="10"/>
                             </xsd:restriction>
                        </xsd:simpleType>
                   </xsd:element>
                   <xsd:element name="CONNECT_EAN" minOccurs="0">
                        <xsd:annotation>
                             <xsd:documentation>Connect_EAN</xsd:documentation>
                        </xsd:annotation>
                        <xsd:simpleType>
                             <xsd:restriction base="xsd:string">
                                  <xsd:maxLength value="18"/>
                             </xsd:restriction>
                        </xsd:simpleType>
                   </xsd:element>
                   <xsd:element name="REASON_ID" minOccurs="0">
                        <xsd:annotation>
                             <xsd:documentation>Reason_ID</xsd:documentation>
                        </xsd:annotation>
                        <xsd:simpleType>
                             <xsd:restriction base="xsd:string">
                                  <xsd:maxLength value="3"/>
                             </xsd:restriction>
                        </xsd:simpleType>
                   </xsd:element>
                   <xsd:element name="PERIOD_STARTDATE" minOccurs="0">
                        <xsd:annotation>
                             <xsd:documentation>Period Startdate</xsd:documentation>
                        </xsd:annotation>
                        <xsd:simpleType>
                             <xsd:restriction base="xsd:string">
                                  <xsd:maxLength value="8"/>
                             </xsd:restriction>
                        </xsd:simpleType>
                   </xsd:element>
                   <xsd:element name="PERIOD_ENDDATE" minOccurs="0">
                        <xsd:annotation>
                             <xsd:documentation>Requested_MR_End_Date</xsd:documentation>
                        </xsd:annotation>
                        <xsd:simpleType>
                             <xsd:restriction base="xsd:string">
                                  <xsd:maxLength value="8"/>
                             </xsd:restriction>
                        </xsd:simpleType>
                   </xsd:element>
                   <xsd:element name="SUBMITTED_DATE" minOccurs="0">
                        <xsd:annotation>
                             <xsd:documentation>Submitted_date</xsd:documentation>
                        </xsd:annotation>
                        <xsd:simpleType>
                             <xsd:restriction base="xsd:string">
                                  <xsd:maxLength value="12"/>
                             </xsd:restriction>
                        </xsd:simpleType>
                   </xsd:element>
                   <xsd:element name="MARKET_SEGMENT" minOccurs="0">
                        <xsd:annotation>
                             <xsd:documentation>Market_Segment</xsd:documentation>
                        </xsd:annotation>
                        <xsd:simpleType>
                             <xsd:restriction base="xsd:string">
                                  <xsd:maxLength value="3"/>
                             </xsd:restriction>
                        </xsd:simpleType>
                   </xsd:element>
                   <xsd:element name="NETOP_EAN" minOccurs="0">
                        <xsd:annotation>
                             <xsd:documentation>NetOp EAN</xsd:documentation>
                        </xsd:annotation>
                        <xsd:simpleType>
                             <xsd:restriction base="xsd:string">
                                  <xsd:maxLength value="13"/>
                             </xsd:restriction>
                        </xsd:simpleType>
                   </xsd:element>
                   <xsd:element name="REQUEST_REFERENCE" minOccurs="0">
                        <xsd:annotation>
                             <xsd:documentation>Request_Reference</xsd:documentation>
                        </xsd:annotation>
                        <xsd:simpleType>
                             <xsd:restriction base="xsd:string">
                                  <xsd:maxLength value="25"/>
                             </xsd:restriction>
                        </xsd:simpleType>
                   </xsd:element>
                   <xsd:element name="_-RWENL_-U_MEDTD2" type="ZUECH_0210._-RWENL_-U_MEDTD2" maxOccurs="99"/>
              </xsd:sequence>
              <xsd:attribute name="SEGMENT" type="xsd:string" use="required" fixed="1"/>
         </xsd:complexType>
    </xsd:schema>

Maybe you are looking for

  • Having difficulty in Win 8.1 changing boot order drive at the Bios level

    My desktop computer has 32GB of DDR3-1600Mhz Memory plus a 128GB SSD boot drive "C" and 2 2TB SATA drives and finally a 1TB Sata drive. My problem is that the 128GB SSD drive is maxed out space wise.  I want to change the boot drive to the 1TB drive,

  • Can you get FCPX on three screens?

    Hello, I have a Mac Pro but it is not the late 2013 model. Is there a way to get fcpx on three screens and not just two like on the new mac pro? Thanks.

  • Cannot open a file

    when I try to open a file to print a form or to open some files to read them, an (untitled) appears after I am ask, do I want to open this file? This untitled appears numerous times with a continuous scroll across the computer screen.

  • Notes sync iPhone - mac?

    Simple question : How do I get the Notes in Mail.app on my mac to sync with the Notes app on iPhone?

  • How to Open On Page closed webparts?

    I had a page that was giving me problems. In Web Part Maintenance Page, I closed all of the web parts. Would up be a Managed Metadata issue, it's fixed, and now I want to re-open all of those web parts. Way to do it through ?contents=1 or spcontnt.as