GitHub Copilot pour ABAP : Booster la productivite avec l IA

En bas a droite dans VS Code : Icone Copilot
- Vert = Actif
- Rouge = Erreur (verifier la connexion)

" Implement validation to check if customer exists in I_Customer
METHOD validateCustomer FOR VALIDATE ON SAVE
  IMPORTING keys FOR Travel~validateCustomer.

  " Read travel data
  READ ENTITIES OF zi_travel IN LOCAL MODE
    ENTITY Travel
      FIELDS ( CustomerId )
      WITH CORRESPONDING #( keys )
    RESULT DATA(lt_travel).

  " Get all customer IDs
  DATA(lt_customer_ids) = VALUE string_table(
    FOR travel IN lt_travel ( travel-CustomerId )
  ).

  " Check if customers exist
  SELECT Customer
    FROM I_Customer
    FOR ALL ENTRIES IN @lt_customer_ids
    WHERE Customer = @lt_customer_ids-table_line
    INTO TABLE @DATA(lt_existing_customers).

  " Report errors for non-existing customers
  LOOP AT lt_travel INTO DATA(ls_travel).
    IF NOT line_exists( lt_existing_customers[ table_line = ls_travel-CustomerId ] ).
      APPEND VALUE #(
        %tky = ls_travel-%tky
        %element-CustomerId = if_abap_behv=>mk-on
      ) TO failed-travel.

      APPEND VALUE #(
        %tky = ls_travel-%tky
        %element-CustomerId = if_abap_behv=>mk-on
        %msg = new_message_with_text(
          severity = if_abap_behv_message=>severity-error
          text     = |Customer { ls_travel-CustomerId } does not exist|
        )
      ) TO reported-travel.
    ENDIF.
  ENDLOOP.
ENDMETHOD.

-- CDS View for Sales Orders with customer name and total amount
-- Include association to customer

@AccessControl.authorizationCheck: #CHECK
@EndUserText.label: 'Sales Orders with Customer Data"

define view entity ZI_SalesOrderWithCustomer
  as select from I_SalesOrder as Order
  association [0..1] to I_Customer as _Customer
    on Order.SoldToParty = _Customer.Customer
{
  key Order.SalesOrder,
      Order.SalesOrderType,
      Order.SalesOrganization,
      Order.SoldToParty,
      Order.CreationDate,

      @Semantics.amount.currencyCode: 'TransactionCurrency"
      Order.TotalNetAmount,

      @Semantics.currencyCode: true
      Order.TransactionCurrency,

      Order.OverallSDProcessStatus,

      // Customer data via association
      _Customer.CustomerName,
      _Customer.CityName,
      _Customer.Country,

      // Expose association
      _Customer
}

" Unit test for validateCustomer method
" Test case: Customer does not exist -> should fail

CLASS ltc_validate_customer DEFINITION FINAL FOR TESTING
  DURATION SHORT RISK LEVEL HARMLESS.

  PRIVATE SECTION.
    DATA mo_env TYPE REF TO if_cds_test_environment.
    METHODS:
      setup,
      teardown,
      test_customer_not_exists FOR TESTING,
      test_customer_exists FOR TESTING.
ENDCLASS.

CLASS ltc_validate_customer IMPLEMENTATION.

  METHOD setup.
    mo_env = cl_cds_test_environment=>create_for_multiple_cds(
      i_for_entities = VALUE #(
        ( i_for_entity = 'ZI_Travel' )
        ( i_for_entity = 'I_Customer' )
      )
    ).

    " Insert test customer
    mo_env->insert_test_data(
      i_data = VALUE i_customer(
        ( Customer = '000042' CustomerName = 'Test Customer' )
      )
    ).
  ENDMETHOD.

  METHOD test_customer_not_exists.
    " Arrange: Travel with non-existing customer
    MODIFY ENTITIES OF zi_travel
      ENTITY Travel
        CREATE FIELDS ( CustomerId )
        WITH VALUE #( ( %cid = 'T1' CustomerId = '999999' ) )
      FAILED DATA(failed).

    " Act: Commit triggers validation
    COMMIT ENTITIES
      RESPONSE OF zi_travel
      FAILED DATA(commit_failed)
      REPORTED DATA(commit_reported).

    " Assert: Should fail
    cl_abap_unit_assert=>assert_not_initial(
      act = commit_failed-travel
      msg = 'La validation devrait echouer pour un client inexistant"
    ).

    cl_abap_unit_assert=>assert_bound(
      act = commit_reported-travel[ 1 ]-%msg
      msg = 'Un message d erreur devrait etre present"
    ).
  ENDMETHOD.

  METHOD test_customer_exists.
    " Arrange: Travel with existing customer
    MODIFY ENTITIES OF zi_travel
      ENTITY Travel
        CREATE FIELDS ( CustomerId )
        WITH VALUE #( ( %cid = 'T1' CustomerId = '000042' ) )
      FAILED DATA(failed).

    " Act
    COMMIT ENTITIES
      RESPONSE OF zi_travel
      FAILED DATA(commit_failed).

    " Assert: Should succeed
    cl_abap_unit_assert=>assert_initial(
      act = commit_failed-travel
      msg = 'La validation devrait reussir pour un client existant"
    ).
  ENDMETHOD.

  METHOD teardown.
    ROLLBACK ENTITIES.
    mo_env->destroy( ).
  ENDMETHOD.

