710 Nexar API (Octopart)¶

Voraussetzungen:¶

1. Erstellung eines Login's unter https://portal.nexar.com/
2. Anlage einer Application unter https://portal.nexar.com/applications/ AufklappenAufklappen

   

3. Eintragung von Client-ID und Client-Secret in den dynamischen Einstellungen in Prodat AufklappenAufklappen

   

Implementierte Funktionen¶

• Artikelinformationen in Stammdaten übernehmen
• Preise ale Lieferantenanfrage übernehmen

Technische Dokumentation¶

• Das Datenmodell der Nexar API: https://api.nexar.com/ui/voyager

• Für die Abfrage der API wird folgendes benötigt:
  • ein Token ... Dieser wird bei jeder Anfrage aus der Client-ID und dem Client-Secret erstellt.
    Dies macht die Funktion get_token() in nexarClient.py
  • eine Abfrage-Query ... Beispiele für Abfragen sind hier zu finden: https://support.nexar.com/support/solutions/articles/101000472564-query-templates
  • (optional Variablen ... Diese werden in der Abfrage-Query eingefügt, z.B. MPN)
• Die API wird mit der Python-Funktion results = nexar.get_query(query, variables) abgefragt

Integration in Prodat¶

• TabellenstrukturTabellenstruktur

  In der Tabelle nexar_api_call lässt sich die Abfrage-Query je Prodat-Form definieren
  

  CREATE TABLE nexar_api_call (
    nex_id               SERIAL PRIMARY KEY,     
    nex_api              text NOT NULL,       -- Nexar Anfrage-Query
    nex_ownerform        VARCHAR(100)         -- Prodat Form
   );
  

  In der Tabelle nexar_mapping lässt sich definieren welche Werte aus den erhaltenen Daten wo gespeichert werden sollen
  

  CREATE TABLE nexar_mapping (
    nexm_id               SERIAL PRIMARY KEY,     
    nexm_json_psth        VARCHAR(250) NOT NULL,  -- Nexar Attribut
    nexm_table            regclass NOT NULL,      -- Zieltabelle Prodat
    nexm_column           VARCHAR(100) NOT NULL   -- Zielfeld Prodat
   );
  

  
  Bsp:
  

  In der Tabelle link_import werden die Informationen zu einer durchgeführten Abfrage gespeichert.
  

  CREATE TABLE link_import (
    li_id               SERIAL PRIMARY KEY,     
    li_connector        varchar(20) NOT NULL,  -- Anbindung (z.B. Nexar)
    li_ownerform        varchar(100),          -- Prodat Form
    li_ownerform_var    json,                  -- Prodat Variablen
    li_api_call         text NOT NULL,         -- Anfrage-Query
    li_api_call_var     json,                  -- zusätzliche Variablen
    li_result           json NOT NULL          -- Ergebnis
   );
  

