Integration von HubSpot in Oracle APEX über REST API

           , , ,      No comments   

Integration von HubSpot und Oracle APEX über REST API





Teil 1: https://youtu.be/xNh7f8fOODc 
Teil 5: https://youtu.be/ntlJ0Q0tWYg

Willkommen zu meinem Blogbeitrag, in dem ich Schritt für Schritt erkläre, wie man HubSpot mittels REST API in Oracle APEX integriert. Unser Ziel ist es, Daten nahtlos zwischen diesen beiden Plattformen zu übertragen. Hier zeige ich euch, wie das geht:

  1. Erstellung eines Tokens in HubSpot: Ich beginne damit, wie man einen Authentifizierungstoken in HubSpot erstellt, der für den Zugriff via API erforderlich ist.
  2. Einrichtung einer Procedure in Oracle APEX: Anschließend zeige ich, wie man diese Authentifizierung in Oracle APEX verwendet, um mittels einer Procedure REST API Calls zu tätigen.
  3. Dateneingabe über ein Formular in HubSpot: Nachdem die Verbindung steht, erkläre ich, wie man Daten durch ein Formular direkt in HubSpot eingibt.
  4. Import von Daten zurück nach Oracle APEX: Zum Abschluss beschreibe ich, wie man die in HubSpot gespeicherten Daten wieder zurück in die Oracle APEX Datenbank importiert.

Begleitet mich durch diese detaillierte Anleitung, um zu erfahren, wie diese Integration effektiv umgesetzt werden kann!

Erste Schritte zur Integration von HubSpot und Oracle APEX

Bevor wir in die technischen Details eintauchen, ist es wichtig, dass ihr sowohl ein Oracle APEX-Konto als auch ein Entwicklerkonto bei HubSpot einrichtet. Sobald ihr euch bei HubSpot angemeldet habt, beginnt alles mit einem einfachen Klick:

  1. Sucht oben rechts auf der Seite nach dem Button und klickt darauf.
  2. Wählt dann „Profil & Einstellungen“ aus dem Menü.




Einrichten Ihrer privaten App in HubSpot

Nachdem ihr auf „Profil & Einstellungen“ geklickt habt, erscheint eine Vielzahl von Optionen auf der linken Seite. Um zur Integration zu gelangen, folgt diesen Schritten:

  1. Navigiert zum Abschnitt „Account-Setup“.
  2. Unter diesem Menüpunkt findet ihr die Option „Integration“. Klickt darauf.
  3. Wählt dann „Private Apps“ aus.

Hier beginnt der eigentliche Setup-Prozess für die private App, die wir für die REST API-Verbindung zwischen HubSpot und Oracle APEX nutzen werden.




Konfiguration Ihrer individuellen Apps für maßgeschneiderte Integration

Im Bereich „Private Apps“ habt ihr die Möglichkeit, eure eigenen Apps zu konfigurieren, um eine Integration zwischen HubSpot und Oracle APEX zu gewährleisten.



Erstellung einer neuen App in HubSpot

Wenn ihr im Bereich „Private Apps“ seid, werdet ihr feststellen, dass zunächst keine Apps vorhanden sind. Wir werden eine neue App erstellen. Folgt dazu diesen einfachen Schritten:

  1. Klickt auf „App erstellen“ oder „Neue App hinzufügen“.
  2. Ein Konfigurationsassistent wird geöffnet, der euch Schritt für Schritt durch den gesamten Prozess der App-Erstellung führt.

Konfigurieren der Details der neuen App

Der nächste Schritt ist es mit den notwendigen Detailinformationen zu versehen.

  • Name: Gebt einen Namen ein.
  • Beschreibung: Gebt eine klare Beschreibung eurer App an.






Definieren der API-Berechtigungen im Reiter „Bereiche“ und Einrichtung einer Testumgebung sowie App-Erstellung

Ein kritischer Teil beim Konfigurieren eurer neuen App ist der Reiter „Bereiche“. In diesem Abschnitt legt ihr fest, welche Berechtigungen eure App haben soll. Diese Einstellungen sind von entscheidender Bedeutung, denn sie bestimmen, auf welche Daten eure App zugreifen und welche Aktionen sie ausführen darf:

  • Leserechte: Erlauben der App, Daten zu lesen.
  • Schreibrechte: Ermöglichen, Daten zu verändern oder zu ergänzen.

