fireapi-24fire v1.0.5

fireapi-24fire

Die FireAPI-24Fire erleichtert die Interaktion mit der FireAPI in Node.js, was die Entwicklung effizienter gestaltet.

Features

• 🔗 Kommunikation über SSL
• 🏃 Schnelle interaktion
• ➡️ Direkte Anfragen ohne Middelware
• ℹ️ Verwalte VM, Domains, Dedicated Server, Account und Accounting

Optimierungen & Feedback

Welche Optimierungen hast du in deinem Code vorgenommen? Z.B. Refactoring, Performance-Verbesserungen

Wenn du Feedback hast, wenden dich an mich unter support@flostechnikwelt.de

Wie wird es installiert?

Um die FireAPI-24Fire in deinem Projekt zu installieren, führe bitte den folgenden Befehl aus

  npm install fire-24fire

Empfehlenswert

• Offizielle API Dokumentation
• Reseller werden
• Discord

Wie verwende ich fireapi-24fire?

Einen fireApi Client erstellen

  const fireApi = require("fireapi-24fire")
  const apiKey = 'DEIN_API_SCHLÜSSEL';
  const myFireApi = new fireApi(apiKey);

VM -> List

-> Zeige alle VMs an

  myFireApi.list().listVM().then(data => {
    console.log('Liste der VMs:', data);
  }).catch(error => {
    console.error('Fehler beim Abfragen der VMs:', error);
  });

-> Zeige alle Hostsysteme an

  myFireApi.list().listHosts().then(data => {
    console.log('Liste der Hosts:', data);
  }).catch(error => {
    console.error('Fehler beim Abfragen der Hosts:', error);
  });

-> Zeige alle Betriebsysteme an (OS) an

  myFireApi.list().listOS().then(data => {
    console.log('Liste der Betriebssysteme:', data);
  }).catch(error => {
    console.error('Fehler beim Abfragen der Betriebssysteme:', error);
  });

-> Zeige alle ISOs an

  myFireApi.list().listISO().then(data => {
    console.log('Liste der ISOs:', data);
  }).catch(error => {
    console.error('Fehler beim Abfragen der ISOs:', error);
  });

VM -> DDoS

-> Zeige alle DDoS Einstellungen an

  myFireApi.DDOS(vmID).getDDOSsettings().then(data => {
    console.log('DDoS Einstellungen:', data);
  }).catch(error => {
    console.error('Fehler beim Abfragen der DDoS Einstellungen:', error);
  });

-> Bearbeite die DDoS Einstellungen

  myFireApi.DDOS(vmID).editDDOSsettings('layer4', 'layer7', 'ip_adress').then(data => {
    console.log('Antwort von der fireApi:', data);
  }).catch(error => {
    console.error('Fehler beim bearbeiten der DDoS Werten: ', error);
  });

VM -> Backup

-> Zeige alle Backup an

  myFireApi.Backup(vmID).getAllBackups().then(backups => {
    console.log('All Backups:', backups);
  }).catch(error => {
    console.error('Error:', error);
  });

-> Ein Backup von einer VM erstellen

  myFireApi.Backup(vmID).createBackup().then(response => {
    console.log('Backup Created:', response);
  }).catch(error => {
    console.error('Error:', error);
  });

-> Status beim erstellen einens Backups

Wie weit ist der erstellungsprozess

  myFireApi.Backup(vmID).createBackupStatus().then(response => {
    console.log('Backup Creation Status:', response);
  }).catch(error => {
    console.error('Error:', error);
  });

-> Ein Backup auf den Server widerherstellen

  myFireApi.Backup(vmID).restoreBackup(backupId).then(response => {
    console.log('Backup Restored:', response);
  }).catch(error => {
    console.error('Error:', error);
  });

-> Den Wiederherstellungsprozess Status aprufen

Wie weit ist die Wiederherstellung

  myFireApi.Backup(vmID).restoreBackupStatus(backupId).then(response => {
    console.log('Restore Status:', response);
  }).catch(error => {
    console.error('Error:', error);
  });

-> Ein erstelltes Backup löschen

  myFireApi.Backup(vmID).deleteBackup(backupId).then(response => {
    console.log('Backup Deleted:', response);
  }).catch(error => {
    console.error('Error:', error);
  });

VM -> ISO

-> Eine ISO in die VM einlegen

  myFireApi.ISO(vmID).insertISO(ISOid).then(response => {
    console.log('ISO wurde eingelegt:', response)
  }).catch(error => { 
    console.error('Error beim versuch ISO einzulegen:', error)
  });

