ಟಿಂಕಾಫ್ ಹೂಡಿಕೆಗಾಗಿ ಅಂಕಿಅಂಶ ಸೇವೆಯ ಅಭಿವೃದ್ಧಿಯ ಹಿಂದಿನ ಪ್ರೇರಕರು :

• ಹಬ್ರೆ ಲೇಖನ “ಟಿಂಕಾಫ್ ಇನ್ವೆಸ್ಟ್ಮೆಂಟ್ಸ್ ಏನು ಹೇಳುತ್ತಿಲ್ಲ” 
• ಪ್ಲಾಟ್‌ಫಾರ್ಮ್ ಬಳಕೆದಾರರ ಆಶಯಗಳ ವಿಶ್ಲೇಷಣೆ
• ಆಯೋಗಗಳ ಲೆಕ್ಕಾಚಾರದ ಬಗ್ಗೆ ಒಂದು ಲೇಖನ . 

ಏನು ಚರ್ಚಿಸಲಾಗುವುದು?

• ಅಭಿವೃದ್ಧಿಯ ಬಗ್ಗೆ ಅನ್ವಯಿಕ ಭಾಗ ಮಾತ್ರ.
• ಹಣಕಾಸಿನ ಸಾಧನಗಳೊಂದಿಗೆ ಕೆಲಸ ಮಾಡುವಲ್ಲಿ ಬಹಳ ಮುಖ್ಯವಾದ ನೈಜ ಜ್ಞಾನ ಮತ್ತು ಅನುಭವ.
• ಕೆಲಸ ಮಾಡಬೇಕಾದ ಸಮಸ್ಯೆಗಳ ಅವಲೋಕನ

ಆದ್ದರಿಂದ, ನಾನು ವ್ಯಾಪಾರ ಅಂಕಿಅಂಶಗಳನ್ನು ಲೆಕ್ಕಾಚಾರ ಮಾಡಲು ಮತ್ತು ಅದನ್ನು ಅನುಕೂಲಕರ ರೀತಿಯಲ್ಲಿ ಮಾಡಲು ಬಯಸುತ್ತೇನೆ. 

ಹಂತ ಹಂತವಾಗಿ ಅಂಕಿಅಂಶ ಸೇವೆಯನ್ನು ಅಭಿವೃದ್ಧಿಪಡಿಸುವುದು: 

1. Tinkoff ಇನ್ವೆಸ್ಟ್ API ಗೆ ಸಂಪರ್ಕ
2. ಬ್ರೌಸರ್‌ನಲ್ಲಿ ಟಿಂಕಾಫ್ ಇನ್ವೆಸ್ಟ್ API ನಿಂದ ಡೇಟಾ ಡ್ರಾಯಿಂಗ್
3. ಬ್ರೋಕರೇಜ್ ವರದಿಗಳು ಮತ್ತು ವಹಿವಾಟುಗಳನ್ನು ಸ್ವೀಕರಿಸುವುದು
4. ಆಸಕ್ತಿಯ ಮಾಹಿತಿಯ ಲೆಕ್ಕಾಚಾರ ಮತ್ತು ಔಟ್ಪುಟ್
5. ಭವಿಷ್ಯಕ್ಕಾಗಿ ತೀರ್ಮಾನಗಳು ಮತ್ತು ಯೋಜನೆಗಳು

Tinkoff ಇನ್ವೆಸ್ಟ್ API ಗೆ ಸಂಪರ್ಕ

API ಗೆ ಸಂಪರ್ಕಿಸಲು, ನೀವು ಡಾಕ್ಯುಮೆಂಟೇಶನ್ https://github.com/Tinkoff/investAPI#sdk ನಿಂದ ಯಾವುದೇ sdk ತೆಗೆದುಕೊಳ್ಳಬಹುದು . ಅಥವಾ npm ಪ್ಯಾಕೇಜ್ ` tinkoff-sdk-grpc-js `. ಡೆವಲಪರ್‌ಗಳಿಂದ ಪ್ಯಾಕೇಜ್ ಅನ್ನು ಇತ್ತೀಚಿನ ಆವೃತ್ತಿಗೆ ನವೀಕರಿಸುವುದು ಮುಖ್ಯವಾಗಿದೆ. ಸ್ಥಾಪಿಸಿ

