ടിങ്കോഫ് നിക്ഷേപങ്ങൾക്കായുള്ള സ്ഥിതിവിവരക്കണക്ക് സേവനത്തിന്റെ വികസനത്തിന് പിന്നിലെ പ്രചോദനം :

• ഹബ്രെയെക്കുറിച്ചുള്ള ലേഖനം “എന്താണ് ടിങ്കോഫ് നിക്ഷേപങ്ങൾ പറയുന്നില്ല” 
• പ്ലാറ്റ്ഫോം ഉപയോക്താക്കളുടെ ആഗ്രഹങ്ങളുടെ വിശകലനം
• കമ്മീഷനുകളുടെ കണക്കുകൂട്ടലിനെക്കുറിച്ചുള്ള ഒരു ലേഖനം . 

എന്ത് ചർച്ച ചെയ്യും?

• വികസനത്തെക്കുറിച്ചുള്ള പ്രായോഗിക ഭാഗം മാത്രം.
• സാമ്പത്തിക ഉപകരണങ്ങളുമായി പ്രവർത്തിക്കുന്നതിൽ വളരെ പ്രധാനപ്പെട്ട യഥാർത്ഥ അറിവും അനുഭവവും.
• പ്രവർത്തിക്കേണ്ട പ്രശ്നങ്ങളുടെ അവലോകനം

അതിനാൽ, വ്യാപാര സ്ഥിതിവിവരക്കണക്കുകൾ കണക്കാക്കാനും സൗകര്യപ്രദമായ രീതിയിൽ ചെയ്യാനും ഞാൻ ആഗ്രഹിക്കുന്നു. 

ഒരു സ്റ്റാറ്റിസ്റ്റിക്സ് സേവനം ഘട്ടം ഘട്ടമായി വികസിപ്പിക്കുന്നു: 

1. ടിങ്കോഫ് ഇൻവെസ്റ്റ് എപിഐയിലേക്കുള്ള കണക്ഷൻ
2. ഒരു ബ്രൗസറിൽ ടിങ്കോഫ് ഇൻവെസ്റ്റ് എപിഐയിൽ നിന്ന് ഡാറ്റ വരയ്ക്കുന്നു
3. ബ്രോക്കറേജ് റിപ്പോർട്ടുകളും ഇടപാടുകളും സ്വീകരിക്കുന്നു
4. താൽപ്പര്യമുള്ള വിവരങ്ങളുടെ കണക്കുകൂട്ടലും ഔട്ട്പുട്ടും
5. ഭാവിയിലേക്കുള്ള നിഗമനങ്ങളും പദ്ധതികളും

ടിങ്കോഫ് ഇൻവെസ്റ്റ് എപിഐയിലേക്കുള്ള കണക്ഷൻ

API-യിലേക്ക് കണക്റ്റുചെയ്യാൻ, നിങ്ങൾക്ക് https://github.com/Tinkoff/investAPI#sdk എന്ന ഡോക്യുമെന്റേഷനിൽ നിന്ന് ഏതെങ്കിലും sdk എടുക്കാം . അല്ലെങ്കിൽ npm പാക്കേജ് ` tinkoff-sdk-grpc-js `. ഡെവലപ്പർമാർ പാക്കേജ് ഏറ്റവും പുതിയ പതിപ്പിലേക്ക് അപ്‌ഡേറ്റ് ചെയ്യുന്നത് പ്രധാനമാണ്. ഇൻസ്റ്റാൾ ചെയ്യുക

npm i tinkoff-sdk-grpc-js

പരിശോധിക്കുന്നു

const { createSdk } = ആവശ്യമാണ് (‘tinkoff-sdk-grpc-js’);   // ഇതുപോലെ ലഭിക്കാവുന്ന ടോക്കൺ   const TOKEN = ‘YOURAPI’;   // ടിസിഎസ് ലോഗുകളിൽ നിങ്ങളെ കണ്ടെത്താൻ കഴിയുന്ന ആപ്ലിക്കേഷന്റെ പേര്. const appName = ‘tcsstat’;   const sdk = createSdk(TOKEN, appName); (async () => {     console.log(sdk.users.getAccounts() കാത്തിരിക്കുക); })();

ഫലം: നിങ്ങളുടെ അക്കൗണ്ടുകളുടെ ഒരു ലിസ്റ്റ് കൺസോളിൽ പ്രദർശിപ്പിക്കും. ഉദാഹരണത്തിന്, നമുക്ക് സൂക്ഷ്മതകൾ വിശകലനം ചെയ്യാം:

• അക്കൗണ്ടുകളുടെ പട്ടികയിൽ ഒരു “ഇൻവെസ്റ്റ്മെന്റ് ബാങ്ക്” ഉണ്ട്, അത് ഉപയോഗിച്ച് നിങ്ങൾക്ക് API ഉപയോഗിച്ച് പ്രവർത്തിക്കാൻ കഴിയില്ല
• ഫീൽഡുകൾ ഒട്ടക കേസിലാണ് വരുന്നതെന്ന കാര്യം ശ്രദ്ധിക്കുക, അതേസമയം ഡോക്യുമെന്റേഷനിൽ ഈ ഫീൽഡുകൾ അണ്ടർ_സ്കോറിൽ അവതരിപ്പിച്ചിരിക്കുന്നു. 
• ഇത് എല്ലായിടത്തും ഇതുപോലെയായിരിക്കും, അതിനാൽ നിങ്ങൾക്ക് ഡോക്യുമെന്റേഷനിൽ നിന്ന് ഒരു ഫീൽഡ് എടുക്കാനും പകർത്താനും കഴിയില്ല.