Es ist wichtig, nur die Berechtigungen zu aktivieren, die unbedingt notwendig sind.


Für eine effektive Testphase empfehle ich, zunächst alle Berechtigungs-Checkboxen zu aktivieren. Dies ermöglicht es euch, alle Funktionen der API ohne Einschränkungen durch Berechtigungsfehler zu testen. Beachtet jedoch, dass diese Einstellung ausschließlich für Testzwecke gedacht ist. Hier die Schritte:

  1. Aktivierung aller Berechtigungen: Stellt sicher, dass ihr alle Funktionalitäten der API umfassend testen könnt.
  2. App erstellen: Nachdem ihr alle notwendigen Informationen eingegeben und die Berechtigungen für die Testphase eingestellt habt, klickt auf den Button „App erstellen“.

Mit diesen Schritten wird eure neue App in HubSpot erstellt und ist bereit für die Integration mit Oracle APEX.

Bestätigung und Abschluss der App-Erstellung

Nachdem ihr auf „App erstellen“ geklickt habt, erscheint normalerweise eine Bestätigungsaufforderung.

  • Bestätigung der Details: Überprüft noch einmal alle eingegebenen Informationen und bestätigt dann die Erstellung der App.


Erhalt und sichere Aufbewahrung Ihres Zugriffstokens

Nach der Bestätigung der App-Erstellung wird euch ein Zugriffstoken angezeigt. Dieser Token spielt eine zentrale Rolle für die Authentifizierung eurer App bei API-Aufrufen:

  • Sicherheit des Tokens: Es ist äußerst wichtig, diesen Token sicher aufzubewahren. Da er den Zugang zu euren Daten in HubSpot ermöglicht, solltet ihr ihn vor unbefugtem Zugriff schützen.
  • Verwendung des Tokens: Nutzt den Token in eurem Code, um euch programmatisch bei der HubSpot API zu authentifizieren.



Überwachung der API-Aufrufe in Ihrem HubSpot-Konto

Sobald eure App in HubSpot erfolgreich eingerichtet ist, könnt ihr sie jederzeit in eurem Konto einsehen. Ein besonders nützlicher Aspekt dabei ist die Möglichkeit, einen detaillierten Überblick über die API-Aufrufe zu erhalten. Dies bietet folgende Vorteile:

  • Monitoring der Operationen: Ihr könnt alle durchgeführten API-Aufrufe überwachen.
  • Analyse der Datenübertragungen: Zugriff auf die Historie der API-Aufrufe ermöglicht es euch, zu überprüfen, welche Daten übertragen wurden und wie die Interaktionen stattgefunden haben.

Diese Funktionen sind besonders wertvoll, um sicherzustellen, dass eure Integration korrekt funktioniert und um potenzielle Probleme frühzeitig zu erkennen und zu beheben.

Vorbereitung zur Datenübertragung und Formularerstellung in Oracle APEX

Nachdem ihr eure Einstellungen in HubSpot abgeschlossen habt, ist es entscheidend, den Zugriffstoken sorgfältig zu notieren.

  1. Notieren des Tokens: Stellt sicher, dass ihr den Token sicher speichert, da er für die Autorisierung der Datenübertragung zwischen den Systemen benötigt wird.

Wechselt nun zu Oracle APEX, um das nächste Ziel zu erreichen:

  1. Erstellung eines Formulars in Oracle APEX: Nachdem ihr euch eingeloggt habt, erstellt ein Formular. Dieses Formular sollte verschiedene Felder enthalten, die auf die Daten abgestimmt sind, die ihr erfassen wollt.
Erstellen einer neuen Seite in Oracle APEX mit einem interaktiven Button

Nachdem ihr euch in Oracle APEX eingeloggt habt, könnt ihr beginnen, eine neue Seite zu gestalten.

  1. Erstellen einer neuen Seite: Geht im Menü auf die Option zum Erstellen einer neuen Seite.

  2. Hinzufügen eines Buttons: Auf dieser neuen Seite fügt ihr einen Button hinzu. Konfiguriert den Button so, dass er bei einem Klick ein Popup-Fenster öffnet.

  3. Konfiguration des Popup-Fensters: Das Popup-Fenster sollte so gestaltet sein, dass es zusätzliche Daten erfassen kann.