npm ಮತ್ತು tinkoff-sdk-grpc-js

ಪರಿಶೀಲಿಸಲಾಗುತ್ತಿದೆ

const { createSdk } = ಅಗತ್ಯವಿದೆ (‘tinkoff-sdk-grpc-js’);   // ಈ ರೀತಿ ಪಡೆಯಬಹುದಾದ ಟೋಕನ್   const TOKEN = ‘YOURAPI’;   // ನೀವು 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   

ಬ್ರೌಸರ್‌ನಲ್ಲಿ ಟಿಂಕಾಫ್ ಇನ್ವೆಸ್ಟ್ API ನಿಂದ ಡೇಟಾ ಡ್ರಾಯಿಂಗ್

ನಾನು next.js ಮತ್ತು socket.io ತೆಗೆದುಕೊಂಡೆ. ಇದು ಬಲವಾದ ಶಿಫಾರಸು ಅಲ್ಲ, ನಿಮ್ಮ ವಿವೇಚನೆಯಿಂದ ಆಯ್ಕೆಮಾಡಿ. 

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

ನಾವು ತಕ್ಷಣವೇ ಸ್ನೇಹದ ಹಂತಕ್ಕೆ ಮುಂದಿನ+ಸಾಕೆಟ್+ಇನ್ವೆಸ್ಟಾಪಿಗೆ ಮುಂದುವರಿಯುತ್ತೇವೆ ಮತ್ತು ಎಲ್ಲಾ ವಿವರಗಳಿಗಾಗಿ ಈ ಹಂತದ  ಉಪಯುಕ್ತ ವಿಭಾಗವನ್ನು ನೋಡಿ. ನಾನು ವಿವರಗಳನ್ನು ವಿವರಿಸುತ್ತೇನೆ: 

• nodejs (ಸರ್ವರ್) ಬದಿಯಲ್ಲಿ, pages/api/investapi.js ಫೈಲ್ ಇದೆ. ಇಲ್ಲಿ ನಾವು socket.io ಸರ್ವರ್ ಅನ್ನು ರಚಿಸುತ್ತೇವೆ ಮತ್ತು ಇನ್ವೆಸ್ಟಾಪಿಗೆ ಸಂಪರ್ಕಿಸುತ್ತೇವೆ.
• ಬ್ರೌಸರ್ (ಕ್ಲೈಂಟ್) ಬದಿಯಲ್ಲಿ, ನಾವು ಸಾಕೆಟ್ ಮೂಲಕ ಸರ್ವರ್‌ಗೆ ಸಂಪರ್ಕಿಸುತ್ತೇವೆ ಮತ್ತು ಬ್ರೋಕರ್‌ನಿಂದ ಖಾತೆ ಡೇಟಾವನ್ನು ವಿನಂತಿಸುತ್ತೇವೆ. 
• ನಾವು ಸರ್ವರ್‌ನಲ್ಲಿ ಬ್ರೋಕರ್‌ನಿಂದ ಡೇಟಾವನ್ನು ಸ್ವೀಕರಿಸುತ್ತೇವೆ, ನಂತರ ಅದನ್ನು ಕ್ಲೈಂಟ್‌ಗೆ ಕಳುಹಿಸುತ್ತೇವೆ. ಅವುಗಳನ್ನು ಕ್ಲೈಂಟ್‌ನಲ್ಲಿ ಸ್ವೀಕರಿಸಿದಾಗ, ಅವುಗಳನ್ನು ಬ್ರೌಸರ್‌ನಲ್ಲಿ ಪ್ರದರ್ಶಿಸಲಾಗುತ್ತದೆ. 

