Airbnb API: Jak používat API Mashvisor k získání dat Airbnb

Mashvisor API je nástroj pro analýzu nemovitostí, který poskytuje více než jen základní fakta o současných nebo potenciálních vlastnostech. Mashvisor může poskytnout data pomocí algoritmů statistické inference, které mohou někomu zabránit v provádění špatných investic do nemovitostí, pokud jde o Airbnb nebo tradiční pronájem.

API má dvě hlavní kategorie:

  • Krátkodobé výpůjčky (Airbnb) nebo výpisy nájemného na dovolenou
  • Dlouhodobé pronájmy („tradiční“)

API může poskytovat podrobné informace o specifických vlastnostech Airbnb za měsíc, včetně;

Koncové body jsou rozděleny do kategorií, jako je nemovitost, nájemné, trendy, prediktivní skóre atd. Někdo by mohl hledat celkové tržní trendy v oblasti nebo se zarazit na konkrétní nemovitost Airbnb. Možná vás zajímá, proč nepoužíváme API Airbnb k získání konkrétních výpisů nemovitostí, protože to je to, co hledáme.

Proč nepoužívat API Airbnb?

„V současné době nepřijímáme nové žádosti o přístup k našemu API. Náš globální tým partnerských manažerů osloví potenciální partnery na základě nabídky, kterou vaše firma představuje, síly vaší technologie a schopnosti podporovat naše sdílené zákazníky. “ Web Airbnb

Pokud bychom vytvářeli aplikaci pro uživatele, která by jim umožnila provádět akce (tj. Aktualizovat seznamy), pak bychom rádi měli přímý přístup k rozhraní Airbnb API. Tento přístup by s největší pravděpodobností přicházel prostřednictvím jiné strany než Airbnb.

Před vytvořením projektu by bylo užitečné přesně vědět, jaký typ dat potřebujete pro otázky, na které se pokoušíte odpovědět. Informace, které získáme z rozhraní Mashvisor API, by mohly:

  • Informujte potenciální hostitele Airbnb o tom, zda se ve své oblasti dělají dobré nebo špatné rozhodnutí
  • Pomozte cestovatelům určit, zda je výhodné používat Airbnb nebo jiné poskytovatele nájemného

Mashvisor je většinou analytický a informační a nevykonává akce pro uživatele na svém účtu.

S tímto rozhraním API existuje mnoho možností, ale nejdřív si projdu, jak jej použít. Poté budeme mít svobodu získat statistiky, které chceme sami sobě (nebo našim uživatelům) pomoci při rozhodování o nemovitostech založených na datech.

Jak používat API Mashvisor k získání dat Airbnb

Budeme potřebovat účet s RapidAPI a předplatné, abychom mohli používat rozhraní Mashvisor API (viz dokumentaci API zde).

Vyberte základní předplatné, které nám dává sto volání API měsíčně. Po prvních sto to bude stát 0,10 $ za žádost. Nezapomeňte, že naše použití můžeme vždy zobrazit a spravovat na vývojovém panelu RapidAPI. V následujícím příkladu byste se k vaší kvótě neměli přiblížit, ale pokud máte pocit, že se blížíte, připravte si řídicí panel.

S pouhými stovkami za měsíc musíme být chytří v tom, jak získáváme data a kolik z těchto dat popadáme najednou. Na stránce API najdeme užitečné informace. Na RapidAPI vyhledejte „Mashvisor“ a po odeslání vyberte možnost.

V levé části jsou uvedeny požadavky HTTP, které můžeme provést. Pokud vybereme typ požadavku, střední část nám ukáže volitelné a požadované parametry pro tento požadavek.

V horní části střední části si všimnete krátkého popisu každého koncového bodu.

Parametry střední části jsou vlastně vstupy a pokud tyto vstupy změníme, změní se i úryvky kódu v pravé části! V pravé části jsou také ukázkové odpovědi, abychom mohli vyhodnotit, jaká data získáme od koncového bodu.

V horní části pravé části je rozbalovací nabídka, ve které můžeme v tomto jazyce vybrat různé jazyky a různé knihovny. Úryvky kódu vynikají přidaným zbarvením specifickým pro daný jazyk. Budeme používat tento tvůrce úryvků pro naši aplikaci příkazového řádku NodeJS.

Kdekoli uvidíte „Krátkodobý pronájem“, většinou to znamená Airbnb.

Mashvisor má určitá prediktivní skóre, která generují pomocí vlastních algoritmů, mezi něž patří;

  • Mashmeter
  • Doporučovatel nemovitosti
  • Pravděpodobnost investice

Z toho budeme používat pouze Mashmeter v příkladu, který je popsán jako:

Unikátní skóre navržené Mashvisorem ukazuje celkové hodnocení investiční příležitosti v sousedství v procentech.