Einrichten eines modalen Fensters für Datenintegration in Oracle APEX

Nachdem der Button auf eurer Hauptseite platziert ist, wird durch seinen Klick ein modales Fenster geöffnet. Dieses modale Fenster, das als Seite Nummer 10 definiert wird, ist für den Datenerfassungsprozess:

  1. Einrichtung des Fensters: Stellt sicher, dass das Fenster als Seite Nummer 10 eingerichtet ist und sich automatisch öffnet, wenn der Button gedrückt wird.

  2. Hinzufügen der Eingabefelder: Fügt die notwendigen Felder hinzu, um die Daten zu erfassen, die ihr später in HubSpot speichern möchtet.

  3. Zielsetzung der Datenerfassung: Die Daten aus diesen Feldern werden direkt an HubSpot gesendet, sobald sie eingegeben und abgesendet werden.

Durch diese Schritte werden die Daten schnell und direkt in HubSpot gespeichert.

Gestaltung des Formulars auf der modalen Seite Nummer 10 in Oracle APEX

Auf der modalen Seite Nummer 10 sollten Sie ein benutzerfreundliches Formular einrichten, das folgende Elemente enthält:

Datenübertragung von Oracle APEX zu HubSpot mittels PL/SQL

Nachdem ein Benutzer das Formular auf der modalen Seite Nummer 10 ausgefüllt und auf „Speichern“ geklickt hat, triggert das System automatisch eine PL/SQL-Prozedur.

BEGIN
    create_hubspot_contact(
        p_email    => :P10_EMAIL,
        p_firstname => :P10_FIRSTNAME,
        p_lastname => :P10_LASTNAME,
        p_website  => :P10_WEBSITE,
        p_company  => :P10_COMPANY,
        p_phone    => :P10_PHONE,
        p_address  => :P10_ADDRESS,
        p_city     => :P10_CITY,
        p_state    => :P10_STATE,
        p_zip      => :P10_ZIP
    );
END;

Oracle APEX-Paket zur Kommunikation mit HubSpot

Innerhalb des Oracle APEX-Projekts wird ein entwickeltes Paket genutzt, das den notwendigen Code zur Interaktion mit der HubSpot-API beinhaltet. Dieses Paket ist zentral für die effiziente und sichere Übertragung von Daten zwischen Oracle APEX und HubSpot.

create or replace PROCEDURE create_hubspot_contact (
    p_email    VARCHAR2,
    p_firstname VARCHAR2,
    p_lastname VARCHAR2,
    p_website  VARCHAR2,
    p_company  VARCHAR2,
    p_phone    VARCHAR2,
    p_address  VARCHAR2,
    p_city     VARCHAR2,
    p_state    VARCHAR2,
    p_zip      VARCHAR2
) AS
    l_response CLOB;
    l_url VARCHAR2(500) := 'https://api.hubapi.com/crm/v3/objects/contacts';
    l_body CLOB;
BEGIN
    -- Setzen der notwendigen Header für JSON Content-Type und Authorization
    apex_web_service.g_request_headers(1).name := 'Content-Type';
    apex_web_service.g_request_headers(1).value := 'application/json';
    apex_web_service.g_request_headers(2).name := 'Authorization';
    apex_web_service.g_request_headers(2).value := 'Bearer APEX-API-TOKEN';
   
    -- Erstellen des Body für den POST-Request mit Parametern
    l_body := '{
            "properties": {
                "email": "' || p_email || '",
                "firstname": "' || p_firstname || '",
                "lastname": "' || p_lastname || '",
                "website": "' || p_website || '",
                "company": "' || p_company || '",
                "phone": "' || p_phone || '",
                "address": "' || p_address || '",
                "city": "' || p_city || '",
                "state": "' || p_state || '",
                "zip": "' || p_zip || '"
            }
        }';

    -- Ausführen des POST-Requests
    l_response := apex_web_service.make_rest_request(
        p_url => l_url,
        p_http_method => 'POST',
        p_body => l_body
    );

    -- Optional: Antwort verarbeiten oder loggen
    dbms_output.put_line(l_response);

EXCEPTION
    WHEN OTHERS THEN
        dbms_output.put_line('Error: ' || SQLERRM);
END;

Procedur sofern Wallet angebunden ist.