ಫಲಿತಾಂಶ:  ಬ್ರೌಸರ್ ಕನ್ಸೋಲ್‌ನಲ್ಲಿ ನಾವು ಖಾತೆಗಳ ಬಗ್ಗೆ ಮಾಹಿತಿಯನ್ನು ನೋಡಬಹುದು. ಅಂದರೆ, ಕೊನೆಯ ಹಂತದಲ್ಲಿ, ನಾವು ಸರ್ವರ್ ಕನ್ಸೋಲ್‌ನಲ್ಲಿ (ನೋಡೆಜ್‌ಗಳು) ಖಾತೆಗಳ ಬಗ್ಗೆ ಮಾಹಿತಿಯನ್ನು ನೋಡಿದ್ದೇವೆ, ಪ್ರಸ್ತುತ ಹಂತದಲ್ಲಿ, ನಾವು ಈ ಮಾಹಿತಿಯನ್ನು ಕ್ಲೈಂಟ್‌ಗೆ (ಬ್ರೌಸರ್) ವರ್ಗಾಯಿಸಿದ್ದೇವೆ.

ಈಗ ಅದನ್ನು ಮಾಡೋಣ ಆದ್ದರಿಂದ ನೀವು ಬ್ರೌಸರ್‌ನಿಂದ ಖಾತೆಯನ್ನು ಆಯ್ಕೆ ಮಾಡಬಹುದು ಮತ್ತು ಯಾವುದೇ ಟೋಕನ್ ಇಲ್ಲದಿದ್ದರೆ, ದೋಷವನ್ನು ಕನ್ಸೋಲ್‌ಗೆ ಕಳುಹಿಸಲಾಗುತ್ತದೆ. ಕೆಲಸವು ಸರಳವಾಗಿದೆ ಮತ್ತು ಹೊಸದೇನೂ ಇಲ್ಲ, ಆದ್ದರಿಂದ ನಾನು ಕಮಿಟ್‌ಗಳಿಗೆ ಲಿಂಕ್‌ಗಳನ್ನು ಮಾತ್ರ ನೀಡುತ್ತೇನೆ

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. ಗೆಟ್ ಆಪರೇಷನ್ಸ್ ಬೈಕರ್ಸರ್

ಮೊದಲಿನಿಂದಲೂ ತಿಳಿದುಕೊಳ್ಳುವುದು ಬಹಳ ಮುಖ್ಯ: 

• ಬ್ರೋಕರೇಜ್ ವರದಿಯನ್ನು T-3 ಮೋಡ್‌ನಲ್ಲಿ ರಚಿಸಲಾಗಿದೆ, ಅಂದರೆ. ವಹಿವಾಟುಗಳನ್ನು ಅವುಗಳ ನಿಜವಾದ ಮರಣದಂಡನೆಯ ನಂತರ ಅಲ್ಲಿ ಪ್ರದರ್ಶಿಸಲಾಗುತ್ತದೆ. 
• ಅದರಂತೆ ಕಳೆದ ಎರಡು ದಿನಗಳಿಂದ ಈ ವರದಿಯನ್ನು ಕೋರಿದರೆ ಮೂರು ದಿನದಲ್ಲಿ ಸಿದ್ಧವಾಗಲಿದೆ. 
• ಕೊನೆಯ ದಿನಗಳಲ್ಲಿ ಡೀಲ್‌ಗಳನ್ನು ಮಾಡಲು, ಕಾರ್ಯಾಚರಣೆಗಳನ್ನು ಸ್ವೀಕರಿಸಲು ನಾವು ವಿಧಾನವನ್ನು ಬಳಸುತ್ತೇವೆ, ಆದರೆ ಬ್ರೋಕರೇಜ್ ವರದಿಯ ರಚನೆಯ ನಂತರ ಅವರ ಐಡಿ ಮತ್ತು ವಿಷಯವು ಬದಲಾಗಬಹುದು ಎಂಬುದನ್ನು ನೆನಪಿಡಿ.

GetBrokerReport

