ਟਿੰਕੋਫ ਇਨਵੈਸਟਮੈਂਟਸ ਲਈ ਅੰਕੜਾ ਸੇਵਾ ਦੇ ਵਿਕਾਸ ਦੇ ਪਿੱਛੇ ਪ੍ਰੇਰਕ ਸਨ:

• ਹੈਬਰੇ ‘ਤੇ ਲੇਖ “ਟਿੰਕੋਫ ਨਿਵੇਸ਼ ਕੀ ਨਹੀਂ ਕਹਿ ਰਹੇ ਹਨ” 
• ਪਲੇਟਫਾਰਮ ਉਪਭੋਗਤਾਵਾਂ ਦੀਆਂ ਇੱਛਾਵਾਂ ਦਾ ਵਿਸ਼ਲੇਸ਼ਣ
• ਕਮਿਸ਼ਨਾਂ ਦੀ  ਗਣਨਾ ਬਾਰੇ ਇੱਕ ਲੇਖ

ਕੀ ਚਰਚਾ ਕੀਤੀ ਜਾਵੇਗੀ?

• ਵਿਕਾਸ ਬਾਰੇ ਸਿਰਫ ਲਾਗੂ ਹਿੱਸਾ.
• ਅਸਲ ਗਿਆਨ ਅਤੇ ਅਨੁਭਵ, ਜੋ ਵਿੱਤੀ ਸਾਧਨਾਂ ਨਾਲ ਕੰਮ ਕਰਨ ਵਿੱਚ ਬਹੁਤ ਮਹੱਤਵਪੂਰਨ ਹਨ।
• ਕੰਮ ਕਰਨ ਲਈ ਮੁੱਦਿਆਂ ਦੀ ਸੰਖੇਪ ਜਾਣਕਾਰੀ

ਇਸ ਲਈ, ਮੈਂ ਵਪਾਰ ਦੇ ਅੰਕੜਿਆਂ ਦੀ ਗਣਨਾ ਕਰਨਾ ਚਾਹੁੰਦਾ ਹਾਂ ਅਤੇ ਇਸਨੂੰ ਸੁਵਿਧਾਜਨਕ ਤਰੀਕੇ ਨਾਲ ਕਰਨਾ ਚਾਹੁੰਦਾ ਹਾਂ. 

ਸਟੈਟਿਸਟਿਕਸ ਸਰਵਿਸ ਨੂੰ ਕਦਮ ਦਰ ਕਦਮ ਵਿਕਸਿਤ ਕਰਨਾ: 

1. ਟਿੰਕੋਫ ਇਨਵੈਸਟ API ਨਾਲ ਕਨੈਕਸ਼ਨ
2. ਇੱਕ ਬ੍ਰਾਊਜ਼ਰ ਵਿੱਚ ਟਿੰਕੋਫ ਇਨਵੈਸਟ API ਤੋਂ ਡਾਟਾ ਡਰਾਇੰਗ ਕਰਨਾ
3. ਬ੍ਰੋਕਰੇਜ ਰਿਪੋਰਟਾਂ ਅਤੇ ਲੈਣ-ਦੇਣ ਪ੍ਰਾਪਤ ਕਰਨਾ
4. ਦਿਲਚਸਪੀ ਦੀ ਜਾਣਕਾਰੀ ਦੀ ਗਣਨਾ ਅਤੇ ਆਉਟਪੁੱਟ
5. ਭਵਿੱਖ ਲਈ ਸਿੱਟੇ ਅਤੇ ਯੋਜਨਾਵਾਂ

ਟਿੰਕੋਫ ਇਨਵੈਸਟ 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’);   // ਟੋਕਨ ਜੋ ਇਸ ਤਰ੍ਹਾਂ  ਪ੍ਰਾਪਤ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ const TOKEN = ‘YOURAPI’;   // ਐਪਲੀਕੇਸ਼ਨ ਦਾ ਨਾਮ ਜਿਸ ਦੁਆਰਾ ਤੁਹਾਨੂੰ TCS ਲੌਗਸ ਵਿੱਚ ਪਾਇਆ ਜਾ ਸਕਦਾ ਹੈ। const appName = ‘tcsstat’;   const sdk = createSdk (ਟੋਕਨ, ਐਪ ਨਾਮ); (async () => {     console.log(await sdk.users.getAccounts()); })();

ਨਤੀਜਾ: ਤੁਹਾਡੇ ਖਾਤਿਆਂ ਦੀ ਇੱਕ ਸੂਚੀ ਕੰਸੋਲ ਵਿੱਚ ਪ੍ਰਦਰਸ਼ਿਤ ਕੀਤੀ ਜਾਵੇਗੀ। ਉਦਾਹਰਨ ਲਈ, ਆਓ ਸੂਖਮਤਾਵਾਂ ਦਾ ਵਿਸ਼ਲੇਸ਼ਣ ਕਰੀਏ:

• ਖਾਤਿਆਂ ਦੀ ਸੂਚੀ ਵਿੱਚ ਇੱਕ “ਨਿਵੇਸ਼ ਬੈਂਕ” ਹੈ, ਜਿਸ ਨਾਲ ਤੁਸੀਂ API ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਕੰਮ ਨਹੀਂ ਕਰ ਸਕਦੇ ਹੋ
• ਕਿਰਪਾ ਕਰਕੇ ਧਿਆਨ ਦਿਓ ਕਿ ਫੀਲਡ ਕੈਮਲਕੇਸ ਵਿੱਚ ਆਉਂਦੇ ਹਨ, ਜਦੋਂ ਕਿ ਦਸਤਾਵੇਜ਼ ਵਿੱਚ ਇਹ ਖੇਤਰ under_score ਵਿੱਚ ਪੇਸ਼ ਕੀਤੇ ਜਾਂਦੇ ਹਨ। 
• ਇਹ ਹਰ ਜਗ੍ਹਾ ਇਸ ਤਰ੍ਹਾਂ ਹੋਵੇਗਾ, ਇਸਲਈ ਤੁਸੀਂ ਦਸਤਾਵੇਜ਼ਾਂ ਵਿੱਚੋਂ ਇੱਕ ਖੇਤਰ ਨੂੰ ਲੈ ਕੇ ਕਾਪੀ ਨਹੀਂ ਕਰ ਸਕਦੇ।

ਲਾਭਦਾਇਕ:

• ਤੁਸੀਂ ਇਹ ਕੋਡ ਪ੍ਰੋਜੈਕਟ ਸ਼ਾਖਾ ਵਿੱਚ ਲੱਭ ਸਕਦੇ ਹੋ

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. GetDivendsForeignIssuer
3. ਕਰਸਰ ਦੁਆਰਾ ਓਪਰੇਸ਼ਨ ਪ੍ਰਾਪਤ ਕਰੋ

ਸ਼ੁਰੂ ਤੋਂ ਹੀ ਇਹ ਜਾਣਨਾ ਮਹੱਤਵਪੂਰਨ ਹੈ: 

• ਬ੍ਰੋਕਰੇਜ ਰਿਪੋਰਟ ਟੀ-3 ਮੋਡ ਵਿੱਚ ਤਿਆਰ ਕੀਤੀ ਜਾਂਦੀ ਹੈ, ਯਾਨੀ. ਵਪਾਰ ਉਹਨਾਂ ਦੇ ਅਸਲ ਐਗਜ਼ੀਕਿਊਸ਼ਨ ਤੋਂ ਬਾਅਦ ਉੱਥੇ ਪ੍ਰਦਰਸ਼ਿਤ ਕੀਤੇ ਜਾਂਦੇ ਹਨ। 
• ਇਸ ਮੁਤਾਬਕ ਜੇਕਰ ਤੁਸੀਂ ਪਿਛਲੇ ਦੋ ਦਿਨਾਂ ਤੋਂ ਇਸ ਰਿਪੋਰਟ ਦੀ ਮੰਗ ਕਰਦੇ ਹੋ ਤਾਂ ਇਹ ਤਿੰਨ ਦਿਨਾਂ ਵਿੱਚ ਤਿਆਰ ਹੋ ਜਾਵੇਗੀ। 
• ਆਖਰੀ ਦਿਨਾਂ ਲਈ ਲੈਣ-ਦੇਣ ਪ੍ਰਾਪਤ ਕਰਨ ਲਈ, ਅਸੀਂ ਲੈਣ-ਦੇਣ ਪ੍ਰਾਪਤ ਕਰਨ ਲਈ ਵਿਧੀ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹਾਂ, ਪਰ ਯਾਦ ਰੱਖੋ ਕਿ ਬ੍ਰੋਕਰੇਜ ਰਿਪੋਰਟ ਤਿਆਰ ਹੋਣ ਤੋਂ ਬਾਅਦ ਉਹਨਾਂ ਦੀ ਆਈਡੀ ਅਤੇ ਸਮੱਗਰੀ ਬਦਲ ਸਕਦੀ ਹੈ।

GetBrokerReport

ਬ੍ਰੋਕਰੇਜ ਰਿਪੋਰਟ ਪ੍ਰਾਪਤ ਕਰਨ ਲਈ, ਤੁਹਾਨੂੰ ਖਾਤਾ ਆਈਡੀ, ਰਿਪੋਰਟ ਦੀ ਸ਼ੁਰੂਆਤੀ ਮਿਤੀ ਅਤੇ ਸਮਾਪਤੀ ਮਿਤੀ ਲੈਣ ਦੀ ਲੋੜ ਹੈ, ਪਰ 31 ਦਿਨਾਂ ਤੋਂ ਵੱਧ ਨਹੀਂ। ਅਸੀਂ ਜਨਰੇਟ _broker_report_request ਵਿੱਚ API ਨੂੰ ਇੱਕ ਰਿਪੋਰਟ ਤਿਆਰ ਕਰਨ ਲਈ ਇੱਕ ਬੇਨਤੀ ਭੇਜਦੇ ਹਾਂ , ਜਵਾਬ ਵਿੱਚ ਇੱਕ taskId ਪ੍ਰਾਪਤ ਕਰੋ। ਉਸ ਤੋਂ ਬਾਅਦ, ਇਸ ਟਾਸਕ ਆਈਡੀ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ, ਅਸੀਂ get _broker_report_response ਤੋਂ ਡੇਟਾ ਪ੍ਰਾਪਤ ਕਰਦੇ ਹਾਂ।