create or replace PROCEDURE create_hubspot_contact (
    p_email    VARCHAR2,
    p_firstname VARCHAR2,
    p_lastname VARCHAR2,
    p_website  VARCHAR2,
    p_company  VARCHAR2,
    p_phone    VARCHAR2,
    p_address  VARCHAR2,
    p_city     VARCHAR2,
    p_state    VARCHAR2,
    p_zip      VARCHAR2
) AS
    l_response UTL_HTTP.req;
    l_resp UTL_HTTP.resp;

    l_url VARCHAR2(500) := 'https://api.hubapi.com/crm/v3/objects/contacts';
    l_body CLOB;
BEGIN


    -- Wallet- und HTTPS-Konfiguration
    UTL_HTTP.set_wallet('file:/opt/oracle/oradata/wallet/hubapi', 'Sajjad786');
   
    -- Erstellen des Body für den POST-Request mit Parametern
    l_body := '{
            "properties": {
                "email": "' || p_email || '",
                "firstname": "' || p_firstname || '",
                "lastname": "' || p_lastname || '",
                "website": "' || p_website || '",
                "company": "' || p_company || '",
                "phone": "' || p_phone || '",
                "address": "' || p_address || '",
                "city": "' || p_city || '",
                "state": "' || p_state || '",
                "zip": "' || p_zip || '"
            }
        }';

    -- Ausführen des POST-Requests
    l_response := UTL_HTTP.begin_request(
        url => l_url,
        method => 'POST',
        http_version => 'HTTP/1.1'
    );

    -- Header für JSON und Authorization setzen
    UTL_HTTP.set_header(l_response, 'Content-Type', 'application/json; charset=utf-8');
    UTL_HTTP.set_header(l_response, 'Authorization', 'Bearer APEX-API-TOKEN');
    UTL_HTTP.set_header(l_response, 'Content-Length', LENGTH(l_body));

    -- JSON-Body senden
    UTL_HTTP.write_text(l_response, l_body);

   
    -- Response erhalten
    l_resp := UTL_HTTP.get_response(l_response);

     

EXCEPTION
    WHEN OTHERS THEN
        dbms_output.put_line('Error: ' || SQLERRM);
END;
/




Prozess zur Erstellung eines Kontakts in HubSpot über Oracle APEX

Wenn ein Benutzer das bereitgestellte Formular in Oracle APEX ausfüllt und auf den Button zum Speichern klickt, wird folgender Vorgang ausgelöst:

  1. Aktivierung der ProzedurDie Prozedur „CREATE_HUBSPOT_CONTACT“ wird gestartet.

  2. DatensammlungZuerst sammelt die Prozedur alle Daten, die der Benutzer ins Formular eingegeben hat.

  3. Vorbereitung des HTTP POST-RequestsInnerhalb der Prozedur wird ein HTTP POST-Request erstellt. Dieser Request enthält alle notwendigen Informationen, um einen neuen Kontakt in HubSpot zu registrieren.

  4. Senden des RequestsDer vorbereitete Request wird an HubSpot gesendet. Dies erfolgt über die sichere API-Verbindung, die durch das Authentifizierungssystem von HubSpot geschützt ist.

  5. Einpflegen des neuen KontaktsNachdem der Request erfolgreich von HubSpot verarbeitet wurde, wird der neue Kontakt im HubSpot CRM systematisch eingepflegt. Dies schließt den Prozess ab, und der Kontakt ist nun Teil des CRM-Systems.

Dieser gesamte Prozess stellt sicher, dass die von den Benutzern bereitgestellten Daten effizient und sicher in das HubSpot CRM integriert werden.

Überprüfung eines neu erstellten Kontakts in HubSpot

Nachdem ein neuer Kontakt durch das Oracle APEX-Frontend erfolgreich erstellt wurde, kann der Benutzer die Integration und Funktionalität einfach überprüfen:

  1. Anmelden bei HubSpotZuerst loggt sich der Benutzer in sein HubSpot-Konto ein.

  2. Zugriff auf das CRM-ModulNavigiert im HubSpot-Dashboard zum CRM-Modul, welches zentral für die Verwaltung von Kontaktdaten ist.

  3. Öffnen der Kontakte-ÜbersichtInnerhalb des CRM-Moduls findet ihr die Kontakte-Übersicht. Hier könnt ihr alle bestehenden Kontakte einsehen.

  4. Suchen des neuen KontaktsDer über Oracle APEX erstellte neue Kontakt sollte nun in der Liste sichtbar sein. Ihr könnt nach spezifischen Details des Kontakts suchen, um sicherzustellen, dass alle Informationen korrekt übertragen wurden.