ಬ್ರೋಕರೇಜ್ ವರದಿಯನ್ನು ಪಡೆಯಲು, ನೀವು ಖಾತೆಯ ಐಡಿ, ಪ್ರಾರಂಭ ದಿನಾಂಕ ಮತ್ತು ವರದಿಯ ಅಂತಿಮ ದಿನಾಂಕವನ್ನು ತೆಗೆದುಕೊಳ್ಳಬೇಕಾಗುತ್ತದೆ, ಆದರೆ 31 ದಿನಗಳಿಗಿಂತ ಹೆಚ್ಚಿಲ್ಲ. ನಾವು ಜನರೇಟ್ _broker_report_request ನಲ್ಲಿ API ಗೆ ವರದಿಯನ್ನು ರಚಿಸಲು ವಿನಂತಿಯನ್ನು ಕಳುಹಿಸುತ್ತೇವೆ , ಪ್ರತಿಕ್ರಿಯೆಯಾಗಿ taskId ಅನ್ನು ಪಡೆಯಿರಿ. ಅದರ ನಂತರ, ಈ taskId ಅನ್ನು ಬಳಸಿಕೊಂಡು, ನಾವು get _broker_report_response ನಿಂದ ಡೇಟಾವನ್ನು ಪಡೆಯುತ್ತೇವೆ. [ಸ್ಪಾಯ್ಲರ್ ಶೀರ್ಷಿಕೆ=”ಆದ್ದರಿಂದ ದಸ್ತಾವೇಜನ್ನು ಹೇಳುತ್ತದೆ, ವಾಸ್ತವದಲ್ಲಿ ಸೂಕ್ಷ್ಮ ವ್ಯತ್ಯಾಸಗಳಿವೆ. ನಿಮ್ಮ ಕೈಗಳನ್ನು ವೀಕ್ಷಿಸಿ:”]

• ಈ ದಿನಾಂಕಗಳಿಗಾಗಿ ನೀವು TaskID ಅನ್ನು ಶಾಶ್ವತವಾಗಿ ಉಳಿಸಬೇಕಾಗಿದೆ. 
• ನೀವು ಅದನ್ನು ಕಳೆದುಕೊಂಡರೆ, ವಿನಂತಿಸಿದ ದಿನಾಂಕಗಳಿಗೆ ವರದಿಯು ಮೊದಲು ಪೀಳಿಗೆಯ ವಿನಂತಿಗೆ ಪ್ರತಿಕ್ರಿಯೆಯಾಗಿ ಬರುತ್ತದೆ, 
• ತದನಂತರ ಅದು ಬರುವುದಿಲ್ಲ.

[/ಸ್ಪಾಯ್ಲರ್] ಕೋಡ್ ಬರೆಯಲು ಪ್ರಾರಂಭಿಸೋಣ

ಪ್ರಸ್ತುತ ದಿನಾಂಕದಿಂದ ವ್ಯವಕಲನವನ್ನು ಗಣನೆಗೆ ತೆಗೆದುಕೊಂಡು ದಿನಾಂಕವನ್ನು ಪಡೆಯುವ ವಿಧಾನ

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 ರಿಂದ. ಈ ಎಲ್ಲದರಲ್ಲೂ ಗೊಂದಲಕ್ಕೀಡಾಗದಿರಲು, ಎರಡು ವಿಭಿನ್ನ ವಿಧಾನಗಳನ್ನು ಬರೆಯುವುದು ಸುಲಭವಾಗಿದೆ. ಇದು ವಿಚಿತ್ರ, ಏಕೆಂದರೆ ಕೆಲಸದ ತರ್ಕವು ಒಂದೇ ಆಗಿರುತ್ತದೆ. ನಾನು ಒಂದು ವಿಧಾನವನ್ನು ಮಾಡಲು ಪ್ರಯತ್ನಿಸಿದಾಗ ನಾನು ದೀರ್ಘಕಾಲ ಉಗುಳಿದೆ ಮತ್ತು ಕಡಿಮೆ ಕೋಡ್ ಇತ್ತು. ಇಲ್ಲಿ ಯಾವುದೇ ಉದಾಹರಣೆಗಳಿಲ್ಲ.

ಗೆಟ್ ಆಪರೇಷನ್ಸ್ ಬೈಕರ್ಸರ್