• ਤੁਹਾਨੂੰ ਇਹਨਾਂ ਤਾਰੀਖਾਂ ਲਈ ਹਮੇਸ਼ਾ ਲਈ TaskID ਨੂੰ ਸੁਰੱਖਿਅਤ ਕਰਨ ਦੀ ਲੋੜ ਹੈ। 
• ਕਿਉਂਕਿ ਜੇਕਰ ਤੁਸੀਂ ਇਸਨੂੰ ਗੁਆ ਦਿੰਦੇ ਹੋ, ਤਾਂ ਬੇਨਤੀ ਕੀਤੀਆਂ ਮਿਤੀਆਂ ਲਈ ਰਿਪੋਰਟ ਪਹਿਲਾਂ ਪੀੜ੍ਹੀ ਦੀ ਬੇਨਤੀ ਦੇ ਜਵਾਬ ਵਿੱਚ ਆਵੇਗੀ, 
• ਅਤੇ ਫਿਰ ਇਹ ਬਿਲਕੁਲ ਨਹੀਂ ਆਵੇਗਾ.

[/ spoiler] ਆਓ ਕੋਡ ਲਿਖਣਾ ਸ਼ੁਰੂ ਕਰੀਏ

ਮਿਤੀ ਪ੍ਰਾਪਤ ਕਰਨ ਦਾ ਤਰੀਕਾ, ਮੌਜੂਦਾ ਮਿਤੀ ਤੋਂ ਘਟਾਓ ਨੂੰ ਧਿਆਨ ਵਿੱਚ ਰੱਖਦੇ ਹੋਏ

const getDateSubDay = (ਉਪ-ਦਿਨ = 5, ਸ਼ੁਰੂ = ਸਹੀ) => {     const ਮਿਤੀ = ਨਵੀਂ ਮਿਤੀ ();     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,         }, });

ਨਤੀਜਾ:

• ਕਮਾਂਡ ਦੇ ਪਹਿਲੇ ਐਗਜ਼ੀਕਿਊਸ਼ਨ ਦੇ ਨਤੀਜੇ ਵਜੋਂ, ਸਾਨੂੰ ਟਾਸਕ ਆਈਡੀ ਮਿਲਦੀ ਹੈ। 
• ਦਲਾਲ ਦੇ ਪੱਖ ‘ਤੇ ਰਿਪੋਰਟ ਤਿਆਰ ਹੋਣੀ ਸ਼ੁਰੂ ਹੋ ਜਾਂਦੀ ਹੈ। ਜਦੋਂ ਇਹ ਤਿਆਰ ਹੁੰਦਾ ਹੈ ਤਾਂ ਅਣਜਾਣ ਹੁੰਦਾ ਹੈ, ਅਸੀਂ ਉਡੀਕ ਕਰਦੇ ਹਾਂ ਅਤੇ ਸਮੇਂ-ਸਮੇਂ ‘ਤੇ ਰਿਪੋਰਟ ਦੀ ਉਮੀਦ ਵਿੱਚ ਟਾਸਕਆਈਡੀ ਨੂੰ ਖਿੱਚਦੇ ਹਾਂ।
• ਕਿਉਂ? ਕਿਉਂਕਿ ਜੇਕਰ ਰਿਪੋਰਟ ਤਿਆਰ ਨਹੀਂ ਹੈ, ਤਾਂ ਇਹ ਇੱਕ ਗਲਤੀ ਸੁੱਟਦੀ ਹੈ। ਜੇਕਰ ਬ੍ਰੋਕਰ ਦੇ ਪੱਖ ‘ਤੇ ਰਿਪੋਰਟ ਤਿਆਰ ਨਹੀਂ ਹੈ, ਤਾਂ ਇਹ ਤੁਹਾਡੇ ਕੋਡ ਵਿੱਚ ਇੱਕ ਤਰੁੱਟੀ ਹੈ। ਕਿਰਪਾ ਕਰਕੇ ਪ੍ਰਕਿਰਿਆ ਕਰੋ: 30058|INVALID_ARGUMENT|ਟਾਸਕ ਅਜੇ ਪੂਰਾ ਨਹੀਂ ਹੋਇਆ, ਕਿਰਪਾ ਕਰਕੇ ਬਾਅਦ ਵਿੱਚ ਦੁਬਾਰਾ ਕੋਸ਼ਿਸ਼ ਕਰੋ

ਉਡੀਕ ਕਰਨ ਅਤੇ ਰਿਪੋਰਟ ਪ੍ਰਾਪਤ ਕਰਨ ਲਈ ਕੋਡ ਕੁਝ ਇਸ ਤਰ੍ਹਾਂ ਦਿਖਾਈ ਦਿੰਦਾ ਹੈ।