-> Eine ISO in die VM aus der VM entfernen

  myFireApi.ISO(vmID).removeISO().then(removeResponse => {
   console.log('ISO Removed:', removeResponse)
  }).catch(removeError => { 
   console.error('Error removing ISO:', removeError)
  });

VM

-> Eine VM neuistallieren

  myFireApi.VM().reinstall(vmID, OS).then(response => {
    console.log('Reinstall response:', response);
  }).catch(error => {
    console.error('Error reinstalling VM:', error);
  });

-> Eine neue VM erstellen

  myFireApi.VM().createVM(cores, mem, disk, os, hostsystem, ips, backup_slots, network_speed).then(response => {
    console.log('Create VM response:', response);
  }).catch(error => {
    console.error('Error creating VM:', error);
  });

-> VM Konfiguartion anpassen

  myFireApi.VM().reconfigureVM(vmID, cores, mem, disk, backup_slots, network_speed).then(response => {
    console.log('Antwort beim Rekonfigurieren der VM:', response);
  }).catch(error => {
    console.error('Fehler beim Rekonfigurieren der VM:', error);
  });

-> VM Konfiguartion anzeigen

  myFireApi.VM().getVMconfig(vmID).then(config => {
    console.log('VM-Konfiguration:', config);
  }).catch(error => {
    console.error('Fehler beim Abrufen der VM-Konfiguration:', error);
  });

-> Den RDNS-Eintrag verändern

  myFireApi.VM().changeRDNS(vmID, domain, ip_adress).then(response => {
    console.log('Antwort beim Ändern des RDNS für die VM:', response);
  }).catch(error => {
    console.error('Fehler beim Ändern des RDNS für die VM:', error);
  });

-> Einen noVNC-Konsolen Link erstellen

  myFireApi.VM().noVNC(vmID).then(response => {
        console.log('noVNC Link:', response);
  }).catch(error => {
        console.error('Error calling noVNC:', error);
  });

-> VM Löschen / Kündigen

  myFireApi.VM().deleteVM(vmID).then(response => {
    console.log('Antwort beim Löschen der VM:', response);
  }).catch(error => {
    console.error('Fehler beim Löschen der VM:', error);
  });

-> VM Status Abrufen

  myFireApi.VM().VMstatus(vmID).then(status => {
    console.log('VM-Status:', status);
  }).catch(error => {
    console.error('Fehler beim Abrufen des VM-Status:', error);
  });

-> Den aktuellen Installationsstatus abrufen

  myFireApi.VM().installStatus(vmID).then(installStatus => {
    console.log('Installationsstatus:', installStatus);
  }).catch(error => {
    console.error('Fehler beim Abrufen des Installationsstatus:', error);
  });

-> Das Passwort der VM zurücksetzten

Dies ist nur möglich wenn das Betreibsystem OS ist und nicht mit einer ISO erstellt wurde.

  myFireApi.VM().resetPassword(vmID).then(response => {
    console.log('Antwort beim Zurücksetzen des Passworts für die VM:', response);
  }).catch(error => {
    console.error('Fehler beim Zurücksetzen des Passworts für die VM:', error);
  });

-> VM Starten

  myFireApi.VM().startVM(vmID).then(response => {
    console.log('Antwort beim Starten der VM:', response);
  }).catch(error => {
    console.error('Fehler beim Starten der VM:', error);
  });

-> VM Stoppen

  myFireApi.VM().stopVM(vmID).then(response => {
    console.log('Antwort beim Stoppen der VM:', response);
  }).catch(error => {
    console.error('Fehler beim Stoppen der VM:', error);
  });

-> VM Neustarten

  myFireApi.VM().restartVM(vmID).then(response => {
        console.log('restartVM response:', response);
  }).catch(error => {
        console.error('Error calling restartVM:', error);
  });

Domain -> DNS

-> Einen DNS-Eintrag erstellen

  myFireApi.Domain().addDNS(domain, type, name, data).then(response => {
        console.log('DNS-Eintrag hinzugefügt:', response);
  }).catch(error => {
        console.error('Fehler beim Hinzufügen des DNS-Eintrags:', error);
  });

Mögliche DNS-Eintrag Typen sind: A, AAAA, CNAME, ALIAS, MX, SRV, TXT, CAA, PTR, NS, TLSA, DS, DNSKEY, HTTP_REDIRECT, HTTP_FRAME

