Die inspireerders agter die ontwikkeling van die statistiekdiens vir Tinkoff Investments was:

• artikel oor Habré “Wat Tinkoff Investments nie sê nie” 
• ontleding van die wense van platformgebruikers
• ‘n artikel oor die berekening van kommissies . 

Wat sal bespreek word?

• Slegs die toegepaste deel oor ontwikkeling.
• Werklike kennis en ervaring, wat baie belangrik is om met finansiële instrumente te werk.
• Oorsig van kwessies om aan te werk

Dus, ek wil handelsstatistieke bereken en dit op ‘n gerieflike manier doen. 

Ontwikkel ‘n statistiekdiens stap vir stap: 

1. Verbinding met Tinkoff Invest API
2. Teken data van Tinkoff Invest API in ‘n blaaier
3. Ontvangs van makelaarsverslae en transaksies
4. Berekening en uitvoer van inligting van belang
5. Gevolgtrekkings en planne vir die toekoms

Verbinding met Tinkoff Invest API

Om aan die API te koppel, kan jy enige sdk uit die dokumentasie neem https://github.com/Tinkoff/investAPI#sdk . Of npm-pakket ` tinkoff-sdk-grpc-js `. Dit is belangrik dat die pakket deur die ontwikkelaars opgedateer word na die nuutste weergawe. Installeer

npm en tinkoff-sdk-grpc-js

Nagaan

const { createSdk } = require(‘tinkoff-sdk-grpc-js’);   // Token wat soos hierdie verkry kan word   const TOKEN = ‘YOURAPI’;   // Die naam van die toepassing waarmee jy in die TCS-logboeke gevind kan word. const appName = ‘tcsstat’;   const sdk = createSdk(TOKEN, appNaam); (async () => { console.log(wag sdk.users.getAccounts()); })();

Resultaat: ‘n lys van jou rekeninge sal in die konsole vertoon word. Kom ons analiseer byvoorbeeld die nuanses:

• In die lys van rekeninge is daar ‘n “Beleggingsbank”, waarmee jy nie met die API kan werk nie
• Neem asseblief kennis dat die velde in camelCase kom, terwyl hierdie velde in die dokumentasie in onder_telling aangebied word. 
• Dit sal oral so wees, so jy kan nie net ‘n veld uit die dokumentasie neem en kopieer nie.

Nuttig:

• U kan hierdie kode in die projektak vind

https://github.com/pskucherov/tcsstat/tree/step1 https://github.com/pskucherov/tcsstat/compare/step1   

Teken data van Tinkoff Invest API in ‘n blaaier

Ek het next.js en socket.io geneem. Dit is nie ‘n sterk aanbeveling nie, kies na goeddunke. 

npx create-next-app@nuutste npm i socket.io socket.io-client

Ons gaan dadelik voort na die vriendskapstap volgende+socket+investapi, en sien die Nuttige afdeling van hierdie stap vir al die besonderhede.  Ek sal die besonderhede beskryf: 

• Aan die nodejs (bediener) kant is daar ‘n pages/api/investapi.js lêer. Dit is waar ons die socket.io-bediener skep en aan investapi koppel.
• Aan die blaaier (kliënt) kant koppel ons aan die bediener via ‘n sok en versoek rekeningdata van die makelaar. 
• Ons ontvang data van die makelaar op die bediener, en stuur dit dan na die kliënt. Wanneer hulle op die kliënt ontvang word, word hulle in die blaaier vertoon. 

Resultaat:  in die blaaierkonsole kan ons inligting oor rekeninge sien. Dit wil sê, in die laaste stap het ons inligting oor rekeninge in die bedienerkonsole (nodejs) gesien, in die huidige stap het ons hierdie inligting na die kliënt (blaaier) oorgedra.

Kom ons maak dit nou so dat u ‘n rekening vanaf die blaaier kan kies, en as daar geen teken is nie, word ‘n fout na die konsole gestuur. Die werk is eenvoudig en niks nuuts nie, so ek gee slegs skakels na commits

1. https://github.com/pskucherov/tcsstat/commit/7e1ac57061e5e971588479015b06d8814d6609a9
2. https://github.com/pskucherov/tcsstat/commit/b28ac973a57494f5232589b4cb6b9fb13b8af759 

Nuttig:

• Hoe om vriende te maak volgende en socket word hier in detail beskryf . 
• Vriendskapskode volgende+socket+investapi:

https://github.com/pskucherov/tcsstat/commit/a443a4ac1bb4f0aa898f638128755fe7391ee381 Vir wie bogenoemde moeilik is, bly ons op hierdie stadium en hanteer die kode. As jy vrae het – vra. https://github.com/pskucherov/tcsstat/tree/step2 https://github.com/pskucherov/tcsstat/compare/step1…step2

Ontvangs van makelaarsverslae en transaksies

Daar is drie metodes om makelaarsverslae en transaksies te ontvang

1. GetBrokerReport
2. KryDividende Buitelandse Uitreiker
3. GetOperationsByCursor

Van die begin af is dit belangrik om te weet: 

• Die makelaarsverslag word in die T-3-modus gegenereer, d.w.s. ambagte word daar vertoon na hul werklike uitvoering. 
• Gevolglik, as jy hierdie verslag vir die laaste twee dae aanvra, sal dit binne drie dae gereed wees. 
• Om transaksies vir die laaste dae te maak, gebruik ons ​​die metode om bedrywighede te ontvang, maar onthou dat hul ID en inhoud kan verander na die vorming van die makelaarsverslag.

GetBrokerReport

Om ‘n makelaarsverslag te kry, moet u die rekening-ID, begindatum en einddatum van die verslag neem, maar nie meer as 31 dae nie. Ons stuur ‘n versoek om ‘n verslag na die API te genereer in genereer _broker_report_request , kry ‘n taak-ID in reaksie. Daarna, met behulp van hierdie taak-ID, kry ons data van get _broker_report_response.

Kom ons begin kode skryf

Metode om die datum te kry, met inagneming van die aftrekking van die huidige datum

const getDateSubDay = (subDay = 5, begin = waar) => {     const date = new Date();     date.setUTCDate(date.getUTCDate() – subDag);       if (begin) {         datum.setUTCHours(0, 0, 0, 0);     } anders {         date.setUTCHours(23, 59, 59, 999);     }       keerdatum; };

Versoek generering van verslag 

const brokerReport = wag (sdk.operations.getBrokerReport)({         genereerBrokerReportRequest: {             accountId,             from,             to,         }, });

Resultaat:

• As gevolg van die eerste uitvoering van die opdrag, kry ons die taakId. 
• Die verslag begin aan die makelaar se kant gegenereer word. Wanneer dit gereed is, is onbekend, wag ons en trek die taakID van tyd tot tyd in afwagting van die verslag.
• Hoekom? Want as die verslag nie gereed is nie, gooi dit ‘n fout. As die verslag nie gereed is aan die makelaar se kant nie, dan is dit ‘n fout in jou kode. Verwerk asseblief: 30058|INVALID_ARGUMENT|taak nog nie voltooi nie, probeer asseblief later weer

Die kode vir die wag en ontvangs van ‘n verslag lyk iets soos hierdie.

const timer = asynchrone tyd => {     gee nuwe belofte terug (oplos => stelTimeout (oplos, tyd)); }   const getBrokerResponseByTaskId = async (taskId, bladsy = 0) => {     try {         return await (sdk.operations.getBrokerReport)({             getBrokerReportRequest: {                 taskId,                 page,             },         });     } vang (e) {         console.log(‘wag’, e);         wag timer (10000);         terugkeer wag getBrokerResponseByTaskId(taskId, bladsy);     } };

Dan gebeur dieselfde magie. Ons stop ons draaiboek, begin dit weer, ons het nie ‘n taak-ID nie. Ons voer die kode uit met die taakId-versoek, maar ons kry nie meer die taakId nie, maar dadelik die verslag. Towerkuns! En alles sou reg wees as dit altyd so was. Maar oor ‘n maand sal daar glad nie data wees nie. Nuttig :

• Hier en hier word ‘n bietjie teorie uiteengesit .
• Deur die kode saam te stel, sal die konsep iets soos hierdie lyk.

https://github.com/pskucherov/tcsstat/tree/step3.1 https://github.com/pskucherov/tcsstat/compare/step3.1

• As iemand hierop afkom, welkom by die kwessie . Nadat hulle hierdie magie herstel het, sal dit sy krag verloor en sal dit op een of ander manier anders wees. Maar op die huidige oomblik (21/03/2023) werk dit net so.

KryDividende Buitelandse Uitreiker