const timer = async time => {     ਨਵਾਂ ਵਾਅਦਾ ਵਾਪਸ ਕਰੋ(resolve => setTimeout(resolve, time)); }   const getBrokerResponseByTaskId = async (taskId, ਪੰਨਾ = 0) => {     ਕੋਸ਼ਿਸ਼ ਕਰੋ {         return await (sdk.operations.getBrokerReport)({             getBrokerReportRequest: {                 taskId,                 page,             },         });     } ਕੈਚ (ਈ) {         console.log(‘ਉਡੀਕ’, ਈ);         ਉਡੀਕ ਟਾਈਮਰ (10000);         ਵਾਪਸੀ ਦੀ ਉਡੀਕ getBrokerResponseByTaskId(taskId, ਪੰਨਾ);     } };

ਫਿਰ ਉਹੀ ਜਾਦੂ ਹੁੰਦਾ ਹੈ। ਅਸੀਂ ਆਪਣੀ ਸਕ੍ਰਿਪਟ ਨੂੰ ਰੋਕਦੇ ਹਾਂ, ਇਸਨੂੰ ਦੁਬਾਰਾ ਸ਼ੁਰੂ ਕਰਦੇ ਹਾਂ, ਸਾਡੇ ਕੋਲ ਟਾਸਕਆਈਡੀ ਨਹੀਂ ਹੈ। ਅਸੀਂ taskId ਬੇਨਤੀ ਦੇ ਨਾਲ ਕੋਡ ਨੂੰ ਐਗਜ਼ੀਕਿਊਟ ਕਰਦੇ ਹਾਂ, ਪਰ ਸਾਨੂੰ ਹੁਣ ਟਾਸਕ ਆਈਡੀ ਨਹੀਂ ਮਿਲਦੀ, ਪਰ ਤੁਰੰਤ ਰਿਪੋਰਟ ਮਿਲਦੀ ਹੈ। ਜਾਦੂ! ਅਤੇ ਸਭ ਕੁਝ ਠੀਕ ਰਹੇਗਾ ਜੇ ਇਹ ਹਮੇਸ਼ਾ ਇਸ ਤਰ੍ਹਾਂ ਹੁੰਦਾ. ਪਰ ਇੱਕ ਮਹੀਨੇ ਵਿੱਚ ਕੋਈ ਡਾਟਾ ਨਹੀਂ ਹੋਵੇਗਾ। ਲਾਭਦਾਇਕ :

• ਥਿਊਰੀ ਦਾ ਇੱਕ ਬਿੱਟ ਇੱਥੇ ਅਤੇ ਇੱਥੇ ਦੱਸਿਆ ਗਿਆ ਹੈ .
• ਕੋਡ ਨੂੰ ਇਕੱਠੇ ਰੱਖਣ ਨਾਲ, ਡਰਾਫਟ ਕੁਝ ਇਸ ਤਰ੍ਹਾਂ ਦਿਖਾਈ ਦੇਵੇਗਾ।

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

• ਜੇਕਰ ਕਿਸੇ ਨੂੰ ਇਹ ਪਤਾ ਲੱਗਦਾ ਹੈ, ਤਾਂ ਇਸ ਮੁੱਦੇ ‘ ਤੇ ਤੁਹਾਡਾ ਸੁਆਗਤ ਹੈ । ਇਸ ਜਾਦੂ ਦੀ ਮੁਰੰਮਤ ਕਰਨ ਤੋਂ ਬਾਅਦ, ਇਹ ਆਪਣੀ ਸ਼ਕਤੀ ਗੁਆ ਦੇਵੇਗਾ ਅਤੇ ਕਿਸੇ ਤਰ੍ਹਾਂ ਵੱਖਰਾ ਹੋਵੇਗਾ. ਪਰ ਮੌਜੂਦਾ ਪਲ (03/21/2023) ‘ਤੇ ਇਹ ਉਸੇ ਤਰ੍ਹਾਂ ਕੰਮ ਕਰਦਾ ਹੈ।

GetDivendsForeignIssuer

ਕੋਈ ਸੋਚ ਸਕਦਾ ਹੈ ਕਿ ਇਹ ਤਰੀਕਾ ਪਿਛਲੇ ਇੱਕ ਵਰਗਾ ਹੈ ਅਤੇ ਤੁਸੀਂ ਇੱਕ ਸਿੰਗਲ ਵਿਧੀ ਦੀ ਵਰਤੋਂ ਕਰ ਸਕਦੇ ਹੋ ਜਿਸ ਵਿੱਚ ਤੁਸੀਂ ਸਿਰਫ ਓਪਰੇਸ਼ਨਾਂ ਦਾ ਨਾਮ ਬਦਲ ਸਕਦੇ ਹੋ। ਪਰ ਉਨ੍ਹਾਂ ਨੇ ਅੰਦਾਜ਼ਾ ਨਹੀਂ ਲਗਾਇਆ!  ਤਰੀਕਿਆਂ ਅਤੇ ਵਾਪਸ ਕੀਤੀ ਜਾਣਕਾਰੀ ਦੋਵਾਂ ਵਿੱਚ ਨਾਮਕਰਨ ਬਹੁਤ ਵੱਖਰਾ ਹੈ। ਅਤੇ ਪੰਨੇ ਦੀ ਗਿਣਤੀ 0 ਤੋਂ ਸ਼ੁਰੂ ਹੁੰਦੀ ਹੈ, ਫਿਰ 1 ਤੋਂ। ਇਸ ਸਭ ਵਿੱਚ ਉਲਝਣ ਵਿੱਚ ਨਾ ਪੈਣ ਲਈ, ਦੋ ਵੱਖ-ਵੱਖ ਤਰੀਕਿਆਂ ਨਾਲ ਲਿਖਣਾ ਆਸਾਨ ਹੈ। ਜੋ ਕਿ ਅਜੀਬ ਹੈ, ਕਿਉਂਕਿ ਕੰਮ ਦਾ ਤਰਕ ਇੱਕੋ ਜਿਹਾ ਹੈ। ਮੈਂ ਲੰਬੇ ਸਮੇਂ ਲਈ ਥੁੱਕਿਆ ਜਦੋਂ ਮੈਂ ਇੱਕ ਢੰਗ ਬਣਾਉਣ ਦੀ ਕੋਸ਼ਿਸ਼ ਕੀਤੀ ਅਤੇ ਘੱਟ ਕੋਡ ਸੀ. ਇੱਥੇ ਕੋਈ ਉਦਾਹਰਣ ਨਹੀਂ ਹੋਵੇਗੀ।