-> Abrufen von DNS-Einträgen

  myFireApi.Domain().getDNSentries(domain).then(entries => {
        console.log('DNS-Einträge:', entries);
  }).catch(error => {
        console.error('Fehler beim Abrufen der DNS-Einträge:', error);
  });

-> Einen DNS-Eintrag löschen

  myFireApi.Domain().deleteDNSentrie(domain, recordId).then(response => {
        console.log('DNS-Eintrag gelöscht:', response);
  }).catch(error => {
        console.error('Fehler beim Löschen des DNS-Eintrags:', error);
  });

-> Einen DNS-Eintrag bearbeiten

myFireApi.Domain().editDNSentrie(domain, recordId, type, name, data)
    .then(response => {
        console.log('DNS-Eintrag bearbeitet:', response);
    })
    .catch(error => {
        console.error('Fehler beim Bearbeiten des DNS-Eintrags:', error);
    });

Anmerkung: Änderung wird bald kommen

Domain -> Handle

-> Einen Handle erstellen

myFireApi.Domain().createHandle(gender, firstname, lastname, street, number, zipcode, city, region, countrycode, email)
    .then(response => {
        console.log('Handle erstellt:', response);
    })
    .catch(error => {
        console.error('Fehler beim Erstellen des Handles:', error);
    });

-> Handle Abrufen

myFireApi.Domain().getHandle(handle).then(handleInfo => {
    console.log('Handle-Informationen abgerufen:', handleInfo);
  }).catch(error => {
    console.error('Fehler beim Abrufen der Handle-Informationen:', error);
  });

-> Handle bearbeiten

  myFireApi.Domain().updateHandle(handle, option, data).then(response => {
    console.log('Handle aktualisiert:', response);
  }).catch(error => {
    console.error('Fehler beim Aktualisieren des Handles:', error);
  });

Es kann nur einer per Anfrage verändert werden! (Wird bald geändert)

Mögliche option: street, number, zipcode, city, region, countrycode, email

Nicht möglich sind: gender, firstname, lastname

-> Countriecodes Abrufen

  myFireApi.Domain().getCountriecodes().then(countryCodes => {
    console.log('Ländercodes abgerufen:', countryCodes);
  }).catch(error => {
    console.error('Fehler beim Abrufen der Ländercodes:', error);
  });

Domain

-> Alle Domains abrufen

  myFireApi.Domain().getAllDomains().then(domains => {
      console.log('Alle Domains abgerufen:', domains);
  }).catch(error => {
      console.error('Fehler beim Abrufen aller Domains:', error);
  });

-> Eine Domain regestrieren

  myFireApi.Domain().registarDomain(domain, handle).then(response => {
        console.log('Domain registriert:', response);
  }).catch(error => {
        console.error('Fehler beim Registrieren der Domain:', error);
  });

-> Eine Domain übertragen via Authcode

  myFireApi.Domain().transferDomain(domain, handle, authcode).then(response => {
    console.log('Domain übertragen:', response);
  }).catch(error => {
    console.error('Fehler beim Übertragen der Domain:', error);
  });

-> Eine Domain Löschen / Kündigen

  myFireApi.Domain().deleteDomain(domain).then(response => {
    console.log('Domain gelöscht:', response);
  }).catch(error => {
    console.error('Fehler beim Löschen der Domain:', error);
  });

-> Eine Domain Löschung zurückziehen

  myFireApi.Domain().undeleteDomain(domain).then(response => {
    console.log('Domain wiederhergestellt:', response);
  }).catch(error => {
    console.error('Fehler beim Wiederherstellen der Domain:', error);
  });

-> Einen Authcode für eine Domain anfordern

  myFireApi.Domain().getAuthcode(domain).then(authcode => {
    console.log('Authcode abgerufen:', authcode);
  }).catch(error => {
    console.error('Fehler beim Abrufen des Authcodes:', error);
  });

-> Die Preise für Domains anfordern

  myFireApi.Domain().getDomainPricing().then(pricing => {
    console.log('Domain-Preisgestaltung abgerufen:', pricing);
  }).catch(error => {
    console.error('Fehler beim Abrufen der Domain-Preisgestaltung:', error);
  });

-> Genauere Informationen zu einer Domain Abrufen

  myFireApi.Domain().getDomainInfo(domain).then(domainInfo => {
    console.log('Domain-Informationen abgerufen:', domainInfo);
  }).catch(error => {
    console.error('Fehler beim Abrufen der Domain-Informationen:', error);
  });