O jakémkoli z těchto skóre se můžete dočíst na stránce řídicího panelu rozhraní Mashvisor API.

Doufám, že jste nadšeni, že můžete vytvořit aplikaci příkazového řádku NodeJS, která nám umožní vytvářet personalizované investiční zprávy založené na našem místním sousedství!

Příklad aplikace: Měl bych si pronajmout tradičně nebo seznam na Airbnb?

Mashvisor poskytuje užitečné analytické informace, takže budeme stavět rozhraní příkazového řádku pomocí NodeJS, které bude shromažďovat statistiky, které pomohou odpovědět na otázku: „Měl bych si na základě sousedství, ve kterém žiji, pronajímat krátkodobě s Airbnb nebo tradičně? “ . Aplikace zasáhne pouze několik koncových bodů, ale mohla by být rozšířena o výstup více typů sestav.

Využije populární knihovny npm jako Yargs, Axios a Chalk. Bude používat nástroje NodeJS, jako je destruktivní, asynchronní / čekat, bloky try / catch a řetězcové literály.

Doufám, že vás to inspiruje k vybudování něčeho ještě většího a lepšího, takže začneme!

Předpoklady

  • Budete muset být obeznámeni s tím, jak otevřít a používat nástroj příkazového řádku.
  • Základní porozumění NodeJS nebo JavaScript
  • Budete chtít jednu z novějších verzí uzlu. Používám 10,16 a nainstalovanou nejnovější verzi npm. Používám 6.13.0, ale je dobré mít alespoň 5,6.
  • Připojení k internetu.
  • V systému MacOS budu používat nástroj příkazového řádku systému UNIX bash. Tento příkazový řádek však lze nainstalovat na Windows 10.
  • Účet RapidAPI a základní (bezplatné) předplatné rozhraní Mashvisor API.

Nastavení projektu

  1. Otevřete nový terminál (panel Command-Space, poté vyhledejte na počítači Mac terminál).
  2. Pomocí příkazu cd přejděte do adresáře, který má smysl. Chcete-li vidět, jaké adresáře jsou pod aktuálním adresářem, zadejte cd a dvakrát stiskněte klávesu Tab. Zobrazí se možnosti adresáře. Nyní lze spustit příkazy, které odpovídají tomuto formátu -> cd Lower_directory / directory_below_that_that.
  3. Vytvořte nový adresář příkazem mkdir [jméno_zadresáře]
  4. cd do tohoto adresáře. Můžete zkontrolovat, zda jste na správném místě spuštěním pwd. To znamená Print Working Directory.
  5. Inicializujte nový modul npm spuštěním npm init -y. Pokud byl příkaz spuštěn bez -y, pak by se zobrazily otázky, které by vás požádaly, abyste popsali a definovali aspekty nového modulu npm. Není to nutné pro tento tutoriál a spuštění příkazu s příznakem -y tento proces přeskočí. Ponechte tento terminál otevřený, protože budeme instalovat npm balíčky později a spouštět příkazy z kořenového adresáře projektu.
  6. Otevřete adresář projektu v editoru kódu podle vašeho výběru. Používám kód Visual Studio, takže spustím, který otevře VSCode v adresáři, ve kterém se právě nacházím.

Nyní máme nový projekt NodeJS, se kterým můžeme pracovat.

Porozumění argumentům příkazového řádku

Tento projekt vytvoří sestavy na základě dat vrácených pomocí rozhraní Mashvisor API. Budeme chtít schopnost tato data ukládat. To znamená, že potřebujeme příkazy přidat, zobrazit, zobrazit a odstranit. V našem projektu použijeme knihovnu Yargs, ale nejdřív potřebujeme trochu více porozumět tomu, jak budeme předávat argumenty s našimi příkazy.

  1. V adresáři projektu vytvořte soubor s názvem cli.js.
  2. Vložte kód console.log (process.argv)
  3. Do terminálu zadejte následující příkaz: node cli.js "test". Měl by být zobrazen seznam s několika položkami. Jednou z těchto položek by měl být „test“. Příkaz, který jsme spustili, provede soubor cli.js pomocí NodeJS a uloží argument, který jsme mu dali, do pole, ke kterému můžeme v souboru přistupovat. Takto předáme data do našeho projektu.

Přesto by přístup k této proměnné mohl být chaotický. Vypadalo by to jako proces.argv [2]. Naštěstí existuje knihovna npm, která připojuje tyto argumenty k objektu a dává nám schopnost sestavovat příkazy založené na těchto argumentech: Yargs.

4. Vraťte se zpět na terminál a nainstalujte Yargs příkazem npm install yargs --save.

5. V cli.js musíme importovat náš nový modul a analyzovat náš nový objekt. Do tohoto souboru přidejte níže uvedený kód.

6. Zadejte uzel cli.js --argument = "test". Měli byste vidět náš první argument přihlášený a nový objekt, který má klíčový argument a hodnotu test.