ਕਰਸਰ ਦੁਆਰਾ ਓਪਰੇਸ਼ਨ ਪ੍ਰਾਪਤ ਕਰੋ

ਤਿੰਨਾਂ ਵਿੱਚੋਂ ਮੇਰਾ ਮਨਪਸੰਦ। ਹਾਲਾਂਕਿ ਸਭ ਤੋਂ ਸਹੀ ਨਹੀਂ, ਪਰ ਸਭ ਤੋਂ ਢੁਕਵਾਂ। ਅਸੀਂ ਖਾਤਾ ਬਣਾਉਣ ਦੀ ਸ਼ੁਰੂਆਤ ਤੋਂ ਲੈ ਕੇ ਵੱਧ ਤੋਂ ਵੱਧ ਸੰਭਾਵਿਤ ਮਿਤੀ ਤੱਕ ਬੇਨਤੀ ਕਰਦੇ ਹਾਂ (ਖਾਤਾ ਬੰਦ ਕਰਨਾ ਜਾਂ ਮੌਜੂਦਾ ਇੱਕ)। ਅਸੀਂ ਜਵਾਬ ਪ੍ਰਾਪਤ ਕਰਦੇ ਹਾਂ, ਕਰਸਰ ਲੈਂਦੇ ਹਾਂ ਅਤੇ ਜਦੋਂ ਤੱਕ ਡੇਟਾ ਹੁੰਦਾ ਹੈ ਦੁਬਾਰਾ ਬੇਨਤੀ ਕਰਦੇ ਹਾਂ.  ਅਤੇ ਕੋਡ ਉਪਰੋਕਤ ਉਦਾਹਰਣਾਂ ਨਾਲੋਂ ਵਧੇਰੇ ਸੰਖੇਪ ਹੈ।