ഉപയോഗപ്രദം:

• പ്രോജക്റ്റ് ബ്രാഞ്ചിൽ നിങ്ങൾക്ക് ഈ കോഡ് കണ്ടെത്താം

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

ഒരു ബ്രൗസറിൽ ടിങ്കോഫ് ഇൻവെസ്റ്റ് എപിഐയിൽ നിന്ന് ഡാറ്റ വരയ്ക്കുന്നു

ഞാൻ next.js ഉം socket.io ഉം എടുത്തു. ഇതൊരു ശക്തമായ ശുപാർശയല്ല, നിങ്ങളുടെ വിവേചനാധികാരത്തിൽ തിരഞ്ഞെടുക്കുക. 

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

ഞങ്ങൾ ഉടൻ തന്നെ അടുത്ത+സോക്കറ്റ്+ഇൻവെസ്‌റ്റാപി എന്ന ഫ്രണ്ട്‌ഷിപ്പ് സ്റ്റെപ്പിലേക്ക് പോകുകയും എല്ലാ വിശദാംശങ്ങൾക്കും ഈ ഘട്ടത്തിലെ  ഉപയോഗപ്രദമായ വിഭാഗം കാണുക . ഞാൻ വിശദാംശങ്ങൾ വിവരിക്കും: 

• nodejs (സെർവർ) ഭാഗത്ത്, ഒരു pages/api/investapi.js ഫയൽ ഉണ്ട്. ഇവിടെയാണ് ഞങ്ങൾ socket.io സെർവർ സൃഷ്‌ടിക്കുകയും ഇൻവെസ്‌റ്റാപിയിലേക്ക് ബന്ധിപ്പിക്കുകയും ചെയ്യുന്നത്.
• ബ്രൗസർ (ക്ലയന്റ്) ഭാഗത്ത്, ഞങ്ങൾ ഒരു സോക്കറ്റ് വഴി സെർവറിലേക്ക് കണക്റ്റുചെയ്‌ത് ബ്രോക്കറിൽ നിന്ന് അക്കൗണ്ട് ഡാറ്റ അഭ്യർത്ഥിക്കുന്നു. 
• സെർവറിലെ ബ്രോക്കറിൽ നിന്ന് ഞങ്ങൾക്ക് ഡാറ്റ ലഭിക്കും, തുടർന്ന് അത് ക്ലയന്റിലേക്ക് അയയ്ക്കുക. അവ ക്ലയന്റിൽ ലഭിക്കുമ്പോൾ, അവ ബ്രൗസറിൽ പ്രദർശിപ്പിക്കും. 

ഫലം:  ബ്രൗസർ കൺസോളിൽ നമുക്ക് അക്കൗണ്ടുകളെക്കുറിച്ചുള്ള വിവരങ്ങൾ കാണാൻ കഴിയും. അതായത്, അവസാന ഘട്ടത്തിൽ, സെർവർ കൺസോളിൽ (nodejs) അക്കൗണ്ടുകളെക്കുറിച്ചുള്ള വിവരങ്ങൾ ഞങ്ങൾ കണ്ടു, നിലവിലെ ഘട്ടത്തിൽ, ഞങ്ങൾ ഈ വിവരങ്ങൾ ക്ലയന്റിലേക്ക് (ബ്രൗസർ) കൈമാറി.

ഇപ്പോൾ നമുക്ക് ബ്രൗസറിൽ നിന്ന് ഒരു അക്കൗണ്ട് തിരഞ്ഞെടുക്കാൻ കഴിയും, കൂടാതെ ടോക്കൺ ഇല്ലെങ്കിൽ, കൺസോളിലേക്ക് ഒരു പിശക് അയയ്ക്കും. ജോലി ലളിതമാണ്, പുതിയതൊന്നുമില്ല, അതിനാൽ ഞാൻ കമ്മിറ്റുകളുടെ ലിങ്കുകൾ മാത്രം നൽകുന്നു

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

ഉപയോഗപ്രദം:

• അടുത്ത സുഹൃത്തുക്കളെ എങ്ങനെ ഉണ്ടാക്കാം, സോക്കറ്റ് ഇവിടെ വിശദമായി വിവരിക്കുന്നു . 
• ഫ്രണ്ട്ഷിപ്പ് കോഡ് അടുത്ത+സോക്കറ്റ്+ഇൻവെസ്റ്റാപ്പി:

https://github.com/pskucherov/tcsstat/commit/a443a4ac1bb4f0aa898f638128755fe7391ee381 മുകളിൽ പറഞ്ഞ കാര്യങ്ങൾ ആർക്കൊക്കെ ബുദ്ധിമുട്ടാണ്, അപ്പോൾ ഞങ്ങൾ ഈ ഘട്ടത്തിൽ തുടരുകയും കോഡ് കൈകാര്യം ചെയ്യുകയും ചെയ്യുന്നു. നിങ്ങൾക്ക് ചോദ്യങ്ങളുണ്ടെങ്കിൽ – ചോദിക്കുക. https://github.com/pskucherov/tcsstat/tree/step2 https://github.com/pskucherov/tcsstat/compare/step1…step2