ENDCLASS.

VS Code:
- Ctrl+Shift+I (Windows/Linux)
- Cmd+Shift+I (Mac)
- Ou : Sidebar -> Icone Chat

Explain this ABAP code:
[Selectionner et envoyer le code]

DATA(lt_result) = FILTER #( lt_data WHERE status = 'A' ).

Cette ligne utilise l'expression FILTER inline d'ABAP pour creer une
table interne filtree. Elle :

1. Prend la table source lt_data
2. Filtre les lignes ou le champ status egale 'A"
3. Assigne le resultat a lt_result (type infere automatiquement)

C'est equivalent a :
LOOP AT lt_data INTO DATA(ls_row) WHERE status = 'A'.
  APPEND ls_row TO lt_result.
ENDLOOP.

Mais plus concis et performant (operation en un seul passage).

Refactor this to use modern ABAP syntax:

LOOP AT lt_orders INTO ls_order.
  IF ls_order-status = 'O'.
    ls_order-priority = 'HIGH'.
    MODIFY lt_orders FROM ls_order.
  ENDIF.
ENDLOOP.

" ABAP moderne avec declaration inline et expression modify:
MODIFY lt_orders FROM VALUE #(
  FOR order IN lt_orders WHERE ( status = 'O' )
  ( CORRESPONDING #( order ) priority = 'HIGH' )
).

" Ou encore plus concis avec COND:
lt_orders = VALUE #(
  FOR order IN lt_orders
  ( CORRESPONDING #( order )
    priority = COND #( WHEN order-status = 'O' THEN 'HIGH"
                       ELSE order-priority ) )
).

" Specifique + Contexte
" Create a RAP determination that calculates TotalPrice
" as BasePrice * Quantity * (1 - Discount/100)
" Trigger: on modify when Quantity or BasePrice changes

" Avec exemple
" Convert this SELECT to use path expressions:
" SELECT * FROM vbak
"   INNER JOIN kna1 ON vbak~kunnr = kna1~kunnr
"   WHERE vbak~vbeln = @lv_order.

" Nommer les contraintes
" Write a validation that checks:
" 1. BeginDate not in past
" 2. EndDate after BeginDate
" 3. Max duration 365 days
" Use message class ZTRAVEL

" Specifier la technologie
" Implement OData V4 action 'approve' for Travel entity
" Input: ApprovalNote (string)
" Output: Updated Travel with Status='A"
" Use RAP Business Object pattern

" Trop vague
" Write some validation

" Trop complexe (en un seul prompt)
" Build a complete RAP application with Travel, Booking, Customer,
" including all CRUD, validations, determinations, actions, OData service,
" Fiori UI, and deployment to BTP

" Sans contexte
" Fix this code:
SELECT * FROM table WHERE field = value.
" -> Copilot ne sait pas : Quelle table ? Quelle erreur ?

" Exigence floue
" Make this better
" -> Que signifie "better" ? Performance ? Lisibilite ?

" Code legacy:
REPORT z_sales_report.

TABLES: vbak.

SELECT-OPTIONS: s_vbeln FOR vbak-vbeln.