Budování našich příkazů

  1. Vytvořte nový adresář v našem kořenovém adresáři projektu, cmds.
  2. Vytvořte jiný adresář uvnitř toho, který se jmenuje report_cmds.
  3. Vytvořte soubor add.js uvnitř reports_cmds.

Mohli bychom umístit všechny naše příkazy do stejného souboru, ale to může být chaotické. Místo toho se chystáme sestavit naši aplikaci, přičemž každý příkaz bude mít vlastní soubor.

4. Přidejte následující položky do souboru add.js.

exports.command = 'add' // název příkazu exports.desc = 'Přidá novou sestavu' // popis příkazu exports.builder = {} // sestavení a popis argumentů exporty.handler = function (argv) {console.log ("Přidá novou zprávu") // funkce, která se spustí, když se příkaz nazývá}

V tomto souboru exportujeme vlastnosti příkazu 'add'.

  • command: syntaxe příkazu
  • desc: popis toho, co příkaz dělá
  • stavitel: Popište argumenty, které náš příkaz přijímá
  • handler: funkce, která se spustí, když je příkaz vydán.

Pokud bychom spustili příkaz jako add nli cli.js, očekávali bychom, že se spustí. To však nebude fungovat, protože Yargs nezná náš adresář příkazů. Potřebujeme provést několik změn, abychom to našli.

5. V cli.js nahraďte veškerý kód, který tam máme, níže uvedeným kódem;

Vyžadovat ('yargs') .commandDir ('cmds') // najde adresář příkazů .demandCommand () .help () // nám umožňuje použít příkaz help .argv // analyzuje argumenty

To může být matoucí z pohledu, ale vytváříme příkazový modul, který nám umožňuje vytvářet složité příkazy. Pokud chcete více kontextu pro tuto strukturu kódu, je vytaženo z dokumentace příze.

6. Vytvořte soubor v cmds / adresáři s názvem reports.js. Tento soubor bude vypadat podobně jako cli.js.