-> Domain Verfügbarkeitscheck ausführen

  myFireApi.Domain().checkDomainAvailability(domain).then(availability => {
    console.log('Verfügbarkeit der Domain überprüft:', availability);
  }).catch(error => {
    console.error('Fehler beim Überprüfen der Verfügbarkeit der Domain:', error);
  });

-> Nameserver für eine Domain ändern

  myFireApi.Domain().changeNameserver(domain, ns1, ns2, ns3, ns4, ns5).then(response => {
        console.log('Nameserver geändert:', response);
  }).catch(error => {
    console.error('Fehler beim Ändern der Nameserver:', error);
  });

Dedicated

-> Den Marktplatz abrufen

    myFireApi.dedicated().getMarket().then(marketData => {
        console.log('Market Data:', marketData);
    }).catch(error => {
        console.error('Error fetching market data:', error);
    });

-> Verfügabrkeit überprüfen

    myFireApi.dedicated().checkAvailability(identifier).then(availabilityData => {
        console.log('Availability Data:', availabilityData);
    }).catch(error => {
        console.error('Error checking availability:', error);
    });

-> Einen Dedicated Server Kaufen

    myFireApi.dedicated().buyDedicatedServer(identifier, webhook, connect).then(response => {
        console.log('Buy Dedicated Server Response:', response);
    }).catch(error => {
        console.error('Error buying dedicated server:', error);
    });

Mehr Informationen finden sie auf der API Dokumentationsseite von 24fire: Dedi Kaufen

-> Genauere Informationen zu einem Dedi anzeigen

    myFireApi.dedicated().showDedicatedInfo(identifier).then(dedicatedInfo => {
        console.log('Dedicated Info:', dedicatedInfo);
    }).catch(error => {
        console.error('Error fetching dedicated info:', error);
    });

-> Dedicated-Server im Besitz anzeigen lassen

    myFireApi.dedicated().showAllDedicated().then(allDedicatedInfo => {
        console.log('All Dedicated Info:', allDedicatedInfo);
    }).catch(error => {
        console.error('Error fetching all dedicated info:', error);
    });

-> Einen Dedicated-Server löschen / Kündigen

    myFireApi.dedicated().deleteDedicated(identifier).then(deleteResponse => {
        console.log('Delete Dedicated Response:', deleteResponse);
    }).catch(error => {
        console.error('Error deleting dedicated server:', error);
    });

-> Eine Dedicated-Server löschung / Kündigung zurückziehen

    myFireApi.dedicated().undeleteDedicated(identifier).then(undeleteResponse => {
    console.log('Undelete Dedicated Response:', undeleteResponse);
    }).catch(error => {
        console.error('Error undeleting dedicated server:', error);
    });

Account

-> Alle Anfragen anzeigen

    myFireApi.account().getAllRequests(offset).then(requests => {
        console.log('All requests:', requests);
    }).catch(error => {
        console.error('Error fetching requests:', error);
    });

Accounting

-> Alle Rechnungen anzeigen lassen

    myFireApi.accounting().showAllInvoices().then(invoices => {
        console.log('Alle Rechnungen:', invoices);
    }).catch(error => {
        console.error('Fehler beim Abrufen aller Rechnungen:', error);
    });

-> Genaue Informationen zu einer Rechnung anrufen

    myFireApi.accounting().getInvoiceDetails(InvoiceID).then(invoiceDetails => {
        console.log('Details für Rechnung mit ID ' + InvoiceID + ':', invoiceDetails);
    }).catch(error => {
        console.error('Fehler beim Abrufen von Rechnungsdetails:', error);
    });

-> Aktuellen Rechnungsstand anzeigen

    myFireApi.accounting().getCurrentInvoiceStatus().then(currentStatus => {
        console.log('Aktueller Rechnungsstatus:', currentStatus);
    }).catch(error => {
        console.error('Fehler beim Abrufen des aktuellen Rechnungsstatus:', error);
    });

-> Aktuelle Preise anzeigen

    myFireApi.accounting().getPricings().then(pricings => {
        console.log('Pricings:', pricings);
    }).catch(error => {
        console.error('Fehler beim Abrufen der Pricings:', error);
    });

-> Aktuelle Rabbataktionen anzeigen lassen

    myFireApi.accounting().getSales().then(sales => {
        console.log('Verkäufe:', sales);
    }).catch(error => {
        console.error('Fehler beim Abrufen von Verkäufen:', error);
    });

Authors

• @flostechnikwelt