SAP：COOISPI 增强

项目要求在COOISPI界面增加“批次”查询条件，用于筛选流程订单。

 这里使用了一系列增强实现该功能。

Step1： 增强选择屏幕，增加批次查询条件。因为是标准程序，无法维护批次字段的选择文本。这里使用变量gc_charg，对批次字段设置选择文本。

 Step2： 在初始化事件时，增强对gc_charg赋值，实现批次字段的选择文本。

Step3：点击查询时，保存选择屏幕的输入条件。作用：后续使用批次进行数据过滤用。

Step4：使用badi：WORKORDER_INFOSYSTEM，增强实施方法TABLES_MODIFY_LAY。

  METHOD if_ex_workorder_infosystem~tables_modify_lay.
    DATA: lt_sel TYPE rsparams_tt.
    DATA: lt_charg_rg TYPE RANGE OF mch1-charg,
          ls_charg_rg LIKE LINE OF lt_charg_rg.

    DATA: lt_aufnr_rg TYPE RANGE OF afpo-aufnr.


*   从内存中取出选择屏幕输入信息
    IMPORT zcoois_sel = lt_sel FROM MEMORY ID 'ZCOOISPI'.

*   获得增强的批次输入值
    LOOP AT lt_sel INTO DATA(ls_sel) WHERE selname = 'S_CHARG'.
      CLEAR: ls_charg_rg.
      IF ls_sel-sign IS NOT INITIAL AND ls_sel-option IS NOT INITIAL.
        ls_charg_rg-sign   = ls_sel-sign  .
        ls_charg_rg-option = ls_sel-option.
        ls_charg_rg-low    = ls_sel-low   .
        ls_charg_rg-high   = ls_sel-high  .
        APPEND ls_charg_rg TO lt_charg_rg.
      ENDIF.
    ENDLOOP.