ബ്രോക്കറേജ് റിപ്പോർട്ടുകളും ഇടപാടുകളും സ്വീകരിക്കുന്നു

ബ്രോക്കറേജ് റിപ്പോർട്ടുകളും ഇടപാടുകളും സ്വീകരിക്കുന്നതിന് മൂന്ന് രീതികളുണ്ട്

1. GetBrokerReport
2. ഗെറ്റ് ഡിവിഡന്റ്സ് ഫോറിൻ ഇഷ്യൂവർ
3. GetOperationsByCursor

തുടക്കം മുതൽ അറിയേണ്ടത് പ്രധാനമാണ്: 

• ബ്രോക്കറേജ് റിപ്പോർട്ട് T-3 മോഡിൽ ജനറേറ്റ് ചെയ്യുന്നു, അതായത്. ട്രേഡുകൾ അവയുടെ യഥാർത്ഥ നിർവ്വഹണത്തിന് ശേഷം അവിടെ പ്രദർശിപ്പിക്കും. 
• ഇതനുസരിച്ച് കഴിഞ്ഞ രണ്ട് ദിവസമായി ഈ റിപ്പോർട്ട് ആവശ്യപ്പെട്ടാൽ മൂന്ന് ദിവസത്തിനകം തയ്യാറാകും. 
• അവസാന ദിവസങ്ങളിൽ ഇടപാടുകൾ നടത്തുന്നതിന്, പ്രവർത്തനങ്ങൾ സ്വീകരിക്കുന്നതിനുള്ള രീതി ഞങ്ങൾ ഉപയോഗിക്കുന്നു, എന്നാൽ ബ്രോക്കറേജ് റിപ്പോർട്ടിന്റെ രൂപീകരണത്തിന് ശേഷം അവരുടെ ഐഡിയും ഉള്ളടക്കവും മാറിയേക്കാമെന്ന് ഓർക്കുക.

GetBrokerReport

ഒരു ബ്രോക്കറേജ് റിപ്പോർട്ട് ലഭിക്കാൻ, നിങ്ങൾ അക്കൗണ്ട് ഐഡി, റിപ്പോർട്ടിന്റെ ആരംഭ തീയതി, അവസാന തീയതി എന്നിവ എടുക്കേണ്ടതുണ്ട്, എന്നാൽ 31 ദിവസത്തിൽ കൂടരുത്. ഞങ്ങൾ ജനറേറ്റ് _broker_report_request എന്നതിൽ API-ലേക്ക് ഒരു റിപ്പോർട്ട് സൃഷ്ടിക്കാൻ ഒരു അഭ്യർത്ഥന അയയ്ക്കുന്നു , പ്രതികരണമായി ഒരു ടാസ്‌ക് ഐഡി നേടുക. അതിനുശേഷം, ഈ ടാസ്‌ക് ഐഡി ഉപയോഗിച്ച്, get _broker_report_response-ൽ നിന്ന് ഞങ്ങൾക്ക് ഡാറ്റ ലഭിക്കും. [സ്‌പോയിലർ തലക്കെട്ട്=”അതിനാൽ ഡോക്യുമെന്റേഷൻ പറയുന്നു, വാസ്തവത്തിൽ സൂക്ഷ്മതകളുണ്ട്. നിങ്ങളുടെ കൈകൾ ശ്രദ്ധിക്കുക:”]

• ഈ തീയതികളിൽ നിങ്ങൾ ടാസ്‌ക് ഐഡി എന്നെന്നേക്കുമായി സംരക്ഷിക്കേണ്ടതുണ്ട്. 
• നിങ്ങൾക്ക് അത് നഷ്‌ടപ്പെടുകയാണെങ്കിൽ, അഭ്യർത്ഥിച്ച തീയതികളിൽ റിപ്പോർട്ട് ആദ്യം ജനറേഷൻ അഭ്യർത്ഥനയ്ക്ക് മറുപടിയായി വരും, 
• പിന്നെ അതൊന്നും വരില്ല.

[/സ്പോയിലർ] നമുക്ക് കോഡ് എഴുതാൻ തുടങ്ങാം

നിലവിലെ തീയതിയിൽ നിന്നുള്ള കുറയ്ക്കൽ കണക്കിലെടുത്ത് തീയതി നേടുന്നതിനുള്ള രീതി

const getDateSubDay = (subDay = 5, start = true) => {     const date = new Date();     date.setUTCDate(date.getUTCDate() – subDay);       എങ്കിൽ (ആരംഭിക്കുക) {         date.setUTCHours(0, 0, 0, 0);     } വേറെ {         date.setUTCHours(23, 59, 59, 999);     }       മടങ്ങുന്ന തീയതി; };

റിപ്പോർട്ട് ജനറേഷൻ അഭ്യർത്ഥന 

const BrokerReport = കാത്തിരിക്കുക (sdk.operations.getBrokerReport)({         generateBrokerReportRequest: {             accountId,             from,             to,         }, });

ഫലമായി:

• കമാൻഡിന്റെ ആദ്യ നിർവ്വഹണത്തിന്റെ ഫലമായി, നമുക്ക് taskId ലഭിക്കും. 
• ബ്രോക്കറുടെ ഭാഗത്ത് റിപ്പോർട്ട് സൃഷ്ടിക്കാൻ തുടങ്ങുന്നു. ഇത് തയ്യാറാകുമ്പോൾ അജ്ഞാതമാണ്, റിപ്പോർട്ടിനായി ഞങ്ങൾ കാത്തിരിക്കുകയും ഇടയ്ക്കിടെ ടാസ്ക് ഐഡി വലിക്കുകയും ചെയ്യുന്നു.
• എന്തുകൊണ്ട്? കാരണം റിപ്പോർട്ട് തയ്യാറായില്ലെങ്കിൽ, അത് ഒരു പിശക് എറിയുന്നു. ബ്രോക്കറുടെ ഭാഗത്ത് റിപ്പോർട്ട് തയ്യാറായില്ലെങ്കിൽ, ഇത് നിങ്ങളുടെ കോഡിലെ ഒരു പിശകാണ്. ദയവായി പ്രോസസ്സ് ചെയ്യുക: 30058|INVALID_ARGUMENT|പണി ഇതുവരെ പൂർത്തിയായിട്ടില്ല, ദയവായി പിന്നീട് വീണ്ടും ശ്രമിക്കുക

ഒരു റിപ്പോർട്ട് കാത്തിരിക്കുന്നതിനും സ്വീകരിക്കുന്നതിനുമുള്ള കോഡ് ഇതുപോലെ കാണപ്പെടുന്നു.

കോൺസ്റ്റ് ടൈമർ = അസിൻക് സമയം => {     പുതിയ വാഗ്ദാനം തിരികെ നൽകുക (പരിഹരിക്കുക => setTimeout (പരിഹരിക്കുക, സമയം)); }   const getBrokerResponseByTaskId = async (taskId, പേജ് = 0) => {     ശ്രമിക്കുക {         റിട്ടേൺ വെയിറ്റ് (sdk.operations.getBrokerReport)({             getBrokerReportRequest: {                 taskId,                 page,             },         });     } പിടിക്കുക (ഇ) {         console.log(‘കാത്തിരിക്കുക’, ഇ);         ടൈമർ കാത്തിരിക്കുക (10000);         തിരികെ വരാൻ കാത്തിരിക്കുന്നു getBrokerResponseByTaskId(taskId, page);     } };

അപ്പോൾ അതേ മാജിക് സംഭവിക്കുന്നു. ഞങ്ങൾ സ്‌ക്രിപ്റ്റ് നിർത്തി, വീണ്ടും ആരംഭിക്കുക, ഞങ്ങൾക്ക് ടാസ്ക് ഐഡി ഇല്ല. ടാസ്‌ക് ഐഡി അഭ്യർത്ഥനയ്‌ക്കൊപ്പം ഞങ്ങൾ കോഡ് എക്‌സിക്യൂട്ട് ചെയ്യുന്നു, പക്ഷേ ഞങ്ങൾക്ക് ഇനി ടാസ്‌ക് ഐഡി ലഭിക്കില്ല, പക്ഷേ ഉടൻ തന്നെ റിപ്പോർട്ട് ലഭിക്കും. ജാലവിദ്യ! പിന്നെ എപ്പോഴും ഇങ്ങനെ ആയിരുന്നെങ്കിൽ എല്ലാം ശരിയാകും. എന്നാൽ ഒരു മാസത്തിനുള്ളിൽ ഒരു ഡാറ്റയും ഉണ്ടാകില്ല. ഉപയോഗപ്രദം :

• ഒരു ബിറ്റ് സിദ്ധാന്തം ഇവിടെയും ഇവിടെയും വിവരിച്ചിരിക്കുന്നു .
• കോഡ് ഒരുമിച്ച് ചേർത്താൽ, ഡ്രാഫ്റ്റ് ഇതുപോലെ കാണപ്പെടും.

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

• ആരെങ്കിലും ഇത് കണ്ടാൽ, പ്രശ്നത്തിലേക്ക് സ്വാഗതം . അവർ ഈ മാജിക് നന്നാക്കിയ ശേഷം, അതിന്റെ ശക്തി നഷ്ടപ്പെടുകയും എങ്ങനെയെങ്കിലും വ്യത്യസ്തമായിരിക്കും. എന്നാൽ നിലവിലെ നിമിഷത്തിൽ (03/21/2023) അത് അതുപോലെ പ്രവർത്തിക്കുന്നു.

ഗെറ്റ് ഡിവിഡന്റ്സ് ഫോറിൻ ഇഷ്യൂവർ