• Funktionen
  • Die Funktion connector_import_json ruft für eine durchgeführte Abfrage die passende Import-Funktion auf (aktuell nur auf Nexar beschränkt) SQLSQL

    CREATE OR REPLACE FUNCTION connector_import_json(
          IN _li_id  integer
        )
        RETURNS VOID AS $$
        DECLARE
          _r            record;
          _ak_nr        varchar;
        BEGIN
    
          SELECT *
            INTO _r
            FROM link_import
           WHERE li_id = _li_id;
    
          -- Nexar
          IF _r.li_connector = 'Nexar' THEN
    
            -- Artikelnummer aus den Variablen holen
            _ak_nr = _r.li_ownerform_var->>'ak_nr'; 
    
            -- JSON importieren
            PERFORM nexar_import_json(_r.li_result, _ak_nr);
    
          END IF;
    
        END $$ LANGUAGE plpgsql;
    

  • Die Funktionen get_dynamic_json_path ermitteln anhand eines JSON-Paths das passende Element SQLSQL

    CREATE OR REPLACE FUNCTION get_dynamic_json_path(json_data jsonb, path_parts varchar)
    RETURNS jsonb AS $$
    DECLARE
      path jsonb;
      current_part text;
    BEGIN
      path := json_data;
      current_part := path_parts;
    
        IF current_part ~ '^\\d+$' THEN
          -- JSON-Array-Element
          path := path -> current_part::int;
        ELSEIF current_part LIKE '$%' THEN
          -- JSON-Path-Query
          path := jsonb_path_query(path,current_part::JSONPATH);
        ELSE
          -- JSON-Objekt-Eigenschaft
          path := path -> current_part;
        END IF;
    
      RETURN path;
    END;
    $$ LANGUAGE plpgsql;
    
    CREATE OR REPLACE FUNCTION get_dynamic_json_path(json_data jsonb, path_parts varchar[])
    RETURNS jsonb AS $$
    DECLARE
      path jsonb;
      current_part text;
    BEGIN
      path := json_data;
    
      FOREACH current_part IN ARRAY path_parts
      LOOP
        IF current_part ~ '^\\d+$' THEN
          -- JSON-Array-Element
          path := path -> current_part::int;
        ELSEIF current_part LIKE '$%' THEN
          -- JSON-Path-Query
          path := jsonb_path_query(path,current_part::JSONPATH);
        ELSE
          -- JSON-Objekt-Eigenschaft
          path := path -> current_part;
        END IF;
      END LOOP;
    
      RETURN path;
    END;
    $$ LANGUAGE plpgsql;
    

  • Die Funktion nexar_import_json schreibt die Werte der Nexar API in die Prodat Datenbank SQLSQL

    CREATE OR REPLACE FUNCTION nexar_import_json(
          IN _results         json,
          IN _ak_nr           varchar,
          IN _write_to_art    boolean DEFAULT true,
          IN _write_to_epreis boolean DEFAULT true
        )
        RETURNS VOID AS $$
        DECLARE
          _seller            varchar;
          _seller_path       varchar;
          _inventory         varchar;
          _inventory_path    varchar;
          _r                 record;
          _value             varchar;
          _query             varchar;
        BEGIN
    
        -- Artikeldaten übernehmen
        IF _write_to_art THEN
    
          -- alle definierten Felder durchlaufen und Werte schreiben
          FOR _r IN (
            SELECT nexm_json_path AS path,
                   nexar_mapping.*
              FROM nexar_mapping
             WHERE nexm_table = 'art'::regclass 
            )
          LOOP
    
            -- Wert für Feld aus JSON gemäß Setting-Tabelle ermitteln
            SELECT get_dynamic_json_path(_results::jsonb, _r.nexm_json_path)
              INTO _value;
    
            continue when _value is null OR _value = 'null';
    
            -- Update Statement zusammenbauen und ausführen
            _query := 'UPDATE ' || _r.nexm_table::varchar || ' SET ' || _r.nexm_column::varchar || ' = ''' || _value || ''' WHERE ak_nr = ''' || _ak_nr || '''';
            EXECUTE _query;
    
          END LOOP;
    
        END IF;
    
        -- Lieferantenpreise übernehmen
        IF _write_to_epreis THEN
    
          -- alle definierten Felder durchlaufen und Werte schreiben
          FOR _r IN (
            SELECT nexm_json_path AS path,
                   nexar_mapping.*
              FROM nexar_mapping
             WHERE nexm_table = 'epreis'::regclass 
            )
          LOOP
    
            /*
            ToDo:
             1. Lieferanten aus Adressstamm mit Nexar ID holen
             2. Loop über alle relevanten Lieferanten (evt. sinnvoll einschränken?)
             2.1 passenden Eintrag in JSON zum Lieferant finden
             2.2 INSERT/UPDATE Statement zusammenbauen und ausführen
            */
    
          END LOOP;
    
        END IF;
    
        END $$ LANGUAGE plpgsql;
    

    • Funktion nexar_import_epreisstaffel schreibt Preisstaffeln in Prodat Datenbank SQLSQL

      CREATE OR REPLACE FUNCTION nexar_import_epreisstaffel(
            IN _prices          jsonb,
            IN _est_e_id        integer  DEFAULT null,
            IN _est_aart_id     integer  DEFAULT null,
            IN _est_aang_id     integer  DEFAULT null
          )
          RETURNS VOID AS $$
          DECLARE
            _r            record;
            _element      record;
            _query_insert varchar;
            _query_fields varchar;
            _value        varchar;
          BEGIN
      
            IF _est_e_id is null and _est_aart_id is null and _est_aang_id is null THEN
              RAISE EXCEPTION 'Staffelpreise können nicht ohne Bezug angelegt werden';
            END IF;
      
            -- Alte Staffel löschen
            EXECUTE 'DELETE FROM epreisstaffel WHERE ' || coalesce(_est_e_id::varchar,'null') || ' = est_e_id OR ' || coalesce(_est_aart_id::varchar,'null') || ' = est_aart_id OR ' || coalesce(_est_aang_id::varchar,'null') || ' = est_aang_id';
      
            FOR _element IN
              SELECT jsonb_array_elements FROM jsonb_array_elements(_prices)
            LOOP
      
              _query_insert := 'INSERT INTO epreisstaffel (est_e_id, est_aart_id, est_aang_id, est_ep, est_mengevon) VALUES (' || coalesce(_est_e_id::varchar,'null') || ', ' || coalesce(_est_aart_id::varchar,'null') || ', ' || coalesce(_est_aang_id::varchar,'null');
              _query_fields := '';
      
              -- alle definierten Felder durchlaufen und Werte schreiben
              FOR _r IN (
                SELECT nexm_json_path AS path,
                       nexar_mapping.*
                  FROM nexar_mapping
                 WHERE nexm_table = 'epreisstaffel'::regclass
                 ORDER BY nexm_column = 'est_ep'       desc,
                          nexm_column = 'est_mengevon' desc
                )
              LOOP
      
                -- Wert für Feld aus JSON gemäß Setting-Tabelle ermitteln
                SELECT get_dynamic_json_path(_element.jsonb_array_elements, _r.nexm_json_path)
                  INTO _value;
      
                IF _value is null THEN
                  _value := 'null';
                END IF;
      
                -- Update Statement zusammenbauen und ausführen
                _query_fields := _query_fields || ', ' || _value;
      
              END LOOP;
      
              -- Staffel schreiben
              EXECUTE _query_insert || _query_fields || ')';
      
            END LOOP;
      
          END $$ LANGUAGE plpgsql;
      

• Aufrufen lässt sich die Anbindung über den Zauberstab