*   用批次信息对查询结果过滤
    IF lt_charg_rg[] IS NOT INITIAL.
      DELETE ct_ioheader WHERE charg NOT IN lt_charg_rg.
      DELETE ct_ioitem   WHERE charg NOT IN lt_charg_rg.

      " 使用增强的批次对系统的查询结果进行二次过滤
      IF ct_iomamo[] IS NOT INITIAL.
        SELECT aufm~mblnr,
               aufm~mjahr,
               aufm~zeile
          INTO TABLE @DATA(lt_aufm)
          FROM aufm
          INNER JOIN afpo ON afpo~aufnr = aufm~aufnr
          FOR ALL ENTRIES IN @ct_iomamo[]
          WHERE afpo~aufnr =  @ct_iomamo-aufnr
            AND afpo~charg IN @lt_charg_rg.

        IF sy-subrc <> 0.
          REFRESH: ct_iomamo.
        ELSE.
          DATA(lt_iomamo) = ct_iomamo[].
          REFRESH: ct_iomamo.  "清空结果，准备输出过滤后的结果
          LOOP AT lt_aufm INTO DATA(ls_aufm).
            LOOP AT lt_iomamo INTO DATA(ls_iomamo) WHERE mblnr =  ls_aufm-mblnr
                                                     AND mjahr =  ls_aufm-mjahr
                                                     AND zeile =  ls_aufm-zeile.
              APPEND ls_iomamo TO ct_iomamo.
            ENDLOOP.
          ENDLOOP.
        ENDIF.
      ENDIF.

      "使用增强的批次对系统的查询结果进行二次过滤
      IF ct_ioopgomo[] IS NOT INITIAL.
        SELECT mseg~mblnr,
               mseg~mjahr,
               mseg~zeile
          INTO TABLE @DATA(lt_mseg)
          FROM mseg
          INNER JOIN afpo ON afpo~aufnr = mseg~aufnr
          FOR ALL ENTRIES IN @ct_ioopgomo[]
          WHERE afpo~aufnr =  @ct_ioopgomo-aufnr
            AND afpo~charg IN @lt_charg_rg.
        IF sy-subrc <> 0.
          REFRESH: ct_ioopgomo[].
        ELSE.
          DATA(lt_ioopgomo) = ct_ioopgomo[].
          REFRESH: ct_ioopgomo.     "清空结果，准备输出过滤后的结果
          LOOP AT lt_mseg INTO DATA(ls_mseg).
            LOOP AT lt_ioopgomo INTO DATA(ls_ioopgomo) WHERE  mblnr  = ls_mseg-mblnr
                                                      AND mjahr  = ls_mseg-mjahr
                                                      AND zeile  = ls_mseg-zeile.
              APPEND ls_ioopgomo TO ct_ioopgomo.
            ENDLOOP.
          ENDLOOP.
        ENDIF.
      ENDIF.


      "使用增强的批次对系统的查询结果进行二次过滤
      IF ct_iogomo[] IS NOT INITIAL.
        SELECT mseg~mblnr,
               mseg~mjahr,
               mseg~zeile
          INTO TABLE @lt_mseg
          FROM mseg
          INNER JOIN afpo ON afpo~aufnr = mseg~aufnr
          FOR ALL ENTRIES IN @ct_iogomo[]
          WHERE afpo~aufnr =  @ct_iogomo-aufnr
            AND afpo~charg IN @lt_charg_rg.
        IF sy-subrc <> 0.
          REFRESH: ct_iogomo[].
        ELSE.
          DATA(lt_iogomo) = ct_iogomo[].
          REFRESH: ct_iogomo. "清空结果，准备输出过滤后的结果
          LOOP AT lt_mseg INTO ls_mseg.
            LOOP AT lt_iogomo INTO DATA(ls_iogomo) WHERE  mblnr  = ls_mseg-mblnr
                                                      AND mjahr  = ls_mseg-mjahr
                                                      AND zeile  = ls_mseg-zeile.
              APPEND ls_iogomo TO ct_iogomo.
            ENDLOOP.
          ENDLOOP.
        ENDIF.
      ENDIF.


      "使用增强的批次对系统的查询结果进行二次过滤
      IF ct_iosogomo[] IS NOT INITIAL.
        SELECT mseg~mblnr,
               mseg~mjahr,
               mseg~zeile
          INTO TABLE @lt_mseg
          FROM mseg
          INNER JOIN afpo ON afpo~aufnr = mseg~aufnr
          FOR ALL ENTRIES IN @ct_iosogomo[]
          WHERE afpo~aufnr =  @ct_iosogomo-aufnr
            AND afpo~charg IN @lt_charg_rg.
        IF sy-subrc <> 0.
          REFRESH: ct_iosogomo[].
        ELSE.
          DATA(lt_iosogomo) = ct_iosogomo[].
          REFRESH: ct_iosogomo.   "清空结果，准备输出过滤后的结果
          LOOP AT lt_mseg INTO ls_mseg.
            LOOP AT lt_iosogomo INTO DATA(ls_iosogomo) WHERE  mblnr  = ls_mseg-mblnr
                                                      AND mjahr  = ls_mseg-mjahr
                                                      AND zeile  = ls_mseg-zeile.
              APPEND ls_iosogomo TO ct_iosogomo.
            ENDLOOP.
          ENDLOOP.
        ENDIF.
      ENDIF.

      "使用增强的批次对系统的查询结果进行二次过滤
      IF ct_ioopcomp[] IS NOT INITIAL.
        " 读取凭证抬头中的批次信息，准备进行数据过滤
        SELECT * FROM afpo INTO TABLE @DATA(lt_afpo)
          FOR ALL ENTRIES IN @ct_ioopcomp[]
          WHERE aufnr = @ct_ioopcomp-aufnr
            AND charg IN @lt_charg_rg.
        IF sy-subrc <> 0.
          REFRESH: ct_ioopcomp[].
        ELSE.
          REFRESH: lt_aufnr_rg.
          LOOP AT lt_afpo INTO DATA(ls_afpo).
            APPEND VALUE #( sign = 'I' option = 'EQ' low = ls_afpo-aufnr ) TO lt_aufnr_rg.
          ENDLOOP.

          SORT lt_aufnr_rg BY low.
          DELETE ADJACENT DUPLICATES FROM lt_aufnr_rg COMPARING low.
          DELETE ct_ioopcomp WHERE aufnr NOT IN lt_aufnr_rg.
        ENDIF.
      ENDIF.

      "使用增强的批次对系统的查询结果进行二次过滤
      IF ct_ioopgmer[] IS NOT INITIAL.    "货物移动（包含错误）
        SELECT affw~weblnr  ,
               affw~weblpos
          INTO TABLE @DATA(lt_affw)
          FROM affw
          INNER JOIN afpo ON afpo~aufnr = affw~aufnr
          FOR ALL ENTRIES IN @ct_ioopgomo[]
          WHERE afpo~aufnr =  @ct_ioopgomo-aufnr
            AND afpo~charg IN @lt_charg_rg.
        IF sy-subrc <> 0.
          REFRESH: ct_ioopgmer[].
        ELSE.
          DATA(lt_ioopgmer) = ct_ioopgmer[].
          REFRESH: ct_ioopgmer.
          LOOP AT lt_affw INTO DATA(ls_affw).
            LOOP AT lt_ioopgmer INTO DATA(ls_ioopgmer) WHERE weblnr  = ls_affw-weblnr
                                                         AND weblpos  = ls_affw-weblpos.
              APPEND ls_ioopgmer TO ct_ioopgmer.
            ENDLOOP.
          ENDLOOP.
        ENDIF.
      ENDIF.

      "使用增强的批次对系统的查询结果进行二次过滤
      IF ct_iogmer[] IS NOT INITIAL.
        SELECT affw~weblnr  ,
               affw~weblpos
          INTO TABLE @lt_affw
          FROM affw
          INNER JOIN afpo ON afpo~aufnr = affw~aufnr
          FOR ALL ENTRIES IN @ct_iogmer[]
          WHERE afpo~aufnr =  @ct_iogmer-aufnr
            AND afpo~charg IN @lt_charg_rg.
        IF sy-subrc <> 0.
          REFRESH: ct_iogmer[].
        ELSE.
          DATA(lt_iogmer) = ct_iogmer[].
          REFRESH: ct_iogmer.  "输出二次过滤后的结果
          LOOP AT lt_affw INTO ls_affw.
            LOOP AT lt_iogmer INTO DATA(ls_iogmer) WHERE weblnr  = ls_affw-weblnr
                                                         AND weblpos  = ls_affw-weblpos.
              APPEND ls_iogmer TO ct_iogmer.
            ENDLOOP.
          ENDLOOP.
        ENDIF.
      ENDIF.

      "使用增强的批次对系统的查询结果进行二次过滤
      IF ct_iosogmer[] IS NOT INITIAL.
        SELECT affw~weblnr  ,
               affw~weblpos
          INTO TABLE @lt_affw
          FROM affw
          INNER JOIN afpo ON afpo~aufnr = affw~aufnr
          FOR ALL ENTRIES IN @ct_iosogmer[]
          WHERE afpo~aufnr =  @ct_iosogmer-aufnr
            AND afpo~charg IN @lt_charg_rg.
        IF sy-subrc <> 0.
          REFRESH: ct_iosogmer[].
        ELSE.
          DATA(lt_iosogmer) = ct_iosogmer[].
          REFRESH: ct_iosogmer.  "输出二次过滤后的结果
          LOOP AT lt_affw INTO ls_affw.
            LOOP AT lt_iosogmer INTO DATA(ls_iosogmer) WHERE weblnr  = ls_affw-weblnr
                                                         AND weblpos  = ls_affw-weblpos.
              APPEND ls_iosogmer TO ct_iosogmer.
            ENDLOOP.
          ENDLOOP.
        ENDIF.
      ENDIF.

      "使用增强的批次对系统的查询结果进行二次过滤
      IF ct_ioprodlist[] IS NOT INITIAL.
        REFRESH: lt_afpo.
        SELECT * FROM afpo INTO TABLE lt_afpo
          FOR ALL ENTRIES IN ct_ioprodlist[]
          WHERE aufnr = ct_ioprodlist-aufnr
            AND charg IN lt_charg_rg.
        IF sy-subrc <> 0.
          REFRESH: ct_ioprodlist.
        ELSE.
          " 准备过滤条件
          REFRESH: lt_aufnr_rg.
          LOOP AT lt_afpo INTO ls_afpo.
            APPEND VALUE #( sign = 'I' option = 'EQ' low = ls_afpo-aufnr ) TO lt_aufnr_rg.
          ENDLOOP.

          "输出二次过滤后的结果
          SORT lt_aufnr_rg BY low.
          DELETE ADJACENT DUPLICATES FROM lt_aufnr_rg COMPARING low.
          DELETE ct_ioprodlist WHERE aufnr NOT IN lt_aufnr_rg.
        ENDIF.
      ENDIF.

      "使用增强的批次对系统的查询结果进行二次过滤
      IF ct_iooper[] IS NOT INITIAL.
        REFRESH: lt_afpo.
        SELECT * FROM afpo INTO TABLE lt_afpo
          FOR ALL ENTRIES IN ct_iooper[]
          WHERE aufnr = ct_iooper-aufnrd
            AND charg IN lt_charg_rg.
        IF sy-subrc <> 0.
          REFRESH: ct_iooper.
        ELSE.
          " 准备过滤条件
          REFRESH: lt_aufnr_rg.
          LOOP AT lt_afpo INTO ls_afpo.
            APPEND VALUE #( sign = 'I' option = 'EQ' low = ls_afpo-aufnr ) TO lt_aufnr_rg.
          ENDLOOP.

          "输出二次过滤后的结果
          SORT lt_aufnr_rg BY low.
          DELETE ADJACENT DUPLICATES FROM lt_aufnr_rg COMPARING low.
          DELETE ct_iooper WHERE aufnrd NOT IN lt_aufnr_rg.
        ENDIF.
      ENDIF.

      "使用增强的批次对系统的查询结果进行二次过滤
      IF ct_ioopconf[] IS NOT INITIAL.
        REFRESH: lt_afpo.
        SELECT * FROM afpo INTO TABLE lt_afpo
          FOR ALL ENTRIES IN ct_ioopconf[]
          WHERE aufnr = ct_ioopconf-aufnr
            AND charg IN lt_charg_rg.
        IF sy-subrc <> 0.
          REFRESH: ct_ioopconf.
        ELSE.
          " 准备过滤条件
          REFRESH: lt_aufnr_rg.
          LOOP AT lt_afpo INTO ls_afpo.
            APPEND VALUE #( sign = 'I' option = 'EQ' low = ls_afpo-aufnr ) TO lt_aufnr_rg.
          ENDLOOP.

          "输出二次过滤后的结果
          SORT lt_aufnr_rg BY low.
          DELETE ADJACENT DUPLICATES FROM lt_aufnr_rg COMPARING low.
          DELETE ct_ioopconf WHERE aufnr NOT IN lt_aufnr_rg.
        ENDIF.
      ENDIF.

      "使用增强的批次对系统的查询结果进行二次过滤
      IF ct_ioopcap[] IS NOT INITIAL.  "能力
        SELECT DISTINCT afko~bedid
          INTO TABLE @DATA(lt_afko)
          FROM afko
          INNER JOIN afpo ON afko~aufnr = afpo~aufnr
          FOR ALL ENTRIES IN @ct_ioopcap
          WHERE afko~bedid = @ct_ioopcap-bedid.
        IF sy-subrc <> 0.
          REFRESH: ct_ioopcap[].
        ELSE.
          " 输出二次过滤后的结果
          DATA(lt_ioopcap) = ct_ioopcap[].
          REFRESH: ct_ioopcap[].
          LOOP AT lt_afko INTO DATA(ls_afko).
            LOOP AT lt_ioopcap INTO DATA(ls_ioopcap) WHERE bedid = ls_afko-bedid.
              APPEND ls_ioopcap TO ct_ioopcap[].
            ENDLOOP.
          ENDLOOP.
        ENDIF.
      ENDIF.
    ENDIF.

*  释放内存数据
    FREE MEMORY ID 'ZCOOISPI'.
  ENDMETHOD.