టింకాఫ్ ఇన్వెస్ట్‌మెంట్స్ కోసం స్టాటిస్టిక్స్ సర్వీస్ అభివృద్ధి వెనుక స్ఫూర్తిదాతలు :

• హబ్రేపై కథనం “టింకాఫ్ ఇన్వెస్ట్‌మెంట్స్ ఏమి చెప్పడం లేదు” 
• ప్లాట్‌ఫారమ్ వినియోగదారుల కోరికల విశ్లేషణ
• కమీషన్ల గణన గురించి ఒక కథనం . 

ఏమి చర్చించబడుతుంది?

• అభివృద్ధి గురించి అనువర్తిత భాగం మాత్రమే.
• నిజమైన జ్ఞానం మరియు అనుభవం, ఆర్థిక సాధనాలతో పని చేయడంలో చాలా ముఖ్యమైనవి.
• పని చేయవలసిన సమస్యల అవలోకనం

కాబట్టి, నేను వాణిజ్య గణాంకాలను లెక్కించాలనుకుంటున్నాను మరియు అనుకూలమైన మార్గంలో చేయాలనుకుంటున్నాను. 

దశలవారీగా గణాంకాల సేవను అభివృద్ధి చేయడం: 

1. Tinkoff ఇన్వెస్ట్ APIకి కనెక్షన్
2. బ్రౌజర్‌లో Tinkoff Invest API నుండి డేటాను గీయడం
3. బ్రోకరేజ్ నివేదికలు మరియు లావాదేవీలను స్వీకరించడం
4. ఆసక్తి ఉన్న సమాచారం యొక్క గణన మరియు అవుట్‌పుట్
5. భవిష్యత్తు కోసం తీర్మానాలు మరియు ప్రణాళికలు

Tinkoff ఇన్వెస్ట్ APIకి కనెక్షన్

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’);   // ఈ విధంగా పొందగలిగే టోకెన్   టోకెన్ = ‘యురాపి’;   // మీరు TCS లాగ్‌లలో కనుగొనగలిగే అప్లికేషన్ పేరు. const appName = ‘tcsstat’;   const sdk = createSdk(TOKEN, appName); (async () => {     console.log(వెయిట్ sdk.users.getAccounts()); })();

ఫలితం: మీ ఖాతాల జాబితా కన్సోల్‌లో ప్రదర్శించబడుతుంది. ఉదాహరణకు, సూక్ష్మ నైపుణ్యాలను విశ్లేషిద్దాం:

• ఖాతాల జాబితాలో “ఇన్వెస్ట్‌మెంట్ బ్యాంక్” ఉంది, దానితో మీరు APIని ఉపయోగించి పని చేయలేరు
• డాక్యుమెంటేషన్‌లో ఈ ఫీల్డ్‌లు under_స్కోర్‌లో ప్రదర్శించబడినప్పుడు  ఫీల్డ్‌లు కామెల్‌కేస్‌లో వస్తాయని దయచేసి గమనించండి .
• ఇది ప్రతిచోటా ఇలాగే ఉంటుంది, కాబట్టి మీరు డాక్యుమెంటేషన్ నుండి ఫీల్డ్‌ని తీసుకొని కాపీ చేయలేరు.

ఉపయోగకరమైన:

• మీరు ప్రాజెక్ట్ శాఖలో ఈ కోడ్‌ను కనుగొనవచ్చు

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

బ్రౌజర్‌లో Tinkoff Invest API నుండి డేటాను గీయడం