ഈ രീതി മുമ്പത്തേതിന് സമാനമാണെന്നും നിങ്ങൾക്ക് പ്രവർത്തനങ്ങളുടെ പേര് മാത്രം മാറ്റുന്ന ഒരൊറ്റ രീതി ഉപയോഗിക്കാമെന്നും ആരെങ്കിലും ചിന്തിച്ചേക്കാം. പക്ഷേ അവർ ഊഹിച്ചില്ല!  അവിടെയുള്ള പേരിടൽ രീതികളിലും തിരികെ നൽകിയ വിവരങ്ങളിലും വളരെ വ്യത്യസ്തമാണ്. പേജുകളുടെ എണ്ണം 0-ൽ നിന്ന് ആരംഭിക്കുന്നു, തുടർന്ന് 1-ൽ നിന്ന്. ഇതിലെല്ലാം ആശയക്കുഴപ്പത്തിലാകാതിരിക്കാൻ, രണ്ട് വ്യത്യസ്ത രീതികൾ എഴുതുന്നത് എളുപ്പമാണ്. ഏത് വിചിത്രമാണ്, കാരണം ജോലിയുടെ യുക്തി ഒന്നുതന്നെയാണ്. ഒരു രീതി ഉണ്ടാക്കാൻ ശ്രമിച്ചപ്പോൾ ഞാൻ വളരെ നേരം തുപ്പി, കോഡ് കുറവായിരുന്നു. ഇവിടെ ഉദാഹരണങ്ങളൊന്നും ഉണ്ടാകില്ല.

GetOperationsByCursor

മൂന്നിൽ എനിക്കേറ്റവും ഇഷ്ടം. ഏറ്റവും കൃത്യമല്ലെങ്കിലും, ഏറ്റവും പര്യാപ്തമാണ്. ഒരു അക്കൗണ്ട് സൃഷ്ടിക്കുന്നതിന്റെ തുടക്കം മുതൽ സാധ്യമായ പരമാവധി തീയതി വരെ ഞങ്ങൾ ഒരു അഭ്യർത്ഥന നടത്തുന്നു (ഒരു അക്കൗണ്ട് അല്ലെങ്കിൽ നിലവിലുള്ളത് അടയ്ക്കുന്നത്). ഞങ്ങൾക്ക് ഉത്തരം ലഭിക്കും, കഴ്‌സർ എടുത്ത് ഡാറ്റ ഉള്ളിടത്തോളം വീണ്ടും അഭ്യർത്ഥിക്കുക.  മുകളിലുള്ള ഉദാഹരണങ്ങളേക്കാൾ കോഡ് കൂടുതൽ സംക്ഷിപ്തമാണ്.

കോൺസ്റ്റ് ടൈമർ = അസിൻക് സമയം => {     പുതിയ വാഗ്ദാനം തിരികെ നൽകുക (പരിഹരിക്കുക => setTimeout (പരിഹരിക്കുക, സമയം)); }   const getOperationsByCursor = async (sdk, accountId, from, to, cursor = ”) => {     try {         const reqData = {             accountId,             from,             to,             limit: 1000,             state: sdk.OperationState.OPERATION_STATE_EXECUTED:             false, withoutCommission             വ്യാപാരമില്ലാതെ: തെറ്റ്,             രാത്രികളില്ലാതെ: തെറ്റ്,             കഴ്‌സർ,         };           റിട്ടേൺ കാത്തിരിക്കുന്നു sdk.operations.getOperationsByCursor(reqData);     } പിടിക്കുക (ഇ) {         വെയ്റ്റ് ടൈമർ(60000);         റിട്ടേൺ കാത്തിരിക്കുന്നു getOperationsByCursor(sdk, accountId, from, to, cursor = ”);     } };

പ്രവർത്തിപ്പിക്കാനുള്ള ഡ്രാഫ്റ്റ് ഇവിടെയുണ്ട്: https://github.com/pskucherov/tcsstat/tree/step3.3 https://github.com/pskucherov/tcsstat/compare/step3.3 സ്വീകരിക്കുന്ന പ്രവർത്തനങ്ങൾ ഇതിലേക്ക് ചേർക്കാൻ ഞങ്ങൾ തയ്യാറാണ് ഞങ്ങളുടെ അപേക്ഷ. ശരിയായി ചെയ്തുവെങ്കിൽ, അക്കൗണ്ടിന്റെ മുഴുവൻ നിലനിൽപ്പിനുമുള്ള ബ്രോക്കറേജ് റിപ്പോർട്ടുകൾ നിങ്ങൾക്ക് ലഭിക്കേണ്ടതുണ്ട്. നഷ്‌ടമായ ഡാറ്റയ്‌ക്കായി, അതേ ടി-3-കൾ, പ്രവർത്തനങ്ങളിൽ നിന്ന് റീലോഡ് ചെയ്യുക. എന്നാൽ ഇത് ഒരു പ്രത്യേക ലേഖനമായി വേർതിരിക്കാം. നിങ്ങൾ അഭിമുഖീകരിക്കുന്ന പ്രധാന സൂക്ഷ്മതകളിൽ പശ പ്രവർത്തനങ്ങളും ഒരു ബ്രോക്കറേജ് റിപ്പോർട്ടും ആണ്.