Diese Schritte zeigen die effektive und automatisierte Verbindung zwischen Oracle APEX und HubSpot, die eine nahtlose Kontaktverwaltung ermöglicht.

Massenimport bestehender Kontakte aus Oracle in HubSpot

Wenn ihr bereits Kontakte in eurer Oracle-Datenbank habt und diese in HubSpot übertragen möchtet, könnt ihr dies durch eine automatisierte Methode erreichen, die viele Kontakte gleichzeitig handhabt:

  1. Verwendung eines SELECT FOR LOOPsUmfangreichere Datenmengen können durch die Integration eines SELECT FOR LOOP um die bestehende Prozedur „CREATE_HUBSPOT_CONTACT“ verarbeitet werden. Dieser LOOP durchläuft alle ausgewählten Datensätze in der Oracle-Datenbank.

  2. Automatisierung des Upload-ProzessesFür jeden Kontakt im LOOP wird die Prozedur aufgerufen, die einen HTTP POST-Request an HubSpot sendet, um den Kontakt dort einzupflegen. Dies geschieht sequenziell für jeden Kontakt in der Schleife.

Durch diesen Ansatz könnt ihr eine größere Anzahl von Kontakten schnell und ohne manuellen Aufwand in das HubSpot CRM importieren.

Schritte zum Importieren von Kontaktdaten aus HubSpot in Oracle APEX

Nachdem die Kontakte in HubSpot erfolgreich erstellt wurden – in Ihrem Fall sechs Kontakte –, ist es an der Zeit, den Importmechanismus zu testen und zu demonstrieren:

  1. Vorbereitung des ImportprozessesStellen Sie sicher, dass in Oracle APEX eine geeignete Prozedur vorhanden ist, um die Daten aus HubSpot abzurufen.

  2. Durchführung des ImportsAktivieren Sie die Prozedur, um die Daten von HubSpot in Ihre Oracle APEX-Datenbank zu importieren.

  3. Überprüfung der importierten DatenNachdem die Daten in Oracle APEX importiert wurden, überprüfen Sie, ob alle Informationen korrekt und vollständig übertragen wurden. Vergleichen Sie die Daten in Oracle APEX mit den Originaldaten in HubSpot, um sicherzustellen, dass keine Diskrepanzen vorliegen.

Durch die Umsetzung dieser Schritte können Sie sicherstellen, dass der Datenimport aus HubSpot korrekt funktioniert und die Synchronisation zwischen den beiden Systemen effektiv und fehlerfrei abläuft.

Einrichtung einer Oracle-Datenbanktabelle für HubSpot-Kontaktdaten

Um die aus HubSpot importierten Kontakte effektiv in Ihre Oracle-Datenbank zu integrieren, ist es entscheidend, eine geeignete Tabelle vorzubereiten. Diese Tabelle dient als zentraler Ort für die Speicherung und Organisation der importierten Daten:

CREATE TABLE HUBSPOT_CONTACTS
(
    ID VARCHAR2(100),
    CREATEDATE VARCHAR2(255),
    EMAIL VARCHAR2(255),
    FIRSTNAME VARCHAR2(255),
    LASTNAME VARCHAR2(255),
    COMPANY VARCHAR2(255),
    PHONE VARCHAR2(255),
    WEBSITE VARCHAR2(255),
    ADDRESS VARCHAR2(255),
    CITY VARCHAR2(255),
    STATE VARCHAR2(255),
    ZIP VARCHAR2(100),
    COUNTRY VARCHAR2(255),
    JOB_TITLE VARCHAR2(255),
    LINKEDIN_BIO CLOB,
    TWITTER_HANDLE VARCHAR2(255),
    HS_OBJECT_ID VARCHAR2(100),
    LASTMODIFIEDDATE VARCHAR2(255),
    ARCHIVED VARCHAR2(100),
    CREATED_ON TIMESTAMP(6) DEFAULT SYSDATE
);