నేను 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 = కొత్త తేదీ();     date.setUTCDate(date.getUTCDate() – సబ్‌డే);       ఉంటే (ప్రారంభం) {         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|పని ఇంకా పూర్తి కాలేదు, దయచేసి తర్వాత మళ్లీ ప్రయత్నించండి

నివేదిక కోసం వేచి ఉండటానికి మరియు స్వీకరించడానికి కోడ్ ఇలా కనిపిస్తుంది.

కాన్స్ట్ టైమర్ = సమకాలీకరణ సమయం => {     కొత్త వాగ్దానాన్ని తిరిగి ఇవ్వండి (పరిష్కరించండి => సెట్ టైమ్ అవుట్ (పరిష్కరించండి, సమయం)); }   const getBrokerResponseByTaskId = async (taskId, page = 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

మూడింటిలో నాకు ఇష్టమైనది. చాలా ఖచ్చితమైనది కానప్పటికీ, చాలా సరిపోతుంది. మేము ఖాతాను సృష్టించడం ప్రారంభించినప్పటి నుండి గరిష్ట సాధ్యమయ్యే తేదీ వరకు అభ్యర్థన చేస్తాము (ఖాతా లేదా ప్రస్తుత ఖాతాని మూసివేయడం). మేము సమాధానం పొందుతాము, కర్సర్ తీసుకొని డేటా ఉన్నంత వరకు మళ్లీ అభ్యర్థించాము.  మరియు పైన ఉన్న ఉదాహరణలలో కంటే కోడ్ మరింత సంక్షిప్తంగా ఉంటుంది.

కాన్స్ట్ టైమర్ = సమకాలీకరణ సమయం => {     కొత్త వాగ్దానాన్ని తిరిగి ఇవ్వండి (పరిష్కరించండి => సెట్ టైమ్ అవుట్ (పరిష్కరించండి, సమయం)); }   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 ఇప్పుడు మేము స్వీకరించే కార్యకలాపాలను జోడించడానికి సిద్ధంగా ఉన్నాము మా అప్లికేషన్. సరిగ్గా చేస్తే, మీరు ఖాతా యొక్క మొత్తం ఉనికి కోసం బ్రోకరేజ్ నివేదికలను పొందాలి. మరియు తప్పిపోయిన డేటా కోసం, అదే T-3లు, కార్యకలాపాల నుండి రీలోడ్ చేయండి. కానీ దీనిని ప్రత్యేక వ్యాసంగా విభజించవచ్చు. మీరు ఎదుర్కొనే ప్రధాన సూక్ష్మ నైపుణ్యాలలో జిగురు కార్యకలాపాలు మరియు బ్రోకరేజ్ నివేదిక.

•  ఈ రోజు మీరు బ్రోకరేజ్ నివేదిక మరియు అవసరమైన తేదీల కోసం లావాదేవీలను స్వీకరించినట్లయితే, అన్నింటినీ డేటాబేస్లో ఉంచండి, అప్పుడు సమస్యలు లేవు. 
• మీరు నివేదిక మరియు కార్యకలాపాల నుండి డేటా యొక్క తదుపరి భాగాన్ని స్వీకరించినప్పుడు మరియు వాటిని ఇప్పటికే ఉన్న డేటాబేస్‌తో సమకాలీకరించాలని నిర్ణయించుకున్నప్పుడు మీకు రేపు సమస్యలు ఎదురవుతాయి. 
• ప్రాసెస్ చేసిన తర్వాత సరిపోలడం లేదా ఐడిని మార్చడం గురించి చాలా సూక్ష్మ నైపుణ్యాలు ఉన్నాయి
• అప్పుడు OTC మార్కెట్‌కి, idలు అస్సలు సరిపోలడం లేదు.
•  అలాగే సమకాలీకరించే సాధనాల యొక్క సూక్ష్మ నైపుణ్యాలు, API యొక్క ప్రత్యేకతల కారణంగా మళ్లీ ఏకీభవించవు. అయితే అది మరో కథ.

మా అప్లికేషన్‌కు కార్యకలాపాల గురించి సమాచారాన్ని పొందడం జోడిద్దాం. డేటా ఎక్కడ ప్రాసెస్ చేయబడుతుంది మరియు నిల్వ చేయబడుతుంది అనేది ప్రధాన ప్రశ్న.

•  మీరు మీ కోసం దీన్ని చేస్తే, మీరు వేర్వేరు పరికరాల నుండి ఒకే డేటాను వినియోగిస్తారు. అప్పుడు మీరు సర్వర్‌లో డేటాను ప్రాసెస్ చేసి నిల్వ చేయాలి.
• మీరు అనేక విభిన్న వినియోగదారులచే వినియోగించబడే విభిన్న డేటాను కలిగి ఉంటే, మీరు మరింత ముఖ్యమైనది ఏమిటో నిర్ణయించుకోవాలి: వినియోగదారుల వేగం లేదా మీ వైపు ఇనుమును ఆదా చేయడం. ఎవరైతే అనంతమైన హార్డ్‌వేర్‌ను కొనుగోలు చేయగలరో వారు తన సర్వర్‌లోని ప్రతిదానిని లెక్కించి, వినియోగదారులకు అత్యంత వేగంగా దాన్ని తయారు చేస్తారు, ఫోన్‌లలో చాలా ముఖ్యమైన బ్యాటరీ మరియు ట్రాఫిక్ వంటి వినియోగదారు వనరులను ఆదా చేస్తారు.

ప్రతిగా, బ్రౌజర్లో లెక్కించడం అనేది సూత్రప్రాయంగా అత్యంత సరైన పరిష్కారం కాదు. అందువల్ల, ఖరీదైనది కాదు, మేము దానిని మా సర్వర్‌లో పరిగణిస్తాము. మేము మిగిలిన వాటిని క్లయింట్‌కు వదిలివేస్తాము. నేను నిజంగా సర్వర్‌లో కమీషన్ తీసుకొని లెక్కించాలనుకుంటున్నాను. కానీ ఇక్కడ “ఇంటరాక్టివిటీ” అనే స్వల్పభేదాన్ని వస్తుంది. మీకు వేల సంఖ్యలో ఆపరేషన్లు ఉన్నాయి మరియు వాటిని స్వీకరించడానికి ఐదు నిమిషాల సమయం పడుతుందని అనుకుందాం. ఈ సమయంలో వినియోగదారుకు ఏమి ఉంటుంది? స్పిన్నర్? పురోగతి? ఇన్ఫా ఎంత అప్‌లోడ్ చేయబడింది? ప్రక్రియలో ఉన్న వినియోగదారు ఇప్పటికే ఏదైనా చూడగలిగినప్పుడు “యాక్టివ్ వెయిటింగ్”ని ఉపయోగించడం ఉత్తమం. ఇక్కడ ఫలితం ఉంది:

• పేజీ లోడ్ అవుతోంది
• అన్ని ఇన్‌వాయిస్‌లు అభ్యర్థించబడ్డాయి
• ఆ తర్వాత, అమలు చేయబడిన లావాదేవీల కోసం కమీషన్లతో అన్ని లావాదేవీలు అన్ని ఖాతాలకు అభ్యర్థించబడతాయి. డేటా అందుకున్నప్పుడు, అది బ్రౌజర్‌లో రెండర్ చేయబడుతుంది.

ఈవెంట్‌లలోని డేటాను ప్రతిసారీ ఫిల్టర్ చేయకుండా ఉండటానికి, మేము ప్రతి ఖాతా కోసం మా స్వంత ఈవెంట్‌ను లాగుతాము. ఇలా:

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 హోమ్‌వర్క్‌గా, సేవ నెమ్మదిగా కనెక్షన్‌తో పనిచేస్తుందో లేదో, కనెక్షన్‌లు విచ్ఛిన్నమైనప్పుడు, ఇంటర్నెట్ డిస్‌కనెక్ట్ అయినప్పుడు, బ్రోకర్‌లో లోపాలు లేదా గడువు ముగిసినప్పుడు మీరు తనిఖీ చేయవచ్చు. 

భవిష్యత్తు కోసం తీర్మానాలు మరియు ప్రణాళికలు

• ప్రాథమిక కార్యకలాపాల గురించి మరియు ఇన్వెస్ట్ APIతో పని చేయడం గురించి తెలుసుకున్నారు
• గడిపిన సమయం ~ 10 గంటలు
• క్లిష్టత స్థాయి ~ జూనియర్+ / తక్కువ మధ్య 

మీరు మైక్రోసర్వీస్‌ను మెరుగుపరచడం కొనసాగిస్తే, మీరు ఇలాంటిదే ముగించవచ్చు

https://opexbot.info

  ఇది నా అభివృద్ధి, అర్థం చేసుకోవడానికి, పరుగెత్తడానికి మరియు వారి స్వంతంగా లెక్కించడానికి చాలా సోమరితనం ఉన్నవారికి. వినియోగదారుల అభ్యర్థన మేరకు నేను అక్కడ విశ్లేషణలను జోడించాలని ప్లాన్ చేస్తున్నాను. మీకు కథనం నచ్చినట్లయితే, నా టెలిగ్రామ్ ఛానెల్‌కు సభ్యత్వాన్ని పొందండి .