•  ഇന്ന് നിങ്ങൾക്ക് ഒരു ബ്രോക്കറേജ് റിപ്പോർട്ടും ആവശ്യമായ തീയതികൾക്കുള്ള ഇടപാടുകളും ലഭിച്ചിട്ടുണ്ടെങ്കിൽ, അതെല്ലാം ഡാറ്റാബേസിൽ ഇടുക, പിന്നെ പ്രശ്നങ്ങളൊന്നുമില്ല. 
• റിപ്പോർട്ടിൽ നിന്നും പ്രവർത്തനങ്ങളിൽ നിന്നും ഡാറ്റയുടെ അടുത്ത ഭാഗം നിങ്ങൾക്ക് ലഭിക്കുകയും അവ നിലവിലുള്ള ഡാറ്റാബേസുമായി സമന്വയിപ്പിക്കാൻ തീരുമാനിക്കുകയും ചെയ്യുമ്പോൾ നിങ്ങൾക്ക് നാളെ പ്രശ്‌നങ്ങളുണ്ടാകും. 
• പൊരുത്തമില്ലാത്തതിനെക്കുറിച്ചോ പ്രോസസ്സിംഗിന് ശേഷം ഐഡി മാറ്റുന്നതിനെക്കുറിച്ചോ ധാരാളം സൂക്ഷ്മതകൾ
• അപ്പോൾ OTC മാർക്കറ്റിന്, ഐഡികൾ ഒട്ടും പൊരുത്തപ്പെടുന്നില്ല.
•  എപിഐയുടെ പ്രത്യേകതകൾ കാരണം വീണ്ടും പൊരുത്തപ്പെടാത്ത ഉപകരണങ്ങളുടെ സമന്വയത്തിന്റെ സൂക്ഷ്മതകളും. എന്നാൽ അത് മറ്റൊരു കഥയാണ്.

പ്രവർത്തനങ്ങളെക്കുറിച്ചുള്ള വിവരങ്ങൾ ലഭിക്കുന്നത് ഞങ്ങളുടെ ആപ്ലിക്കേഷനിലേക്ക് ചേർക്കാം. ഡാറ്റ എവിടെ പ്രോസസ്സ് ചെയ്യുകയും സംഭരിക്കുകയും ചെയ്യും എന്നതാണ് പ്രധാന ചോദ്യം.

•  നിങ്ങൾ ഇത് സ്വയം ചെയ്യുകയാണെങ്കിൽ, വ്യത്യസ്ത ഉപകരണങ്ങളിൽ നിന്ന് ഒരേ ഡാറ്റ നിങ്ങൾ ഉപയോഗിക്കും. അപ്പോൾ നിങ്ങൾ സെർവറിൽ ഡാറ്റ പ്രോസസ്സ് ചെയ്യുകയും സംഭരിക്കുകയും വേണം.
• വ്യത്യസ്ത ഉപയോക്താക്കൾ ഉപയോഗിക്കുന്ന ധാരാളം ഡാറ്റ നിങ്ങളുടെ പക്കലുണ്ടെങ്കിൽ, എന്താണ് കൂടുതൽ പ്രധാനമെന്ന് നിങ്ങൾ തീരുമാനിക്കേണ്ടതുണ്ട്: ഉപയോക്താക്കളുടെ വേഗത അല്ലെങ്കിൽ നിങ്ങളുടെ ഭാഗത്ത് ഇരുമ്പ് സംരക്ഷിക്കുക. അനന്തമായ ഹാർഡ്‌വെയറുകൾ താങ്ങാൻ കഴിയുന്നയാൾ തന്റെ സെർവറിലെ എല്ലാം കണക്കാക്കുകയും ഉപയോക്താക്കൾക്ക് അത് അതിവേഗത്തിലാക്കുകയും ചെയ്യുന്നു, ഫോണുകളിൽ വളരെ പ്രധാനപ്പെട്ട ബാറ്ററിയും ട്രാഫിക്കും പോലുള്ള ഉപയോക്തൃ ഉറവിടങ്ങൾ ലാഭിക്കുന്നു.

അതാകട്ടെ, ബ്രൗസറിൽ എണ്ണുന്നത് തത്വത്തിൽ ഏറ്റവും ഒപ്റ്റിമൽ പരിഹാരമല്ല. അതിനാൽ, ചെലവേറിയതല്ലാത്തത്, ഞങ്ങളുടെ സെർവറിൽ ഞങ്ങൾ പരിഗണിക്കുന്നു. ബാക്കിയുള്ളവ ഞങ്ങൾ ഉപഭോക്താവിന് വിടുന്നു. സെർവറിലെ കമ്മീഷൻ എടുക്കാനും കണക്കാക്കാനും ഞാൻ ശരിക്കും ആഗ്രഹിക്കുന്നു. എന്നാൽ ഇവിടെ “ഇന്ററാക്റ്റിവിറ്റി” എന്ന് വിളിക്കപ്പെടുന്ന സൂക്ഷ്മത വരുന്നു. നിങ്ങൾക്ക് ആയിരക്കണക്കിന് ഓപ്പറേഷനുകൾ ഉണ്ടെന്നും അവ ലഭിക്കാൻ അഞ്ച് മിനിറ്റ് എടുക്കുമെന്നും പറയാം. ഈ സമയത്ത് ഉപയോക്താവിന് എന്തായിരിക്കും? സ്പിന്നർ? പുരോഗതി? എത്രത്തോളം അപ്‌ലോഡ് ചെയ്‌തു എന്നതിനെ കുറിച്ചുള്ള വിവരങ്ങൾ? പ്രക്രിയയിലുള്ള ഉപയോക്താവിന് ഇതിനകം എന്തെങ്കിലും കാണാൻ കഴിയുമ്പോൾ “സജീവ കാത്തിരിപ്പ്” ഉപയോഗിക്കുന്നത് അനുയോജ്യമാണ്. ഫലം ഇതാ :