Durch einer gut durchdachten Tabelle in Ihrer Oracle-Datenbank können Sie die aus HubSpot importierten Kontakte effizient verwalten.

Erstellung eines Classic Reports in Oracle APEX für HubSpot-Kontaktdaten

Nachdem Sie die Tabelle hubspot_contacts in Ihrer Oracle-Datenbank erfolgreich erstellt haben, können Sie einen Classic Report in Oracle APEX einrichten, um alle vorhandenen Kontakte anzuzeigen. Hierfür benötigen Sie ein einfaches SQL-Skript, das alle relevanten Daten aus der Tabelle abfragt. Folgen Sie diesen Schritten, um den Report zu erstellen:

select ID,
       CREATEDATE,
       EMAIL,
       FIRSTNAME,
       LASTNAME,
       COMPANY,
       PHONE,
       WEBSITE,
       ADDRESS,
       CITY,
       STATE,
       ZIP,
       COUNTRY,
       JOB_TITLE,
       LINKEDIN_BIO,
       TWITTER_HANDLE,
       HS_OBJECT_ID,
       LASTMODIFIEDDATE,
       ARCHIVED,
       to_Char(CREATED_ON, 'DD.MM.YYYY HH24:MI:SS') as CREATED_ON
  from HUBSPOT_CONTACTS  
  order by CREATED_ON DESC

Durch die Erstellung dieses Classic Reports in Oracle APEX erhalten Sie und Ihre Teammitglieder eine klare und effektive Übersicht über die in der Datenbank gespeicherten Kontakte.

Erweiterung Ihrer Oracle APEX-Seite mit zusätzlichen Funktionen

Nachdem die Tabelle hubspot_contacts in Ihrer Oracle-Datenbank erfolgreich erstellt wurde, können Sie Ihre Oracle APEX-Seite erweitern, um nicht nur die vorhandenen Kontakte anzuzeigen, sondern auch zusätzliche Interaktionen zu ermöglichen. Hierzu zählen das Importieren von Daten aus HubSpot und das Löschen von Daten in der APEX-Tabelle:

  1. Classic Report hinzufügenWie bereits beschrieben, fügen Sie einen Classic Report hinzu, um alle Daten aus der Tabelle hubspot_contacts zu visualisieren.

  2. Button „Import from HubSpot“ hinzufügen

    • Platzierung des ButtonsFügen Sie den Button „Import from HubSpot“ oberhalb oder unterhalb des Classic Reports hinzu. Dieser Button ermöglicht es Benutzern, neue Daten direkt aus HubSpot zu importieren.
    • Aktion definierenVerknüpfen Sie den Button mit einer Aktion, die eine Prozedur oder einen Prozess in APEX auslöst, um Daten von HubSpot abzurufen und in die Tabelle hubspot_contacts zu importieren.

  3. Button „Clear Apex Table“ hinzufügen

    • Platzierung des ButtonsDieser Button sollte ebenfalls in der Nähe des Reports platziert werden und ermöglicht das Löschen aller Daten in der hubspot_contacts Tabelle.
    • Aktion definierenDer Button sollte mit einem SQL-Script verknüpft werden, das alle Einträge in der Tabelle löscht.
      sql
      DELETE FROM hubspot_contacts;
    • Bestätigungsdialog hinzufügenUm versehentliches Löschen zu vermeiden, ist es ratsam, einen Bestätigungsdialog einzubauen, der vor der Ausführung des Löschvorgangs erscheint.

Durch das Hinzufügen dieser Buttons steigern Sie die Interaktivität Ihrer Oracle APEX-Seite und bieten den Benutzern praktische Werkzeuge zur Verwaltung der Daten in der hubspot_contacts Tabelle.

Vorbereitung Ihrer Oracle APEX-Seite für die anfängliche Anzeige
Zum jetzigen Zeitpunkt wird die APEX-Frontend-Seite noch leer erscheinen, da noch keine Kontakte importiert wurden.

Einrichtung des „Import from Hubspot“-Prozesses auf der APEX-Seite