const timer = async time => {     ਨਵਾਂ ਵਾਅਦਾ ਵਾਪਸ ਕਰੋ(resolve => setTimeout(resolve, time)); }   const getOperationsByCursor = async (sdk, accountId, from, to, cursor = ”) => {     ਕੋਸ਼ਿਸ਼ ਕਰੋ {         const reqData = {             accountId,             from,             to,             limit: 1000,             state: sdk.OperationState.OPERATION_STATE_EXECUTED,             ਬਿਨਾਂ ਕਮਿਸ਼ਨ, ਗਲਤ:             ਬਿਨਾਂ ਵਪਾਰ: ਝੂਠੇ,             ਬਿਨਾਂ ਰਾਤਾਂ ਦੇ: ਝੂਠੇ,             ਕਰਸਰ,         };           ਵਾਪਸੀ ਦੀ ਉਡੀਕ ਕਰੋ sdk.operations.getOperationsByCursor(reqData);     } ਫੜੋ (e) {         ਉਡੀਕ ਟਾਈਮਰ (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, ਓਪਰੇਸ਼ਨਾਂ ਤੋਂ ਮੁੜ ਲੋਡ ਕਰੋ. ਪਰ ਇਸ ਨੂੰ ਇੱਕ ਵੱਖਰੇ ਲੇਖ ਵਿੱਚ ਵੱਖ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ. ਮੁੱਖ ਸੂਖਮਤਾਵਾਂ ਵਿੱਚੋਂ ਜਿਸ ਦਾ ਤੁਸੀਂ ਸਾਹਮਣਾ ਕਰੋਗੇ ਉਹ ਹੈ ਗਲੂ ਓਪਰੇਸ਼ਨ ਅਤੇ ਇੱਕ ਦਲਾਲੀ ਰਿਪੋਰਟ।

•  ਜੇ ਅੱਜ ਤੁਹਾਨੂੰ ਲੋੜੀਂਦੀਆਂ ਤਾਰੀਖਾਂ ਲਈ ਇੱਕ ਬ੍ਰੋਕਰੇਜ ਰਿਪੋਰਟ ਅਤੇ ਲੈਣ-ਦੇਣ ਪ੍ਰਾਪਤ ਹੋਇਆ ਹੈ, ਤਾਂ ਇਹ ਸਭ ਡੇਟਾਬੇਸ ਵਿੱਚ ਪਾਓ, ਫਿਰ ਕੋਈ ਸਮੱਸਿਆ ਨਹੀਂ ਹੈ. 
• ਤੁਹਾਨੂੰ ਕੱਲ੍ਹ ਸਮੱਸਿਆਵਾਂ ਹੋਣਗੀਆਂ ਜਦੋਂ ਤੁਸੀਂ ਰਿਪੋਰਟ ਅਤੇ ਓਪਰੇਸ਼ਨਾਂ ਤੋਂ ਡੇਟਾ ਦਾ ਅਗਲਾ ਹਿੱਸਾ ਪ੍ਰਾਪਤ ਕਰੋਗੇ ਅਤੇ ਉਹਨਾਂ ਨੂੰ ਮੌਜੂਦਾ ਡੇਟਾਬੇਸ ਨਾਲ ਸਮਕਾਲੀ ਕਰਨ ਦਾ ਫੈਸਲਾ ਕਰੋਗੇ। 
• ਪ੍ਰੋਸੈਸਿੰਗ ਤੋਂ ਬਾਅਦ ਮੇਲ ਨਾ ਹੋਣ ਜਾਂ ਆਈਡੀ ਬਦਲਣ ਬਾਰੇ ਬਹੁਤ ਸਾਰੀਆਂ ਬਾਰੀਕੀਆਂ
• ਫਿਰ ਓਟੀਸੀ ਮਾਰਕੀਟ ਲਈ, ਆਈਡੀ ਬਿਲਕੁਲ ਮੇਲ ਨਹੀਂ ਖਾਂਦੀ।
•  ਦੇ ਨਾਲ ਨਾਲ ਸਿੰਕ੍ਰੋਨਾਈਜ਼ਿੰਗ ਯੰਤਰਾਂ ਦੀਆਂ ਸੂਖਮਤਾਵਾਂ, ਜੋ ਕਿ ਏਪੀਆਈ ਦੀਆਂ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ ਦੇ ਕਾਰਨ ਦੁਬਾਰਾ ਮੇਲ ਨਹੀਂ ਖਾਂਦੀਆਂ. ਪਰ ਇਹ ਇੱਕ ਹੋਰ ਕਹਾਣੀ ਹੈ.

ਆਉ ਸਾਡੀ ਐਪਲੀਕੇਸ਼ਨ ਵਿੱਚ ਓਪਰੇਸ਼ਨਾਂ ਬਾਰੇ ਜਾਣਕਾਰੀ ਪ੍ਰਾਪਤ ਕਰਨ ਨੂੰ ਸ਼ਾਮਲ ਕਰੀਏ। ਮੁੱਖ ਸਵਾਲ ਇਹ ਹੋਵੇਗਾ ਕਿ ਡੇਟਾ ਕਿੱਥੇ ਪ੍ਰੋਸੈਸ ਅਤੇ ਸਟੋਰ ਕੀਤਾ ਜਾਵੇਗਾ।

•  ਜੇ ਤੁਸੀਂ ਇਹ ਆਪਣੇ ਲਈ ਕਰਦੇ ਹੋ, ਤਾਂ ਤੁਸੀਂ ਵੱਖ-ਵੱਖ ਡਿਵਾਈਸਾਂ ਤੋਂ ਇੱਕੋ ਡੇਟਾ ਦੀ ਵਰਤੋਂ ਕਰੋਗੇ। ਫਿਰ ਤੁਹਾਨੂੰ ਸਰਵਰ ‘ਤੇ ਡੇਟਾ ਦੀ ਪ੍ਰਕਿਰਿਆ ਅਤੇ ਸਟੋਰ ਕਰਨ ਦੀ ਜ਼ਰੂਰਤ ਹੈ.
• ਜੇ ਤੁਹਾਡੇ ਕੋਲ ਬਹੁਤ ਸਾਰੇ ਵੱਖ-ਵੱਖ ਉਪਭੋਗਤਾਵਾਂ ਦੁਆਰਾ ਖਪਤ ਕੀਤੇ ਗਏ ਬਹੁਤ ਸਾਰੇ ਵੱਖ-ਵੱਖ ਡੇਟਾ ਹਨ, ਤਾਂ ਤੁਹਾਨੂੰ ਇਹ ਫੈਸਲਾ ਕਰਨ ਦੀ ਜ਼ਰੂਰਤ ਹੈ ਕਿ ਵਧੇਰੇ ਮਹੱਤਵਪੂਰਨ ਕੀ ਹੈ: ਉਪਭੋਗਤਾਵਾਂ ਦੀ ਗਤੀ ਜਾਂ ਤੁਹਾਡੇ ਪਾਸੇ ਲੋਹੇ ਦੀ ਬਚਤ. ਜੋ ਕੋਈ ਵੀ ਹਾਰਡਵੇਅਰ ਦੀ ਬੇਅੰਤ ਮਾਤਰਾ ਨੂੰ ਬਰਦਾਸ਼ਤ ਕਰ ਸਕਦਾ ਹੈ, ਉਹ ਆਪਣੇ ਸਰਵਰ ‘ਤੇ ਸਭ ਕੁਝ ਗਿਣਦਾ ਹੈ ਅਤੇ ਇਸਨੂੰ ਉਪਭੋਗਤਾਵਾਂ ਲਈ ਬਹੁਤ ਤੇਜ਼ ਬਣਾਉਂਦਾ ਹੈ, ਉਪਭੋਗਤਾ ਸਰੋਤਾਂ ਨੂੰ ਬਚਾਉਂਦਾ ਹੈ, ਜਿਵੇਂ ਕਿ ਬੈਟਰੀ ਅਤੇ ਟ੍ਰੈਫਿਕ, ਜੋ ਕਿ ਫ਼ੋਨਾਂ ‘ਤੇ ਬਹੁਤ ਮਹੱਤਵਪੂਰਨ ਹੈ।

ਬਦਲੇ ਵਿੱਚ, ਬ੍ਰਾਉਜ਼ਰ ਵਿੱਚ ਗਿਣਤੀ ਕਰਨਾ ਸਿਧਾਂਤ ਵਿੱਚ ਸਭ ਤੋਂ ਅਨੁਕੂਲ ਹੱਲ ਨਹੀਂ ਹੈ। ਇਸ ਲਈ, ਜੋ ਮਹਿੰਗਾ ਨਹੀਂ ਹੈ, ਅਸੀਂ ਇਸਨੂੰ ਆਪਣੇ ਸਰਵਰ ‘ਤੇ ਵਿਚਾਰਦੇ ਹਾਂ. ਬਾਕੀ ਅਸੀਂ ਗਾਹਕ ‘ਤੇ ਛੱਡ ਦਿੰਦੇ ਹਾਂ। ਮੈਂ ਅਸਲ ਵਿੱਚ ਸਰਵਰ ਤੇ ਕਮਿਸ਼ਨ ਲੈਣਾ ਅਤੇ ਗਣਨਾ ਕਰਨਾ ਚਾਹੁੰਦਾ ਹਾਂ. ਪਰ ਇੱਥੇ “ਇੰਟਰਐਕਟੀਵਿਟੀ” ਨਾਮਕ ਸੂਖਮਤਾ ਆਉਂਦੀ ਹੈ। ਮੰਨ ਲਓ ਕਿ ਤੁਹਾਡੇ ਕੋਲ ਹਜ਼ਾਰਾਂ ਓਪਰੇਸ਼ਨ ਹਨ ਅਤੇ ਉਹਨਾਂ ਨੂੰ ਪ੍ਰਾਪਤ ਕਰਨ ਵਿੱਚ ਪੰਜ ਮਿੰਟ ਲੱਗਦੇ ਹਨ। ਇਸ ਸਮੇਂ ਉਪਭੋਗਤਾ ਕੋਲ ਕੀ ਹੋਵੇਗਾ? ਸਪਿਨਰ? ਤਰੱਕੀ? ਕਿੰਨੀ ਅਪਲੋਡ ਕੀਤੀ ਗਈ ਸੀ ਬਾਰੇ ਜਾਣਕਾਰੀ? “ਕਿਰਿਆਸ਼ੀਲ ਉਡੀਕ” ਦੀ ਵਰਤੋਂ ਕਰਨਾ ਆਦਰਸ਼ ਹੈ ਜਦੋਂ ਪ੍ਰਕਿਰਿਆ ਵਿੱਚ ਉਪਭੋਗਤਾ ਪਹਿਲਾਂ ਹੀ ਕੁਝ ਦੇਖ ਸਕਦਾ ਹੈ। ਇੱਥੇ ਨਤੀਜਾ ਹੈ:

• ਪੰਨਾ ਲੋਡ ਹੋ ਰਿਹਾ ਹੈ
• ਸਾਰੇ ਚਲਾਨ ਮੰਗੇ ਜਾਂਦੇ ਹਨ
• ਉਸ ਤੋਂ ਬਾਅਦ, ਸਾਰੇ ਖਾਤਿਆਂ ਲਈ ਚਲਾਏ ਗਏ ਲੈਣ-ਦੇਣ ਲਈ ਕਮਿਸ਼ਨਾਂ ਵਾਲੇ ਸਾਰੇ ਲੈਣ-ਦੇਣ ਦੀ ਬੇਨਤੀ ਕੀਤੀ ਜਾਂਦੀ ਹੈ। ਜਿਵੇਂ ਹੀ ਡਾਟਾ ਪ੍ਰਾਪਤ ਹੁੰਦਾ ਹੈ, ਇਹ ਬ੍ਰਾਊਜ਼ਰ ਵਿੱਚ ਰੈਂਡਰ ਕੀਤਾ ਜਾਂਦਾ ਹੈ।

ਹਰ ਵਾਰ ਇਵੈਂਟਸ ਵਿੱਚ ਡੇਟਾ ਨੂੰ ਫਿਲਟਰ ਨਾ ਕਰਨ ਲਈ, ਅਸੀਂ ਹਰੇਕ ਖਾਤੇ ਲਈ ਆਪਣੀ ਖੁਦ ਦੀ ਘਟਨਾ ਨੂੰ ਖਿੱਚਦੇ ਹਾਂ। ਇਸ ਤਰ੍ਹਾਂ:

socket.emit(‘sdk:getOperationsCommissionResult_’ + accountId, {                 ਆਈਟਮਾਂ: ਡੇਟਾ?. ਆਈਟਮਾਂ,                 ਪ੍ਰਗਤੀ: ਬੂਲੀਨ(ਅਗਲਾ ਕਰਸਰ), });

ਲਾਂਚ ਕਰਨ ਲਈ ਡਰਾਫਟ ਇੱਥੇ ਹੈ: https://github.com/pskucherov/tcsstat/tree/step3 https://github.com/pskucherov/tcsstat/compare/step2…step3 ਅੱਗੇ ਵਧਣਾ। ਇਹ ਬਹੁਤ ਵਧੀਆ ਹੈ ਕਿ ਤੁਸੀਂ ਇਹ ਲਾਈਨ ਪੜ੍ਹੀ ਹੈ! 

ਦਿਲਚਸਪੀ ਦੀ ਜਾਣਕਾਰੀ ਦੀ ਗਣਨਾ ਅਤੇ ਆਉਟਪੁੱਟ

ਇਸ ਗੱਲ ‘ਤੇ ਨਿਰਭਰ ਕਰਦਾ ਹੈ ਕਿ ਕਿਸ ਨੂੰ ਕਿਸ ਜਾਣਕਾਰੀ ਦੀ ਲੋੜ ਹੈ। ਇਸ ਲਈ, ਮੈਂ ਤੁਹਾਨੂੰ ਤੁਰੰਤ ਮੁੱਖ ਸੂਖਮਤਾਵਾਂ ਬਾਰੇ ਦੱਸਦਾ ਹਾਂ ਜੋ ਤੁਹਾਨੂੰ ਮਿਲਣਗੇ.

ਕੀਮਤਾਂ ਦੇ ਨਾਲ ਕੰਮ ਕਰਨਾ 

ਹਰ ਕੋਈ ਜੋ ਵਿੱਤ ਨਾਲ ਕੰਮ ਕਰਦਾ ਹੈ, ਉਹ ਜਾਣਦਾ ਹੈ ਕਿ ਪੈਸੇ ਦਾ ਲੈਣ-ਦੇਣ ਸਿਰਫ਼ ਸੰਖਿਆਵਾਂ ਨਾਲ ਹੀ ਕੀਤਾ ਜਾਣਾ ਚਾਹੀਦਾ ਹੈ। ਦਸ਼ਮਲਵ ਬਿੰਦੂ ਤੋਂ ਬਾਅਦ ਮੁੱਲਾਂ ਦੀ ਅਸ਼ੁੱਧਤਾ ਅਤੇ ਵੱਡੀ ਗਿਣਤੀ ਵਿੱਚ ਕਾਰਵਾਈਆਂ ਦੇ ਨਾਲ ਸੰਚਤ ਗਲਤੀ ਦੇ ਕਾਰਨ। ਇਸ ਲਈ ਸਾਰੀਆਂ ਕੀਮਤਾਂ ਹੇਠਾਂ ਦਿੱਤੇ ਮਨੀ ਵੈਲਿਊ ਫਾਰਮੈਟ ਵਿੱਚ ਪੇਸ਼ ਕੀਤੀਆਂ ਗਈਆਂ ਹਨ

ਅਸੀਂ ਉਹਨਾਂ ਨੂੰ ਵੱਖਰੇ ਤੌਰ ‘ਤੇ ਪ੍ਰਕਿਰਿਆ ਕਰਦੇ ਹਾਂ, ਫਿਰ ਉਹਨਾਂ ਨੂੰ ਕੀਮਤ ਮੁੱਲ ‘ਤੇ ਲਿਆਉਂਦੇ ਹਾਂ:

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

  ਇਹ ਮੇਰਾ ਵਿਕਾਸ ਹੈ, ਉਨ੍ਹਾਂ ਲਈ ਜੋ ਆਪਣੇ ਆਪ ਨੂੰ ਸਮਝਣ, ਦੌੜਨ ਅਤੇ ਗਿਣਨ ਵਿੱਚ ਬਹੁਤ ਆਲਸੀ ਹਨ। ਮੈਂ ਉਪਭੋਗਤਾਵਾਂ ਦੀ ਬੇਨਤੀ ‘ਤੇ ਉੱਥੇ ਵਿਸ਼ਲੇਸ਼ਣ ਜੋੜਨ ਦੀ ਯੋਜਨਾ ਬਣਾ ਰਿਹਾ ਹਾਂ. ਜੇ ਤੁਹਾਨੂੰ ਲੇਖ ਪਸੰਦ ਆਇਆ, ਤਾਂ ਮੇਰੇ ਟੈਲੀਗ੍ਰਾਮ ਚੈਨਲ ਨੂੰ ਸਬਸਕ੍ਰਾਈਬ ਕਰੋ ।