• പേജ് ലോഡ് ചെയ്യുന്നു
• എല്ലാ ഇൻവോയ്‌സുകളും അഭ്യർത്ഥിക്കുന്നു
• അതിനുശേഷം, എക്സിക്യൂട്ട് ചെയ്ത ഇടപാടുകൾക്കുള്ള കമ്മീഷനുകളുള്ള എല്ലാ ഇടപാടുകളും എല്ലാ അക്കൗണ്ടുകൾക്കും അഭ്യർത്ഥിക്കുന്നു. ഡാറ്റ ലഭിക്കുമ്പോൾ, അത് ബ്രൗസറിൽ റെൻഡർ ചെയ്യപ്പെടും.

ഓരോ തവണയും ഇവന്റുകളിലെ ഡാറ്റ ഫിൽട്ടർ ചെയ്യാതിരിക്കാൻ, ഓരോ അക്കൗണ്ടിനും ഞങ്ങൾ ഞങ്ങളുടെ സ്വന്തം ഇവന്റ് വലിക്കുന്നു. ഇതുപോലെ:

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

സമാരംഭിക്കാനുള്ള ഡ്രാഫ്റ്റ് ഇവിടെയുണ്ട്: https://github.com/pskucherov/tcsstat/tree/step3 https://github.com/pskucherov/tcsstat/compare/step2…step3 നീങ്ങുന്നു. നിങ്ങൾ ഈ വരി വായിച്ചതിൽ വളരെ സന്തോഷം! 

താൽപ്പര്യമുള്ള വിവരങ്ങളുടെ കണക്കുകൂട്ടലും ഔട്ട്പുട്ടും

ആർക്കൊക്കെ എന്ത് വിവരങ്ങൾ വേണം എന്നതിനെ ആശ്രയിച്ചിരിക്കുന്നു. അതിനാൽ, നിങ്ങൾ അഭിമുഖീകരിക്കുന്ന പ്രധാന സൂക്ഷ്മതകൾ ഞാൻ ഉടൻ നിങ്ങളോട് പറയുന്നു.

വിലയുമായി പ്രവർത്തിക്കുന്നു 

പണമിടപാടുകൾ മുഴുവൻ സംഖ്യകൾ ഉപയോഗിച്ച് മാത്രമേ നടത്താവൂ എന്ന് ഫിനാൻസിൽ ജോലി ചെയ്യുന്ന എല്ലാവർക്കും അറിയാം. ദശാംശ പോയിന്റിന് ശേഷമുള്ള മൂല്യങ്ങളുടെ കൃത്യതയില്ലായ്മയും ധാരാളം പ്രവർത്തനങ്ങളുള്ള ക്യുമുലേറ്റീവ് പിശകും കാരണം. അതുകൊണ്ടാണ് എല്ലാ വിലകളും ഇനിപ്പറയുന്ന MoneyValue ഫോർമാറ്റിൽ അവതരിപ്പിച്ചിരിക്കുന്നത്

ഞങ്ങൾ അവ പ്രത്യേകം പ്രോസസ്സ് ചെയ്യുന്നു, തുടർന്ന് വില മൂല്യത്തിലേക്ക് കൊണ്ടുവരിക:

quotation.units + quotation.nano / 1e9

ഫ്യൂച്ചർ കരാറുകളുടെ വില

ഫ്യൂച്ചറുകളുടെ വില പോയിന്റുകളിൽ അവതരിപ്പിച്ചിരിക്കുന്നു, നിങ്ങൾക്ക് ഒരു കറൻസി ഭാവി ഉള്ളപ്പോൾ, നിങ്ങൾ നിരക്ക് അറിയേണ്ടതുണ്ട്. തീർച്ചയായും പോയിന്റുകളിലെ വിലയും വിലയുടെ ഘട്ടവും. ഇടപാടുകളിൽ നിന്നുള്ള ലാഭം നിങ്ങൾ കണക്കാക്കുമ്പോൾ, ഇത് ഷൂട്ട് ചെയ്യാൻ കഴിയും, കാരണം. വിലയെ അളവ് കൊണ്ട് ഗുണിച്ച് നിങ്ങൾ മൊത്തം തുക കണക്കാക്കുകയാണെങ്കിൽ. ഇവിടെ നിങ്ങൾ ശ്രദ്ധിക്കേണ്ടതുണ്ട്. തൽക്കാലം, അത് എങ്ങനെ പോകുന്നുവെന്ന് നമുക്ക് നോക്കാം. ഇത് കറൻസി ഫ്യൂച്ചറുകൾക്ക് ബാധകമാണ്, മറ്റ് സ്ഥലങ്ങളിൽ എല്ലാം ശരിയാണ്.

OTC മാർക്കറ്റ്