ಮೂವರಲ್ಲಿ ನನ್ನ ನೆಚ್ಚಿನ. ಅತ್ಯಂತ ನಿಖರವಲ್ಲದಿದ್ದರೂ, ಆದರೆ ಹೆಚ್ಚು ಸಮರ್ಪಕವಾಗಿದೆ. ಖಾತೆಯನ್ನು ರಚಿಸುವ ಪ್ರಾರಂಭದಿಂದ ಗರಿಷ್ಠ ಸಂಭವನೀಯ ದಿನಾಂಕದವರೆಗೆ ನಾವು ವಿನಂತಿಯನ್ನು ಮಾಡುತ್ತೇವೆ (ಖಾತೆ ಅಥವಾ ಪ್ರಸ್ತುತವನ್ನು ಮುಚ್ಚುವುದು). ನಾವು ಉತ್ತರವನ್ನು ಪಡೆಯುತ್ತೇವೆ, ಕರ್ಸರ್ ಅನ್ನು ತೆಗೆದುಕೊಂಡು ಡೇಟಾ ಇರುವವರೆಗೆ ಮರು ವಿನಂತಿಸುತ್ತೇವೆ.  ಮತ್ತು ಮೇಲಿನ ಉದಾಹರಣೆಗಳಿಗಿಂತ ಕೋಡ್ ಹೆಚ್ಚು ಸಂಕ್ಷಿಪ್ತವಾಗಿದೆ.

ಕಾನ್ಸ್ಟ್ ಟೈಮರ್ = ಅಸಿಂಕ್ ಸಮಯ => {     ಹೊಸ ಭರವಸೆ ಹಿಂತಿರುಗಿ (ಪರಿಹಾರ => ಸೆಟ್ಟೈಮ್ಔಟ್ (ಪರಿಹಾರ, ಸಮಯ)); }   const getOperationsByCursor = async (sdk, accountId, from, to, cursor = ”) => { {     const         reqData = {             accountId,             ಇಂದ,             ಗೆ,             ಮಿತಿ: 1000,             ರಾಜ್ಯ: sdk.OperationState.OPERATION_STATE_EXECUTED:             ತಪ್ಪು,Commission ಇಲ್ಲದೆ             ವ್ಯಾಪಾರವಿಲ್ಲದೆ: ಸುಳ್ಳು,             ರಾತ್ರಿಯಿಲ್ಲದೆ: ತಪ್ಪು,             ಕರ್ಸರ್,         };           ಹಿಂತಿರುಗಿ ನಿರೀಕ್ಷಿಸಿ 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, {                 ಐಟಂಗಳು: ಡೇಟಾ?.ಐಟಂಗಳು,                 ಪ್ರಗತಿಯಲ್ಲಿದೆ: ಬೂಲಿಯನ್(ಮುಂದಿನ ಕರ್ಸರ್), });

ಪ್ರಾರಂಭಿಸಲು ಡ್ರಾಫ್ಟ್ ಇಲ್ಲಿದೆ: 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

  ಇದು ನನ್ನ ಬೆಳವಣಿಗೆ, ಅರ್ಥ ಮಾಡಿಕೊಳ್ಳಲು, ಓಡಿಹೋಗಲು ಮತ್ತು ಸ್ವಂತವಾಗಿ ಎಣಿಸಲು ಸೋಮಾರಿಯಾದವರಿಗೆ. ಬಳಕೆದಾರರ ಕೋರಿಕೆಯ ಮೇರೆಗೆ ಅಲ್ಲಿ ವಿಶ್ಲೇಷಣೆಗಳನ್ನು ಸೇರಿಸಲು ನಾನು ಯೋಜಿಸುತ್ತೇನೆ. ನೀವು ಲೇಖನವನ್ನು ಇಷ್ಟಪಟ್ಟರೆ, ನನ್ನ ಟೆಲಿಗ್ರಾಮ್ ಚಾನಲ್‌ಗೆ ಚಂದಾದಾರರಾಗಿ .