Iemand dink dalk dat die metode soortgelyk is aan die vorige een en jy kan ‘n enkele metode gebruik waarin jy net die naam van die bewerkings verander. Maar hulle het nie geraai nie!  Die benaming daar verskil baie, beide in die metodes en in die teruggestuurde inligting. En die bladsytelling begin vanaf 0, dan vanaf 1. Om nie deur dit alles verward te raak nie, is dit makliker om twee verskillende metodes te skryf. Wat vreemd is, want die logika van werk is dieselfde. Ek het lank gespoeg toe ek een metode probeer maak het en daar was minder kode. Daar sal geen voorbeelde hier wees nie.

GetOperationsByCursor

My gunsteling van die drie. Alhoewel nie die akkuraatste nie, maar die mees toereikende. Ons rig ‘n versoek van die begin van die skep van ‘n rekening tot die maksimum moontlike datum (die sluiting van ‘n rekening of die huidige een). Ons kry die antwoord, neem die wyser en vra weer solank daar data is.  En die kode is meer bondig as in die voorbeelde hierbo.

const timer = asynchrone tyd => {     gee nuwe belofte terug (oplos => stelTimeout (oplos, tyd)); }   const getOperationsByCursor = async (sdk, accountId, from, to, cursor = ”) => {     try {         const reqData = {             accountId,             from,             to,             limit: 1000,             state: sdk.OperationState.OPERATION_STATE_EXECUTED,             withoutCommissions: false,             sonder Handel: vals,             sonder Oornag: vals,             wyser,         };           terugkeer wag sdk.operations.getOperationsByCursor(reqData);     } vang (e) {         wag timer(60000);         terugkeer wag getOperationsByCursor(sdk, rekeningId, van, na, wyser = ”);     } };

Die konsep om te loop is hier: https://github.com/pskucherov/tcsstat/tree/step3.3 https://github.com/pskucherov/tcsstat/compare/step3.3   Nou is ons gereed om ontvangsbewerkings by te voeg ons aansoek. As dit korrek gedoen word, moet u makelaarsverslae kry vir die hele bestaan ​​van die rekening. En vir die ontbrekende data, dieselfde T-3’s, herlaai van bedrywighede. Maar dit kan in ‘n aparte artikel geskei word.   Van die belangrikste nuanses wat jy sal teëkom, is om bedrywighede en ‘n makelaarsverslag te plak.

•  As u vandag ‘n makelaarsverslag en transaksies vir die vereiste datums ontvang het, plaas dit alles in die databasis, dan is daar geen probleme nie. 
• Jy sal môre probleme hê wanneer jy die volgende gedeelte data van die verslag en bedrywighede ontvang en besluit om dit met die bestaande databasis te sinchroniseer. 
• Baie nuanses oor nie-ooreenstemmende of verandering van ID na verwerking
• Dan vir die OTC-mark stem die ID’s glad nie ooreen nie.
•  Sowel as die nuanses van sinchroniserende instrumente, wat weer nie saamval nie, as gevolg van die eienaardighede van die API. Maar dit is ‘n ander storie.

Kom ons voeg inligting oor bedrywighede by ons toepassing. Die hoofvraag sal wees waar die data verwerk en gestoor sal word.

•  As jy dit vir jouself doen, sal jy dieselfde data vanaf verskillende toestelle verbruik. Dan moet jy data op die bediener verwerk en stoor.
• As jy baie verskillende data het wat deur baie verskillende gebruikers verbruik word, dan moet jy besluit wat belangriker is: die spoed van die gebruikers of die besparing van yster aan jou kant. Wie ‘n oneindige hoeveelheid hardeware kan bekostig, tel alles op sy bediener en maak dit supervinnig vir gebruikers, wat die gebruikersbronne spaar, soos battery en verkeer, wat baie belangrik is op fone.

Op sy beurt is tel in die blaaier in beginsel nie die mees optimale oplossing nie. Daarom, wat nie duur is nie, ons beskou dit op ons bediener. Ons laat die res aan die kliënt oor. Ek wil regtig die kommissie op die bediener neem en bereken. Maar hier kom die nuanse genaamd “interaktiwiteit”. Kom ons sê jy het duisende operasies en dit neem vyf minute om dit te ontvang. Wat sal die gebruiker op hierdie tydstip hê? Spinner? Vordering? Infa oor hoeveel is opgelaai? Dit is ideaal om “aktiewe wag” te gebruik wanneer die gebruiker in die proses reeds iets kon sien. Hier is die resultaat:

• Bladsy laai
• Alle fakture word aangevra
• Daarna word alle transaksies met kommissies vir uitgevoer transaksies vir alle rekeninge aangevra. Soos data ontvang word, word dit in die blaaier weergegee.