ഈ മാർക്കറ്റിന് ധാരാളം പ്രത്യേകതകൾ ഉണ്ട്, അതിനാൽ നമുക്ക് ഇതിലെ പ്രവർത്തനങ്ങൾ പ്രത്യേകം പഠിക്കാം. നിങ്ങൾ പ്രവർത്തനങ്ങൾ സമന്വയിപ്പിക്കാൻ തുടങ്ങുമ്പോൾ, ഉപകരണവുമായി ശരിയായി പൊരുത്തപ്പെടുന്നതിന് നിങ്ങൾ ഫിജി / ടിക്കർ അതേ രൂപത്തിലേക്ക് കൊണ്ടുവരേണ്ടതുണ്ടെന്ന് ഇത് മാറും. നിങ്ങൾ ഇത് ബ്രോക്കറേജ് റിപ്പോർട്ടുമായി സമന്വയിപ്പിക്കാൻ തുടങ്ങുമ്പോൾ, അതേ ഇടപാടിന്റെ ട്രേഡ് ഐഡിക്ക് ഇടപാടുകളിൽ തുടക്കത്തിൽ അക്ഷരങ്ങളുണ്ടെന്നും അവ ബ്രോക്കറേജ് റിപ്പോർട്ടിലില്ലെന്നും ഇത് മാറും. അതിനാൽ, താരതമ്യത്തിലൂടെ അവയെ … അഹേം-അഹേം … താരതമ്യം ചെയ്യാൻ കഴിയില്ല! ഒരു ട്രേഡ് ഐഡി മറ്റൊന്നിൽ അടങ്ങിയിരിക്കുന്ന വ്യാപാര സമയം, ടിക്കർ, പൊരുത്തപ്പെടുത്തൽ എന്നിവയുമായി ഞാൻ പൊരുത്തപ്പെട്ടു. ശരി, എനിക്കറിയില്ല. ഇത് കണ്ടുമുട്ടുന്നവരും അതിനെക്കുറിച്ച് ശ്രദ്ധിക്കുന്നവരും പ്രശ്നത്തിലേക്ക് വരിക അല്ലെങ്കിൽ പുതിയത് ആരംഭിക്കുക.

ടൂളുകളിലെ ഗണിത പ്രവർത്തനങ്ങൾ

മുഴുവൻ ലിസ്റ്റും ഉപയോഗിച്ച് ഗണിത പ്രവർത്തനങ്ങൾ നടത്തുന്നത് നോക്കാതെ അസാധ്യമാണ്. ഊഷ്മളതയിലേക്ക് ഊഷ്മളത ചേർക്കാതിരിക്കാൻ, കറൻസി പൊരുത്തപ്പെടുന്നുവെന്നും പോയിന്റുകൾ ആവശ്യമുള്ള കറൻസിയിലേക്ക് പരിവർത്തനം ചെയ്യപ്പെടുന്നുവെന്നും ഞങ്ങൾക്ക് ഉറപ്പുണ്ടെങ്കിൽ മാത്രമേ ഞങ്ങൾ എല്ലായ്പ്പോഴും കറൻസി പരിശോധിച്ച് പ്രോസസ്സ് ചെയ്യുന്നു. ബാങ്ക് നമ്പറുകൾ ഉപയോഗിച്ച് പ്രവർത്തിക്കുന്നതിനെക്കുറിച്ചുള്ള അറിവ് ഉപയോഗിച്ച്, ഓരോ അക്കൗണ്ടിലും ചെലവഴിച്ച കമ്മീഷൻ ഞങ്ങൾ കണക്കാക്കും. ഇതുപോലെ: https://github.com/pskucherov/tcsstat/tree/step4 https://github.com/pskucherov/tcsstat/compare/step3…step4   

മൈക്രോ സർവീസ് തയ്യാറാണ്!

https://github.com/pskucherov/tcsstat ഒരു ഗൃഹപാഠം എന്ന നിലയിൽ, സേവനം മന്ദഗതിയിലുള്ള കണക്ഷനിൽ പ്രവർത്തിക്കുന്നുണ്ടോ, കണക്ഷനുകൾ തകരാറിലാകുമ്പോൾ, ഇന്റർനെറ്റ് വിച്ഛേദിക്കുമ്പോൾ, ബ്രോക്കറുടെ ഭാഗത്തുനിന്ന് പിശകുകളോ കാലഹരണപ്പെട്ട പരിധികളോ നിങ്ങൾക്ക് പരിശോധിക്കാം. 

ഭാവിയിലേക്കുള്ള നിഗമനങ്ങളും പദ്ധതികളും

• അടിസ്ഥാന പ്രവർത്തനങ്ങളെ കുറിച്ചും ഇൻവെസ്റ്റ് എപിഐയിൽ പ്രവർത്തിക്കുന്നതിനെക്കുറിച്ചും പഠിച്ചു
• ചെലവഴിച്ച സമയം ~ 10 മണിക്കൂർ
• ബുദ്ധിമുട്ട് നില ~ ജൂനിയർ+ / താഴ്ന്ന മധ്യഭാഗം 

നിങ്ങൾ മൈക്രോസർവീസ് പരിഷ്കരിക്കുന്നത് തുടരുകയാണെങ്കിൽ, നിങ്ങൾക്ക് ഇതുപോലൊന്ന് സംഭവിക്കാം

https://opexbot.info

  ഇത് എന്റെ വികസനമാണ്, മനസിലാക്കാനും ഓടാനും സ്വന്തമായി എണ്ണാനും മടിയുള്ളവർക്ക്. ഉപയോക്താക്കളുടെ അഭ്യർത്ഥന പ്രകാരം അവിടെ അനലിറ്റിക്സ് ചേർക്കാൻ ഞാൻ പദ്ധതിയിടുന്നു. നിങ്ങൾക്ക് ലേഖനം ഇഷ്ടപ്പെട്ടെങ്കിൽ, എന്റെ ടെലിഗ്രാം ചാനൽ സബ്സ്ക്രൈബ് ചെയ്യുക .