START-OF-SELECTION.
  SELECT vbak~vbeln vbak~erdat vbak~kunnr kna1~name1 vbak~netwr
    FROM vbak
    INNER JOIN kna1 ON vbak~kunnr = kna1~kunnr
    WHERE vbak~vbeln IN @s_vbeln
    INTO TABLE @DATA(lt_orders).

  cl_salv_table=>factory(
    IMPORTING r_salv_table = DATA(lo_alv)
    CHANGING  t_table      = lt_orders ).

  lo_alv->display( ).

Convert this classic ABAP report to:
1. CDS View with UI annotations
2. RAP Query (read-only)
3. OData V4 service
4. Fiori Elements UI
Target: ABAP Cloud compatible

Optimize this code for performance:

[Coller le code lent]

LOOP AT lt_orders INTO DATA(ls_order).
  SELECT SINGLE name1 FROM kna1
    WHERE kunnr = ls_order-kunnr
    INTO @DATA(lv_name).
  ls_order-customer_name = lv_name.
  MODIFY lt_orders FROM ls_order.
ENDLOOP.

" Optimise : SELECT unique avec FOR ALL ENTRIES
" Evite le probleme de requete N+1 (avant : 1 SELECT par commande)

" 1. Collecter les IDs clients uniques
DATA(lt_customer_ids) = VALUE kunnr_t(
  FOR order IN lt_orders ( order-kunnr ) ).
DELETE ADJACENT DUPLICATES FROM lt_customer_ids.

" 2. Lecture groupee des noms clients
SELECT kunnr, name1
  FROM kna1
  FOR ALL ENTRIES IN @lt_customer_ids
  WHERE kunnr = @lt_customer_ids-table_line
  INTO TABLE @DATA(lt_customers).

" 3. Mettre a jour les commandes avec CORRESPONDING
lt_orders = VALUE #(
  FOR order IN lt_orders
  LET customer_name = VALUE #( lt_customers[ kunnr = order-kunnr ]-name1 OPTIONAL )
  IN ( CORRESPONDING #( order ) customer_name = customer_name )
).

" Amelioration de performance : O(N) au lieu de O(N^2)
" Exemple : 1000 commandes
"   Avant : 1000 SELECTs (~10 secondes)
"   Apres :  2 SELECTs (~0.1 seconde)

Raccourcis VS Code:

Tab              Accepter la suggestion
Esc              Rejeter la suggestion
Alt+]            Suggestion suivante
Alt+[            Suggestion precedente
Ctrl+Enter       Afficher toutes les suggestions (panneau)

Chat:
Ctrl+Shift+I     Ouvrir le chat
/explain         Expliquer le code selectionne
/fix             Suggerer un correctif pour l'erreur
/tests           Generer des tests unitaires
/doc             Generer la documentation

Chat inline (dans l'editeur):
Ctrl+I           Chat inline au curseur

" Connaitre la logique specifique a l'entreprise
" Copilot NE sait PAS :
" - Vos tranches de numeros internes
" - Structures de tables Z personnalisees
" - Regles metier de votre entreprise
" -> Doit etre ajuste manuellement

" Planifier des architectures complexes
" Copilot peut generer du code, mais NE peut PAS :
" - Concevoir une architecture microservices
" - Decider : RAP Managed vs Unmanaged
" - Analyser les goulots de performance (sans donnees de profiling)

" Audits de securite
" Le code Copilot peut contenir :
" - Injection SQL (si non revu)
" - Credentials codes en dur (des donnees d'entrainement)
" - Controles d'autorisation manquants
" -> La revue de code est OBLIGATOIRE !

" Etre 100% correct
" Copilot fait des erreurs :
" - Erreurs de syntaxe (rare, mais possible)
" - Erreurs de logique (regles metier incorrectes)
" - Suggerer des APIs obsoletes
" -> Toujours tester !

" Copilot comme assistant, pas remplacement
" - Utiliser les suggestions comme point de depart
" - Revoir TOUT le code genere
" - Tester exhaustivement

" Travailler iterativement
" - Prompt -> Generer -> Revoir -> Affiner -> Repeter

" Conscient de la securite
" - Supprimer les secrets generes par Copilot
" - Verifier les controles d'autorisation
" - Respecter OWASP Top 10

" Revue de code
" - Traiter le code genere comme du code externe
" - Pair programming avec Copilot

" Apprendre
" - Copilot montre les bonnes pratiques
" - Comprendre le code genere (ne pas copier aveuglément !)