Als Nächstes richten wir auf der APEX-Seite einen Prozess ein, der durch den Button „Import from Hubspot“ aktiviert wird. Dieser Prozess führt einen PL/SQL-Aufruf aus, der direkt mit der HubSpot-API kommuniziert, um Kontaktdaten abzurufen. Wenn der Benutzer auf „Import from Hubspot“ klickt, initiiert der Prozess das Abrufen der Kontaktinformationen und deren Import in unsere Oracle-Datenbank. Dies sorgt für eine nahtlose Übertragung der Daten direkt ins System und ermöglicht eine effiziente Aktualisierung unserer Kontaktliste.

DECLARE
    l_ws_response_clob CLOB;
    l_ws_url VARCHAR2(500) := 'https://api.hubapi.com/crm/v3/objects/contacts';
BEGIN

    apex_web_service.g_request_headers(1).name := 'Accept';
    apex_web_service.g_request_headers(1).value := 'application/json; charset=utf-8';
    apex_web_service.g_request_headers(2).name := 'Content-Type';
    apex_web_service.g_request_headers(2).value := 'application/json; charset=utf-8';
    apex_web_service.g_request_headers(3).name := 'Authorization';
    apex_web_service.g_request_headers(3).value := 'Bearer APEX-API-TOKEN';

    l_ws_response_clob := apex_web_service.make_rest_request(p_url => l_ws_url, p_http_method => 'GET');

    FOR r IN (
        SELECT j.*
        FROM JSON_TABLE(
            l_ws_response_clob, '$.results[*]'
            COLUMNS (
                id VARCHAR2(100) PATH '$.id',
                createdate VARCHAR2(255) PATH '$.properties.createdate',
                email VARCHAR2(255) PATH '$.properties.email',
                firstname VARCHAR2(255) PATH '$.properties.firstname',
                lastname VARCHAR2(255) PATH '$.properties.lastname',
                company VARCHAR2(255) PATH '$.properties.company',
                phone VARCHAR2(255) PATH '$.properties.phone',
                website VARCHAR2(255) PATH '$.properties.website',
                address VARCHAR2(255) PATH '$.properties.address',
                city VARCHAR2(255) PATH '$.properties.city',
                state VARCHAR2(255) PATH '$.properties.state',
                zip VARCHAR2(100) PATH '$.properties.zip',
                country VARCHAR2(255) PATH '$.properties.country',
                job_title VARCHAR2(255) PATH '$.properties.jobtitle',
                linkedin_bio CLOB PATH '$.properties.linkedinbio',  
                twitter_handle VARCHAR2(255) PATH '$.properties.twitterhandle',  
                hs_object_id VARCHAR2(100) PATH '$.properties.hs_object_id',
                lastmodifieddate VARCHAR2(255) PATH '$.properties.lastmodifieddate',
                archived VARCHAR2(10) PATH '$.archived'
            )
        ) j
    )
    LOOP
        INSERT INTO hubspot_contacts (id, createdate, email, firstname, lastname, company, phone, website, address, city, state, zip, country, job_title, linkedin_bio, twitter_handle, hs_object_id, lastmodifieddate, archived)
        VALUES (r.id, r.createdate, r.email, r.firstname, r.lastname, r.company, r.phone, r.website, r.address, r.city, r.state, r.zip, r.country, r.job_title, r.linkedin_bio, r.twitter_handle, r.hs_object_id, r.lastmodifieddate, r.archived);
    END LOOP;
END;


Procedur sofern Wallet angebunden ist.

DECLARE
    l_response UTL_HTTP.REQ;
    l_resp UTL_HTTP.RESP;
    l_ws_response_clob CLOB;
    l_ws_url VARCHAR2(500) := 'https://api.hubapi.com/crm/v3/objects/contacts';