Om nie die data in die gebeurtenisse elke keer te filter nie, trek ons ​​ons eie gebeurtenis vir elke rekening. Soos hierdie:

socket.emit(‘sdk:getOperationsCommissionResult_’ + accountId, {                 items: data?.items,                 inProgress: Boolean(nextCursor), });

Die konsep om bekend te stel is hier: https://github.com/pskucherov/tcsstat/tree/step3 https://github.com/pskucherov/tcsstat/compare/step2…step3 Beweeg aan. Dit is wonderlik dat jy hierdie reël gelees het! 

Berekening en uitvoer van inligting van belang

Hang af wie watter inligting benodig. Daarom vertel ek jou dadelik die belangrikste nuanses wat jy sal teëkom.

Werk met pryse 

Almal wat met finansies werk weet dat geldtransaksies slegs met heelgetalle uitgevoer moet word. As gevolg van die onakkuraatheid van waardes na die desimale punt en die kumulatiewe fout met ‘n groot aantal bewerkings. Dit is hoekom alle pryse in die volgende MoneyValue- formaat aangebied word

veld	tipe	Beskrywing
geldeenheid	string	String ISO geldeenheid kode
eenhede	int64	Heelgetal deel van die som, kan ‘n negatiewe getal wees
nano	int32	Fraksionele deel van die bedrag, kan ‘n negatiewe getal wees

Ons verwerk hulle afsonderlik en bring dit dan na die pryswaarde:

quotation.units + quotation.nano / 1e9

Die koste van termynkontrakte

Die prys van termynkontrakte word in punte aangebied, wanneer jy ‘n geldeenheid toekoms het, moet jy die koers ken. En natuurlik die prys in punte en die prysstap. Wanneer jy die wins uit transaksies bereken, kan dit skiet, want. as jy die totale bedrag bereken deur die prys met die hoeveelheid te vermenigvuldig. Hier moet jy versigtig wees. Vir eers sal ons sien hoe dit gaan. Dit geld vir valuta-termynkontrakte, op ander plekke is alles reg hiermee.

OTC mark

Hierdie mark het baie eienaardighede, so kom ons bestudeer bedrywighede daaroor afsonderlik.Wanneer jy begin om bedrywighede te sinchroniseer, sal dit blyk dat jy figi / ticker na dieselfde vorm moet bring om die instrument korrek te pas. Wanneer jy dit met die makelaarsverslag begin sinchroniseer, sal dit blyk dat die tradeID van dieselfde transaksie letters aan die begin in die transaksies het en dit is nie in die makelaarsverslag nie. Daarom kan hulle nie vergelyk word nie … ahem-ahem … in vergelyking! Ek het die handelstyd, tikker en ooreenstem met die ooreenstemming dat een tradeId in ‘n ander vervat is. Reg, ek weet nie. Wie dit ook al teëkom en wie daarvoor omgee, kom na die kwessie of begin ‘n nuwe een.

Wiskundige bewerkings op gereedskap

Dit is onmoontlik, sonder om te kyk, om wiskundige bewerkings met die hele lys uit te voer. Om nie warm tot sag te voeg nie, gaan ons altyd die geldeenheid na en verwerk slegs as ons seker is dat die geldeenheid ooreenstem, en die punte word omgeskakel na die gewenste geldeenheid. Gewapen met kennis oor die werk met banknommers, sal ons die kommissie wat op elk van die rekeninge bestee word, bereken. Soos hierdie: https://github.com/pskucherov/tcsstat/tree/step4 https://github.com/pskucherov/tcsstat/compare/step3…step4    

Mikrodiens is gereed!

https://github.com/pskucherov/tcsstat As ‘n huiswerk kan jy kyk of die diens met ‘n stadige verbinding werk, wanneer verbindings gebreek word, wanneer die internet ontkoppel word, wanneer foute of verval perke aan die kant van die makelaar. 

Gevolgtrekkings en planne vir die toekoms

• Het geleer oor basiese bedrywighede en werk met die Invest API
• Tyd spandeer ~ 10 uur
• Moeilikheidsgraad ~ junior+ / lae middel 

As jy aanhou om die mikrodiens te verfyn, kan jy dalk met so iets eindig

https://opexbot.info

Dit is my ontwikkeling, vir diegene wat te lui is om op hul eie te verstaan, hardloop en tel. Ek beplan om analise daar by te voeg op versoek van gebruikers.   As jy van die artikel hou, teken dan in op my telegramkanaal .