// reports.js
exporty.command = 'zprávy 'vývozu.desc =' Spravovat sestavy 'Exports.builder = function (yargs) {návrat yargs.commandDir (' report_cmds ') // vyhledejte příkazy sestavy} exporty.handler = funkce (argv) {}

Všimněte si, že příkaz v tomto souboru vypadá trochu jinak. Syntaxe je zástupný symbol vyjadřující, že argument je povinný. Pokud by příkaz měl být volitelný, byl by zabalen do [].

7. V terminálu stále v kořenovém adresáři našeho adresáře vydejte nápovědu k uzlu cli.js

Příkazy: zprávy cli.js Spravujte zprávy
Možnosti: --version Zobrazit číslo verze [boolean] --help Zobrazit nápovědu [boolean]

Měli byste vidět popis našeho příkazu (z reports.js) a další možnosti. Zkuste to znovu, ale tentokrát zadejte uzel cli.js report help.

Měli byste vidět náš příkaz add s jeho popisem.

Příkazy: cli.js reports add Přidá novou sestavu

8. Zpět v add.js musíme nastavit argumenty, které budeme předávat jako parametry pro volání API. Příkaz bude vypadat takto:

To znamená, že příkaz add má tři požadované argumenty. Objekt vývozu.builder bude použit k popisu argumentu, označení podle potřeby nebo ne a k podrobnému popisu typu argumentu (řetězec, číslo atd.).

// add.js
... export.builder = {name: {description: 'Report name.', demandOption: true, // dělá to požadovaný typ: 'string' // define object}, ... ...

9. Přidejte níže uvedený kód a přidejte add.js

exports.command = 'add 'vývozu.desc =' Přidat novou zprávu 'Exports.builder = {name: {description:' Name report. ', demandOption: true, type:' string '}, location: {description:' ID sousedství Mashvisor pro načtení dat for. ', demandOption: true, type:' number '}, state: {description:' State to pull data for. ', demandOption: true, type:' string '},} export.handler = function (argv) { console.log ('Přidá zprávu')}

Toto je náš první skutečný příkaz. Vyžaduje to tři argumenty. Při volání nemá žádnou funkci, ale brzy bude spuštěna.

10. Spusťte nápovědu pro zprávy uzlu cli.js a podívejte se na náš příkaz add s argumenty a deskriptory. Dále můžete spustit přidání uzlů cli.js, které selže, ale zobrazí popisy a typy argumentů, které příkaz potřebuje.

11. Soubory pro příkazy seznamu, zobrazení a odebrání jsou velmi podobné. Z důvodu času vytvořte každý soubor v adresáři report_cmds / list (list.js, remove.js, view.js) a přidejte k těmto souborům odpovídající kód.

// list.js
exports.command = 'list' Exports.desc = 'Seznam všech přehledů'ports.handler = () => {console.log (' Seznam všech názvů přehledů ')}
Celý kód naleznete na adrese https://rapidapi.com/blog/mashvisor-api-airbnb-data/

Vytváření popisovačů základních funkcí

Každý příkaz má popisovač. Jedná se o funkci, která se volá, když je příkaz vydán. Tyto funkce musíme vytvořit, ale uděláme to v samostatném souboru.

  1. V kořenovém adresáři projektu vytvořte soubor reports.js.
  2. V tomto souboru budeme mít funkce pro naše příkazy. Tyto funkce musíme exportovat ze souboru.
const listReports = () => {// vypíše názvy přehledů}
const addReport = async (jméno, sousedstvíId) => {// přidá zprávu}
const viewReport = (name) => {// vytiskne data sestavy}
const removeReport = (name) => {// odebere zprávu z reports.json}
module.exports = {addReport, removeReport, listReports, viewReport,}

Data našich přehledů budou uložena jako seznam v místním souboru. Zde budeme číst, ukládat, načítat a odstraňovat data zpráv.

3. Vytvořte soubor reports.json v kořenovém adresáři adresáře a umístěte do něj seznam, který obsahuje příklad objektu [{"name": "test", "location": 54678}]

Budeme potřebovat dvě pomocné funkce, které načtou zprávy z reports.json a jednu, která tyto zprávy uloží zpět do tohoto souboru. Uděláme to pomocí vestavěného modulu fs od NodeJS. Budeme to vyžadovat v horní části report.js.

4. Přidejte tento kód na začátek souboru reports.js.

const fs = vyžadovat ('fs')
const loadReports = () => {try {let reportsBuffer = fs.readFileSync ('./ reports.json'); // najít a načíst soubor nechat reportsJson = reportsBuffer.toString (); // převést buffer na řetězec return JSON.parse (reportsJson); // parse string to object} catch (e) {return []; }}
const saveReports = (reports) => {const dataJson = JSON.stringify (reports); fs.writeFileSync ('reports.json', dataJson); } ...

5. Nyní můžeme vytvořit funkci seznamu. Jedná se o jednoduchou funkci, která zachytí sestavy a vytiskne názvy sestav do konzoly. Chystáme se okořenit knihovnou Chalk. Nainstalujte knihovnu křídy pomocí npm install chalk --save

Křída přidává zbarvení do výstupu konzoly. Více informací o křídě si můžete přečíst na její stránce npm.

6. Dokončete funkci seznamu v reports.js a importujte křídu v horní části souboru

const chalk = vyžadovat ('křída') ... const listReports = () => {const reports = loadReports (); reports.map ((report, i) => {console.warn (chalk.white.bgBlue (`$ {report.name}`));})} ...

Jsme téměř připraveni otestovat náš první příkaz, ale tuto funkci jsme nezahrnuli do příkazového souboru list.js.

7. V list.js nahraďte console.log („Seznam všech názvů přehledů“) reportem.listReports () a v horní části souboru přidejte;

const reports = vyžadují ('../../ zprávy');

8. Spusťte seznam zpráv uzlu cli.js. Měli byste vidět jméno našeho a pouze hlášení vytisknout na konzoli s modrým pozadím.

Dále se rychle postaráme o příkaz odstranění. Tato funkce převezme název (název sestavy) a poté jej odebere ze seznamu zpráv v souboru reports.json. Odstraňuje ji jednoduše tím, že ji po odfiltrování neuloží zpět do souboru se zbytkem zpráv.

9. Přidejte tento kód k funkci odebrání v reports.js

... const removeReport = (name) => {try {const reports = loadReports (); // načíst zprávy v let newReports = reports.filter (report => report.name! == name); // filtr pro získání přehledů, které neodpovídají jménu if (reports.length> newReports.length) {saveReports (newReports); // uložit seznam nových sestav do souboru console.log (chalk.green.inverse ('Report odstraněn!')))} else {console.log (chalk.red.inverse ('Report not found'))); }} úlovek (e) {návrat e}} ...

10. Přidejte funkci remove.js jako náhradu souboru console.log (...) a importujte objekt reportů.

// remove.js
const reports = vyžadovat ('../../ reports') ... ... vývozu.handler = function (argv) {reports.removeReport (argv.name)}

Všimněte si, že předáváme argument názvu funkci přes objekt argv. Uvnitř tohoto objektu bude vlastnost „name“, která drží hodnotu předanou z příkazového řádku.

Je konečně čas vytvořit příkaz add, který načte data Airbnb a tradiční nemovitosti z rozhraní Mashvisor API.

Načítání dat z Mashvisoru (integrace rozhraní Airbnb API)

Příkaz add;

  • Získejte data z Mashvisoru
  • Vyberte data, která chceme zachovat
  • Uložte tato data do reports.json

Budeme sestavovat naše HTTP volání v samostatném souboru s Axios. Ujistěte se, že jste stále v kořenovém adresáři projektu.

2. Vytvořte soubor api.js v kořenovém adresáři projektu. V tomto souboru importujte axia a přidejte následující kód, takže soubor vypadá takto:

const axios = vyžadovat ('axios')
const instance = axios.create ({timeout: 1000, záhlaví: {// zde přidané záhlaví bude použito na všechny 'instance' // níže v modulu.exports}});
module.exports = {util: {// zde přidáme naše API volání getNe NeighborhoodOverview: (city, state) => instance ({})}, airbnb: {// airbnb api calls here}, traditional: {/ / tradiční api hovory zde}}
viz celý kód na https://rapidapi.com/blog/mashvisor-api-airbnb-data/

Můžeme vytvořit všechna volání API v jednom souboru a exportovat je jako funkce připojené k různým objektům. Všimněte si, že vytváříme funkci na objektu util s názvem „getNe NeighborhoodOverview“ a předáváme mu dva z našich argumentů příkazového řádku „sousedství“ a „stav“.

To pomáhá uspořádat náš kód a umožňuje nám snadno vytvořit instanci Axios, která ukládá záhlaví, které potřebujeme pro každý požadavek.

Bohužel nemůžu jít do podrobností o knihovně Axios a instancích, ale o tom si můžete přečíst zde.

3. V prohlížeči přejděte do rozhraní Mashvisor API a na levém panelu na kartě „Hledat“ vyberte „Přehled sousedství“.

4. V pravém panelu na této stránce vyberte rozbalovací nabídku a najděte „Node.js“. Měl by existovat další postranní panel, který obsahuje „Axios“. Najděte ji a vyberte 'Axios'.

Záhlaví HTTP budou umístěna do instance Axios nahoře. Metoda, adresa URL a parametry jdou uvnitř našeho volání funkce. Po extrahování příslušných dat z fragmentu kódu by api.js měl mít tento kód v souboru.

const axios = vyžadovat ('axios') 
viz celý kód na https://rapidapi.com/blog/mashvisor-api-airbnb-data/

Problém s aktuální adresou URL spočívá v tom, že není dynamický. Potřebujeme, aby proměnné z příkazového řádku byly předány přímo do řetězce.

5. Nahraďte každou nabídku na obou koncích URL backtickem `. Tím se vytvoří řetězcový literál a umožní nám to vložit do řetězce proměnné se syntaxí $ {název_ proměnné}.

6. Nahraďte NeighborId v URL za $ {NeighborId} a hodnotu parametru state za proměnnou state, takže naše volání API bude vypadat takto:

... "method": "GET", "url": `https: //mashvisor-api.p.rapidapi.com/ne Neighborhood/$ {NeighborhoodId} / bar`," params ": {" state ": state } ...

Nyní, když máme nastaveno první volání API, musíme tuto funkci importovat do reports.js a zavolat do naší funkce addReport.

7. Importujte {util} do reports.js a ve funkci jej asynchronně zavolejte.

... const {util} = vyžadovat ('./ api') ...
... const addReport = async (jméno, sousedstvíId, stát) => {try {// {data: [name]} vytáhne datový objekt z odpovědi a přejmenuje ho // Získat data pro přehled sousedství const {data: OverviewData} = await util.getNe NeighborhoodOverview (sousedstvíId, stát)
// Pomozte vyhloubit hloubku objektu const NeighborOverview = OverviewData.content;
} catch (e) {console.log (e) return console.log (chalk.red.inverse ('Chyba při načítání dat'))}} ...

Do tohoto kódu jsem přidal několik dalších věcí. Zničujeme odpověď Axios tím, že z tohoto objektu odpovědi stáhneme vlastnost 'data' a přejmenujeme ji na "OverviewData".

Pak jdeme hlouběji do těla odpovědi proměnné NeighborOverview, protože obsah je o něco dále dolů. To víme tak, že se podíváme na příklady odpovědí na ovládacím panelu RapidAPI.

V této funkci chybí čtyři věci:

  1. Načítání ve zprávách
  2. Kontrola duplicitního názvu
  3. Výběr dat z objektu odpovědi
  4. Ukládání zpráv

8. Přidejte hovor na loadReports () v horní části funkce addReport () a uložte výsledek do reportů proměnných.

9. Pomocí funkce Javascript find () iterujte zprávy a hledejte duplicitní název.

10. Pokud neexistuje duplikát, zavolejte API, pokud existuje, zaznamenejte zprávu, která to vysvětluje. Po těchto přírůstcích bude funkce obsahovat kód;

... const addReport = async (jméno, sousedství, stát) => {const reports = loadReports (); const duplicateReport = reports.find (report => report.name === name);
if (! duplicateReport) {try {// {data: [name]} vytáhne datový objekt z odpovědi a přejmenuje ho // Získat data pro přehled sousedství const {data: OverviewData} = await util.getNe NeighborhoodOverview (NeighborhoodId, state) / / Pomozte vyhloubit hloubku objektu const NeighborOverview = OverviewData.content;
} catch (e) {console.log (e) return console.log (chalk.red.inverse ('Error fetching data report'))}} else {console.log (chalk.red.inverse ('Report už existuje') ))}} ...

Ukládání dat sestavy bude poměrně snadné. Musíme ji pouze posunout do proměnné naší sestavy a pak zavolat funkci saveReports (). Předtím musíme skutečně analyzovat data, která chceme z odpovědi.

11. Vytvořte složku util v kořenovém adresáři našeho adresáře a přidejte soubor cleanData.js.

Vím, že to může vypadat jako problém při vytváření všech těchto souborů a složek, ale pokud doufáme, že budujeme větší a vzrušující aplikace, je důležité věnovat pozornost organizaci našeho projektu. Nechceme dělat nepořádek.

Tato funkce přijme malý objekt odpovědi, přiřadí hodnoty novým vlastnostem a objekt vrátí. Již jsem se podíval na objekt odpovědí na ovládacím panelu RapidAPI a vybral jsem z objektu Airbnb a tradiční údaje o nemovitostech, které se mají použít.

Bude to vypadat jako spousta kódu, ale většina z toho je jednoduše přiřazení proměnných a objektů.

12. Přidejte níže uvedený kód do cleanData.js.

const cleanData = async (jméno, sousedstvíId) => {
// Získat data z objektu odpovědi a přiřadit novým proměnným const airbnb_properties = sousedstvíOverview.num_of_airbnb_properties; const traditional_properties = NeighborhoodOverview.num_of_traditional_properties; const mash_meter = sousedstvíOverview.mashMeter; const avg_occupancy = sousedstvíOverview.avg_occupancy; const roi_airbnb = sousedstvíOverview.airbnb_rental.roi; const roi_traditional = sousedstvíOverview.traditional_rental.roi; const cap_rate_airbnb = NeighborhoodOverview.airbnb_rental.cap_rate; const cap_rate_traditional = NeighborhoodOverview.traditional_rental.cap_rate; const rent_income_airbnb = sousedstvíOverview.airbnb_rental.rental_income; const rent_income_traditional = NeighborhoodOverview.traditional_rental.rental_income;
// Vytvoření objektu, který bude vrácen a přidán do sestav, viz zbytek na https://rapidapi.com/blog/mashvisor-api-airbnb-data/

Nyní máme objekt s deseti užitečnými datovými body o Airbnb a tradičních nájemních vlastnostech v dané čtvrti.

13. Přijměte tento objekt zpět ve funkci addReport () a uložte jej do našeho souboru reports.json. Musíme se také ujistit, že importujeme funkci cleanData (). Soubor a funkce by se nyní měly podobat;

... const cleanData = vyžadovat ('./ util / cleanData')
... const addReport = async (jméno, sousedstvíId) => {const reports = loadReports (); const duplicateReport = reports.find (report => report.name === name);
ostatní najdete na https://rapidapi.com/blog/mashvisor-api-airbnb-data/

Je to už nějakou dobu, co jsme použili příkazový řádek, ale je čas otestovat příkaz add, abychom se ujistili, že naše příkazy tuto funkci skutečně dosahují.

Pokud bychom se pokusili předat argumenty pro jméno, umístění a stav pomocí příkazového řádku, selhalo by to. Do našeho obslužného programu příkazu add jsme nepřidali volání funkce addReport (argv.name, argv.location, argv.state).

14. Importujte funkci addReport a zavolejte do add.js. Nezapomeňte zahrnout tři argumenty vytažené z objektu argv.

Soubor bude nyní mít kód:

const reports = vyžadují ('../../ zprávy');
exports.command = 'add 'vývozu.desc =' Přidat novou zprávu 'Exports.builder = {name: {description:' Name report. ', demandOption: true, type:' string '}, location: {description:' ID sousedství Mashvisor pro načtení dat for. ', demandOption: true, type:' number '}, state: {description:' State to pull data for. ', demandOption: true, type:' string '},} export.handler = function (argv) { reports.addReport (argv.name, argv.location, argv.state)}

Vyzkoušejte, zda se argumenty dostávají do funkce addReport ().

15. Vyjádřete volání funkce API ve funkci a přidejte:

console.log (jméno, sousedstvíId, stát)

Nad okomentovaným kódem. Před vyvoláním chyby by se měly protokolovat argumenty.

16. Spustit zprávy uzlu cli.js přidat "test" 45624 "WA"

// výstup konzoly ... test 45624 WA // naše argumenty, které jsme zadali! ReferenceError: OverviewData není definována // zbytek zásobníku ...

Perfektní! Naše argumenty se dostávají do funkce a lze je nyní použít při volání API do Mashvisoru.

17. Odkomentujte kód a odstraňte protokol konzoly. Spusťte následující příkaz a přidejte naši první skutečnou zprávu:

zprávy uzlu cli.js přidat "první zprávu" 271841 "WA"

Podívejte se dovnitř souboru reports.json a měli byste vidět naše příkladná data a naše první údaje o přehledech!

Musíme ještě udělat dvě věci.

  1. Dokončete funkci viewReport (name), abychom mohli tato data zobrazit pěkným způsobem.
  2. Napište příkaz, který najde sousedství nejblíže našemu aktuálnímu umístění.

Funkce zobrazení

V této funkci budeme muset:

  • Načíst zprávy (máme pro to funkci)
  • Podívejte se, zda dané jméno prošlo v argument je platný a;
  • Vyvolejte funkci, která tiskne zprávy

Budeme používat téměř identický kód z funkce add.

// reports.js ... const viewReport = (name) => {const reports = loadReports (); let found = reports.find ((report) => report.name === name) // pokud je nalezen report, zavolejte funkci, která vytiskne data do konzole} ...

2. Nastavte blok if / else pro vyvolání funkce, pokud je nalezena sestava s tímto jménem. Pokud neodpovídá hlášení, protokolovejte, že zprávu nelze najít.

// reports.js ... const viewReport = (name) => {const reports = loadReports (); let found = reports.find ((report) => report.name === name) if (found) {printBasicReport (found); // zatím neexistuje} else {console.log (chalk.red.inverse ('Tuto zprávu nelze najít.'))}} ...

Funkce printBasicReport (found) dosud neexistuje.

3. Vytvořte nový adresář v kořenovém adresáři projektu s názvem print_report a uvnitř tohoto adresáře vytvořte soubor s názvem printBasicReports.js.

Budeme sestrojit pole s menšími poli jako hodnoty. Každé pole bude mít dvě věci.

  1. Štítek pro data, která tiskneme.
  2. Odpovídající data z nalezeného objektu předáváme.

4. Zadejte níže uvedený kód do našeho nového souboru.

// printBasicReport.js
const printBasicReport = (nalezeno) => {
const reportLines = [["Název přehledu", found.name], ["Location", found.ne NeighborhoodId], ["Airbnb Properties", found.airbnb_properties], ["Traditional Properties", found.traditional_properties], ["Mash Meter ", found.mash_meter], [" Avg. Occupancy ", found.avg_occupancy], [" ROI - Airbnb ", found.roi_airbnb], [" ROI - Traditional ", found.roi_traditional], [" Cap Rate - Airbnb ", found.cap_rate_airbnb], [" Cap Rate - Traditional ", found.cap_rate_traditional], [" Rent Income - Airbnb ", found.rental_income_airbnb], [" Rent Income - Traditional ", found.rental_income_traditional],]
// iterujte položky a vytiskněte je na konzoli}
module.exports = printBasicReport;

Vytáhneme položky z nalezeného objektu a přizpůsobíme jej snadnějšímu čtení štítku.

Dále přidejte Chalk do procesu a console.log () naše data a štítky.

5. Konečný soubor printBasicReports.js bude mít kód;

const chalk = vyžadovat ('křída') // importovat křídu
const printBasicReport = (nalezeno) => {const labelText = chalk.white.bgCyan; // vytvořte funkci pomocí křídy
const reportLines = [["Název přehledu", found.name], ["Location", found.ne NeighborhoodId], ["Airbnb Properties", found.airbnb_properties], ["Traditional Properties", found.traditional_properties], ["Mash Meter ", found.mash_meter], [" Avg. Occupancy ", found.avg_occupancy], [" ROI - Airbnb ", found.roi_airbnb], [" ROI - Traditional ", found.roi_traditional], [" Cap Rate - Airbnb ", found.cap_rate_airbnb], [" Cap Rate - Traditional ", found.cap_rate_traditional], [" Rent Income - Airbnb ", found.rental_income_airbnb], [" Rent Income - Traditional ", found.rental_income_traditional],]
// iteruje řádky a přidává nějaké formátování reportLines.map (line => {console.log (labelText (řádek [0]) + +:: \ n \ t "+" ---- "+ řádek [1])} )}
module.exports = printBasicReport;

6. Vraťte se zpět na reports.js a importujte novou funkci nahoře

// zprávy. js ... const printBasicReport = vyžadovat ('./ print_report / printBasicReport') ...

Tento příkaz je téměř připraven k použití, ale musíme funkci přidat do view.js

7. Přidejte funkci do souboru view.js

// view.js const reports = vyžadují ('../../ reports') // funkce importu do souboru export.command = 'view 'vývozu.desc =' Zobrazit jednu sestavu 'Exports.builder = {name: {description: "Název sestavy, kterou chcete zobrazit.", demandOption: true, type:' string '}} export.handler = function (argv) {reports.viewReport (argv.name) // volání funkce a předat název z objektu argv}

8. V kořenovém adresáři našeho adresáře spusťte příkaz

zprávy uzlu cli.js zobrazují „první zprávu“

Výstup v konzole by měl vypadat takto!

Toto je spousta užitečných informací pouze z jednoho volání API. Můžeme použít Mash Meter jako prediktivní průvodce nebo jednoduše porovnat návratnost investic a příjmy z pronájmu mezi Airbnb a tradičními metodami.

Pokud chcete informace uložit později, můžete jednoduše přesměrovat výstup projektu do jiného souboru pomocí příkazu;

uzel cli.js view [name_of_report]> fileName.txt

Tím se vytvoří soubor a zapíše se jako jeho obsah.

Najděte své nejbližší sousedství

Hodím na vás dva soubory, které vám umožní zadat souřadnice a získat sousedství, které je vám nejblíže.

První je find-najbližší.js. Toto je nový příkaz a nový soubor půjde do adresáře cmds /.

const findClosestNe Neighborhood = vyžadovat ('../ util / findClosestNe Neighborhood')
exports.command = 'najít nejbližší 'vývozu.desc =' Vyhledá identifikační číslo sousedství 'vývozu.builder = {lat: {description:' Zeměpisná šířka aktuálního umístění ', demandOption: true, typ:' number '}, long: {description:' Délka současného umístění ' , demandOption: true, type: 'number'}, city: {description: 'City the location is in,, demandOption: true, type:' string '}, state: {description:' State uveďte polohu ', demandOption : true, type: 'string'},} export.handler = function (argv) {findClosestNe Neighborhood (argv.lat, argv.long, argv.city, argv.state)}

Dalším souborem byl soubor importovaný v horní části této stránky (pokud jste si to všimli).

2. V adresáři util vytvořte soubor findClosestNe Neighborhood.js a přidejte kód:

const {util} = vyžadovat ('../ api') const chalk = vyžadovat ('křída')
viz celý kód na https://rapidapi.com/blog/mashvisor-api-airbnb-data/

Tento soubor převezme vaše souřadnice, odešle požadavek do koncového bodu „Seznam sousedství“ v Mashvisoru a vrátí seznam objektů představujících sousedství ve vašem městě.

Poté porovná poskytnuté souřadnice se souřadnicemi pro každou čtvrť a určí, která je nejbližší. Nejedná se o dokonalou funkci výpočtu vzdálenosti, ale je nám dost blízko.

Musíme přidat volání API k objektu util v api.js.

3. Přidejte žádost HTTP sousedství seznamu do api.js pod předchozí volání API.

// api.js
... module.exports = {util: {... getNe NeighborhoodsInArea: (city, state) => instance ({"method": "GET", "url": `https: //mashvisor-api.p.rapidapi .com / city / sousedství / $ {state} / $ {city} `,})}, ...}

4. Získejte souřadnice vaší polohy nebo jakéhokoli místa, které vás zajímá. Pokud potřebujete pomoc se získáním souřadnic zeměpisné šířky a délky, Google má kroky, které vám pomohou.

5. Proveďte příkaz nejbližší k nalezení pomocí souřadnic, města a stavu.

Spustil jsem příkaz pro umístění na kopci Capitol v Seattlu.

uzel cli.js najít-nejbližší 47.627464 -122.321387 "Seattle" "WA"

A v konzole byl zaznamenán nejbližší soused.

Nejbližší sousedství je Broadway s identifikačním číslem 250150

Nyní jsem mohl znovu spustit příkaz přidat hlášení s tímto novým ID sousedství Mashvisor!

A je to!

Pohyb vpřed

Tato aplikace se zabývala mnoha tématy a přeskočila i několik. Je nastaven tak, aby tvůrce mohl vytvářet modulární příkazy, zprávy a zjednodušovat kód požadavku HTTP.

Jedním ze složitějších aspektů zachycení dat z API je vytažení dat z hloubek objektu reakce. Tato úloha je zdanění, zejména pokud jsme vytvořili tuto aplikaci pro volání 10 nebo 20 API.

Pokud se oba shodneme, že kopání do objektů je trochu nepříjemné, měli byste se podívat na GraphQL, protože RapidAPI nedávno přidala podporu pro tento typ jazyka dotazu.

Pokud chcete, můžete do aplikace přidat další volání HTTP.

Související zdroje

  • Nejlépe Geocoding a Location API
  • Nejlepší hotel API
  • Rozhraní API pro vývoj mobilních aplikací
  • Jak vytvořit aplikaci jako Airbnb?

Původně zveřejněno na adrese https://rapidapi.com 27. ledna 2020.