BEGIN

      -- Wallet- und HTTPS-Konfiguration
    UTL_HTTP.set_wallet('file:/opt/oracle/oradata/wallet/hubapi', 'Sajjad786');

     -- Request initialisieren
    l_response := UTL_HTTP.begin_request(l_ws_url, 'GET', UTL_HTTP.HTTP_VERSION_1_1);

        -- Header für JSON und Authorization setzen
    UTL_HTTP.set_header(l_response, 'Content-Type', 'application/json; charset=utf-8');
    UTL_HTTP.set_header(l_response, 'Authorization', 'Bearer APEX-API-TOKEN');

        -- Response erhalten
    l_resp := UTL_HTTP.get_response(l_response);

        -- Response-Body lesen
    UTL_HTTP.read_text(l_resp, l_ws_response_clob);
    UTL_HTTP.end_response(l_resp);

    FOR r IN (
        SELECT j.*
        FROM JSON_TABLE(
            l_ws_response_clob, '$.results[*]'
            COLUMNS (
                id VARCHAR2(100) PATH '$.id',
                createdate VARCHAR2(255) PATH '$.properties.createdate',
                email VARCHAR2(255) PATH '$.properties.email',
                firstname VARCHAR2(255) PATH '$.properties.firstname',
                lastname VARCHAR2(255) PATH '$.properties.lastname',
                company VARCHAR2(255) PATH '$.properties.company',
                phone VARCHAR2(255) PATH '$.properties.phone',
                website VARCHAR2(255) PATH '$.properties.website',
                address VARCHAR2(255) PATH '$.properties.address',
                city VARCHAR2(255) PATH '$.properties.city',
                state VARCHAR2(255) PATH '$.properties.state',
                zip VARCHAR2(100) PATH '$.properties.zip',
                country VARCHAR2(255) PATH '$.properties.country',
                job_title VARCHAR2(255) PATH '$.properties.jobtitle',
                linkedin_bio CLOB PATH '$.properties.linkedinbio',  
                twitter_handle VARCHAR2(255) PATH '$.properties.twitterhandle',  
                hs_object_id VARCHAR2(100) PATH '$.properties.hs_object_id',
                lastmodifieddate VARCHAR2(255) PATH '$.properties.lastmodifieddate',
                archived VARCHAR2(10) PATH '$.archived'
            )
        ) j
    )
    LOOP
        INSERT INTO hubspot_contacts (id, createdate, email, firstname, lastname, company, phone, website, address, city, state, zip, country, job_title, linkedin_bio, twitter_handle, hs_object_id, lastmodifieddate, archived)
        VALUES (r.id, r.createdate, r.email, r.firstname, r.lastname, r.company, r.phone, r.website, r.address, r.city, r.state, r.zip, r.country, r.job_title, r.linkedin_bio, r.twitter_handle, r.hs_object_id, r.lastmodifieddate, r.archived);
    END LOOP;
END;


Einrichtung des „Clear Apex Table“-Prozesses auf der APEX-Seite

Zusätzlich etablieren wir einen Prozess, der das Löschen der importierten Datensätze in unserer Oracle-Datenbank übernimmt. Dieser Prozess wird durch den Button „Clear Apex Table“ aktiviert. Ein Klick auf diesen Button führt dazu, dass alle Einträge aus der Tabelle hubspot_contacts entfernt werden.

delete from HUBSPOT_CONTACTS;

Gestaltung des Seitenlayouts im Oracle APEX Page Designer

Nach Abschluss der Konfiguration sollte das Layout Ihrer APEX-Seite im Page Designer folgendermaßen aussehen:

Automatischer Import von Kontaktdaten durch den 'Import from Hubspot'-Button

Wenn in Ihrer Oracle APEX-Anwendung der 'Import from Hubspot'-Button betätigt wird, sollte folgender Prozess automatisch ausgelöst werden:

  1. Initiierung des Importvorgangs

  2. Datenabfrage bei HubSpot

  3. Datenübertragung und -speicherung

Durch diesen automatisierten Prozess wird sichergestellt, dass die Kontakte schnell und fehlerfrei von HubSpot in Ihre Oracle APEX-Anwendung übertragen werden.

Zugang zum Testbereich und Download der Anwendung

Das gesamte Setup Ihrer Oracle APEX-Anwendung kann im APEX Workspace umfassend getestet werden. Sie können den Testbereich über den folgenden Link erreichen:

Oracle APEX Testbereich

Für zusätzliche Flexibilität und weitere Analysen sind sowohl die Anwendung selbst als auch alle zugehörigen SQL- und PL/SQL-Skripte zum Download verfügbar. Diese Ressourcen ermöglichen es Ihnen, die Anwendung und die Skripte in Ihrer eigenen Umgebung einzurichten, anzupassen und detailliert zu testen.

Durch den Zugriff auf diese Materialien können Sie nicht nur die Funktionalität im Testmodus überprüfen, sondern auch sicherstellen, dass die Integration und die Datenverarbeitung Ihren spezifischen Anforderungen entsprechen.


0 $type={blogger}:

Kommentar veröffentlichen