పవర్‌షెల్‌ని ఉపయోగించి 7-9 తరగతుల్లోని పాఠశాల పిల్లల కోసం ఒక సాధారణ టెలిగ్రామ్ బాట్ కోసం టెంప్లేట్

స్నేహితుడితో సంభాషణల సమయంలో, వారి పాఠశాలలో 8-10 తరగతుల పిల్లలకు ప్రోగ్రామింగ్ అస్సలు నేర్పడం లేదని నేను అకస్మాత్తుగా తెలుసుకున్నాను. వర్డ్, ఎక్సెల్ మరియు ప్రతిదీ. ఎక్సెల్ కోసం లోగో లేదు, పాస్కల్ కాదు, VBA కూడా లేదు.

నేను చాలా ఆశ్చర్యపోయాను, ఇంటర్నెట్ తెరిచి చదవడం ప్రారంభించాను -
ఒక ప్రత్యేక పాఠశాల యొక్క పని ఏమిటంటే, దాని అభివృద్ధి మరియు జీవనశైలిలో సమాచార సమాజం యొక్క పరిస్థితులకు అనుగుణంగా కొత్త తరం యొక్క విద్యను ప్రోత్సహించడం.
పాస్కల్ ప్రోగ్రామింగ్ లాంగ్వేజ్ యొక్క ప్రాథమిక నిర్మాణాలపై వారి జ్ఞానాన్ని ఆచరణలో ఏకీకృతం చేయడానికి ఈ కోర్సు విద్యార్థులను అనుమతిస్తుంది. (2017 కోసం కొన్ని వ్యాయామశాల కార్యక్రమం నుండి)

చివరికి, నేను కొన్ని గంటలు గడపాలని నిర్ణయించుకున్నాను మరియు "పాఠశాల పిల్లల కోసం ఒక సాధారణ బాట్‌ను ఎలా సృష్టించాలి" అనే ఉదాహరణను రూపొందించాను.

పవర్‌షెల్‌లో మరొక సాధారణ బోట్‌ను ఎలా వ్రాయాలి మరియు వెబ్‌హుక్, వైట్ IPలు, అంకితమైన సర్వర్లు, క్లౌడ్‌లో మోహరించిన వర్చువల్ మిషన్లు మరియు మొదలైనవి లేకుండా ఎలా పని చేయాలో కట్ క్రింద ఉంది - సాధారణ Windowsతో సాధారణ హోమ్ PCలో.

TLDR: వ్యాకరణ మరియు వాస్తవిక దోషాలతో కూడిన మరొక బోరింగ్ కథనం, చదవడానికి ఏమీ లేదు, హాస్యం లేదు, చిత్రాలు లేవు.

వ్యాసంలో కొత్తది ఏమీ లేదు, ఇంతకు ముందు వ్రాసిన ప్రతిదీ ఇప్పటికే హబ్రేలో ఉంది, ఉదాహరణకు కథనాలలో సూచనలు: టెలిగ్రామ్‌లో బాట్‌లను ఎలా సృష్టించాలి и సిస్టమ్ అడ్మినిస్ట్రేటర్ కోసం టెలిగ్రామ్ బాట్.
అంతేకాకుండా, ప్రతిసారీ విద్యా సాహిత్యాన్ని సూచించకుండా ఉండటానికి వ్యాసం ఉద్దేశపూర్వకంగా అనవసరంగా ఉంది. టెక్స్ట్‌లో గ్యాంగ్ 4, పవర్‌షెల్ డీప్ డైవ్స్ లేదా, ది 5 పిల్లర్స్ ఆఫ్ ది AWS వెల్-ఆర్కిటెక్టెడ్ ఫ్రేమ్‌వర్క్‌కు సంబంధించిన సూచనలు లేవు.

ముందుమాటకు బదులుగా, మీరు దాటవేయవచ్చు

దాటవేయడానికి సంకోచించకండి2006లో, మైక్రోసాఫ్ట్ అప్పటి-Windows XP, Vista మరియు సర్వర్ 1.0 కోసం PowerShell 2003ని విడుదల చేసింది. కొన్ని మార్గాల్లో, ఇది cmdbat స్క్రిప్ట్‌లు, vb స్క్రిప్ట్‌లు, Windows స్క్రిప్ట్ హోస్ట్ మరియు JScript వంటి వాటిని భర్తీ చేసింది.

ఇప్పుడు కూడా, లూప్‌లు, తరగతులు, ఫంక్షన్‌లు, MS GUI కాల్‌లు ఉన్నప్పటికీ, బహుశా ఇప్పటికీ ఉపయోగించిన డెల్ఫీ (లేదా ఏదైనా పాతది) బదులుగా, లోగో ఎంపికల తర్వాత పవర్‌షెల్ తదుపరి దశగా మాత్రమే పరిగణించబడుతుంది, Git ఇంటిగ్రేషన్ మరియు అందువలన న.

పవర్‌షెల్ చాలా అరుదుగా ఉపయోగించబడుతుంది; మీరు దీన్ని PowerShell కోర్, VMware vSphere PowerCLI, Azure PowerShell, MS ఎక్స్ఛేంజ్, డిజైర్డ్ స్టేట్ కాన్ఫిగరేషన్ రూపంలో మాత్రమే ఎదుర్కోవచ్చు. పవర్‌షెల్ వెబ్ యాక్సెస్ మరియు డజను లేదా అంతకంటే ఎక్కువ అరుదుగా ఉపయోగించే ప్రోగ్రామ్‌లు మరియు విధులు. బహుశా అతను విడుదలతో రెండవ గాలిని పొందుతాడు WSL2, కానీ అది సరిగ్గా లేదు.

పవర్‌షెల్‌కు మూడు పెద్ద ప్రయోజనాలు కూడా ఉన్నాయి:

1. ఇది చాలా సులభం, దాని గురించి చాలా సాహిత్యం మరియు ఉదాహరణలు ఉన్నాయి మరియు రష్యన్ భాషలో కూడా, ఉదాహరణకు, Foreach గురించి ఒక వ్యాసం - పుస్తకం నుండి లోతులో PowerShell - తేడా గురించి () మరియు {}
2. అతను ఎడిటర్‌తో వెళ్తాడు ISE, Windows తో చేర్చబడింది. అక్కడ ఒక రకమైన డీబగ్గర్ కూడా ఉంది.
3. దాని నుండి కాల్ చేయడం సులభం గ్రాఫికల్ ఇంటర్‌ఫేస్‌ను నిర్మించడానికి భాగాలు.

0. తయారీ.

మాకు అవసరం:

• Windows PC (నా దగ్గర Windows 10 ఉంది)
• కనీసం కొంత రకమైన ఇంటర్నెట్ యాక్సెస్ (ఉదాహరణకు NAT ద్వారా)
• టెలిగ్రామ్‌కు పరిమిత ప్రాప్యత ఉన్నవారికి - బ్రౌజర్‌లో ఫ్రీగేట్‌ని ఇన్‌స్టాల్ చేసి కాన్ఫిగర్ చేసి, కొన్ని కష్టమైన సందర్భాల్లో, సింపుల్ DNS క్రిప్ట్‌తో కలిపి
• మీ ఫోన్‌లో టెలిగ్రామ్ క్లయింట్ పని చేస్తోంది
• చాలా ప్రాథమిక అంశాలను అర్థం చేసుకోవడం - వేరియబుల్, అర్రే, లూప్ అంటే ఏమిటి.

కథనాలను తెరిచి చదవండి - సూచనలు: టెలిగ్రామ్‌లో బాట్‌లను ఎలా సృష్టించాలి и సిస్టమ్ అడ్మినిస్ట్రేటర్ కోసం టెలిగ్రామ్ బాట్

1. మరొక టెస్ట్ బాట్‌ని క్రియేట్ చేద్దాం.

ప్రతి ఒక్కరికి ఇది ఇప్పటికే తెలుసు మరియు ఇప్పటికే జరిగింది కాబట్టి, మీరు దీన్ని దాటవేయవచ్చుపై కథనంలో చెప్పినట్లుగా - ముందుగా, టెలిగ్రామ్ కోసం ఒక బాట్ - ఇది ఇప్పటికీ మీ వైపు నడుస్తున్న అప్లికేషన్ మరియు టెలిగ్రామ్ బాట్ APIకి అభ్యర్థనలు చేస్తోంది. అంతేకాకుండా, API స్పష్టంగా ఉంది - బోట్ నిర్దిష్ట URLని పారామితులతో యాక్సెస్ చేస్తుంది మరియు టెలిగ్రామ్ JSON ఆబ్జెక్ట్‌తో ప్రతిస్పందిస్తుంది.

సంబంధిత సమస్యలు: ఏదో తెలియని మార్గంలో మీరు JSON ఆబ్జెక్ట్ నుండి కొంత కోడ్‌ని తీసుకుని, దానిని అమలు కోసం పంపితే (ఉద్దేశపూర్వకంగా కాదు), కోడ్ మీ కోసం అమలు చేయబడుతుంది.

సృష్టి ప్రక్రియ పైన రెండు కథనాలలో వివరించబడింది, కానీ నేను పునరావృతం చేస్తున్నాను: టెలిగ్రామ్‌లో మేము పరిచయాలను తెరుస్తాము, @botfather కోసం వెతుకుతాము, అతనికి చెప్పండి /న్యూబోట్, Botfortest12344321 బోట్‌ను సృష్టించండి, దీనికి Mynext1234bot అని కాల్ చేయండి మరియు దాని యొక్క ప్రత్యేక కీతో సందేశాన్ని అందుకుంటాము. ఫారమ్ 1234544311:AbcDefNNNNNNNNNNNNNN

కీని జాగ్రత్తగా చూసుకోండి మరియు దానిని ఇవ్వవద్దు!

అప్పుడు మీరు బోట్‌ను కాన్ఫిగర్ చేయవచ్చు, ఉదాహరణకు, దానిని సమూహాలకు జోడించడాన్ని నిషేధించండి, కానీ మొదటి దశల్లో ఇది అవసరం లేదు.

“/mybot” కోసం BotFatherని అడుగుదాం మరియు మనకు ఏదైనా నచ్చకపోతే సెట్టింగ్‌లను సర్దుబాటు చేద్దాం.

పరిచయాలను మళ్లీ తెరవండి, అక్కడ @Botfortest12344321ని కనుగొనండి (@తో శోధనను ప్రారంభించడం తప్పనిసరి), "ప్రారంభించు" క్లిక్ చేసి, "/Glory to the robots" అని బోట్‌కు వ్రాయండి. / గుర్తు అవసరం, కోట్స్ అవసరం లేదు.
బోట్, వాస్తవానికి, దేనికీ సమాధానం ఇవ్వదు.

బాట్ సృష్టించబడిందో లేదో తనిఖీ చేసి, దాన్ని తెరవండి.

api.telegram.org/bot1234544311:AbcDefNNNNNNNNNNNNN/getMe
ఇక్కడ 1234544311:AbcDefNNNNNNNNNNNNN అనేది గతంలో అందుకున్న కీ,
మరియు వంటి లైన్ పొందండి
{"సరే":నిజం,"ఫలితం":{""}}

మనకు మొదటి రహస్య పదబంధం (టోకెన్) ఉంది. ఇప్పుడు మనం రెండవ రహస్య సంఖ్యను కనుగొనాలి - బోట్‌తో చాట్ యొక్క ID. ప్రతి చాట్, సమూహం మొదలైనవి వ్యక్తిగతమైనవి మరియు దాని స్వంత సంఖ్యను కలిగి ఉంటాయి (కొన్నిసార్లు మైనస్‌తో - బహిరంగ సమూహాలకు). ఈ సంఖ్యను కనుగొనడానికి, మేము బ్రౌజర్‌లో అభ్యర్థించాలి (వాస్తవానికి, ఇది బ్రౌజర్‌లో అస్సలు అవసరం లేదు, కానీ మంచి అవగాహన కోసం మీరు దానితో ప్రారంభించవచ్చు) చిరునామా (ఇక్కడ 1234544311:NNNNNNNNNN మీ టోకెన్

https://api.telegram.org/bot1234544311:NNNNNNNNN/getUpdates

మరియు వంటి ప్రతిస్పందనను పొందండి

{"ok":true,"result":[{"update_id":...,... చాట్":{"id":123456789

మాకు chat_id అవసరం.

మనం చాట్‌కు మాన్యువల్‌గా వ్రాయగలమో లేదో తనిఖీ చేద్దాం: బ్రౌజర్ నుండి చిరునామాకు కాల్ చేయండి

https://api.telegram.org/botваштокен/sendMessage?chat_id=123456789&text="Life is directed motion"

మీరు మీ చాట్‌లోని బాట్ నుండి సందేశాన్ని స్వీకరించినట్లయితే, సరే, మీరు తదుపరి దశకు వెళ్లండి.

ఈ విధంగా (బ్రౌజర్ ద్వారా) మీరు లింక్ జనరేషన్‌లో సమస్యలు ఉన్నాయా లేదా ఏదైనా ఎక్కడో దాచబడి పని చేయకపోతే ఎల్లప్పుడూ తనిఖీ చేయవచ్చు.

చదవడం కొనసాగించే ముందు మీరు తెలుసుకోవలసినది

టెలిగ్రామ్‌లో అనేక రకాల గ్రూప్ చాట్‌లు ఉన్నాయి (ఓపెన్, క్లోజ్డ్). ఈ చాట్‌ల కోసం, కొన్ని ఫంక్షన్‌లు (ఉదాహరణకు, id) భిన్నంగా ఉంటాయి, ఇది కొన్నిసార్లు కొన్ని సమస్యలను కలిగిస్తుంది.

ఇది 2019 ముగింపు అని అనుకుందాం మరియు మన కాలపు హీరో కూడా, సుప్రసిద్ధ మ్యాన్-ఆర్కెస్ట్రా (నిర్వాహకుడు, లాయర్, ఇన్ఫర్మేషన్ సెక్యూరిటీ స్పెషలిస్ట్, ప్రోగ్రామర్ మరియు ఆచరణాత్మకంగా MVP) Evgeniy V. $i వేరియబుల్‌ని శ్రేణి నుండి వేరు చేస్తుంది, ఉచ్చులు స్వావలంబన ఉంది, సంవత్సరాల తదుపరి జంట లో చూడండి చాక్లెట్ మాస్టర్, ఆపై పవర్‌షెల్‌తో సమాంతర ప్రాసెసింగ్ и ప్రతి వస్తువు సమాంతరంగా అది వస్తుంది.

1. మా బోట్ ఏమి చేస్తుందో మేము ఆలోచిస్తాము

నాకు ఏ ఆలోచనలు లేవు, నేను ఆలోచించవలసి వచ్చింది. నేను ఇప్పటికే బోట్-నోట్‌బుక్ వ్రాసాను. నేను "ఎక్కడో ఏదో పంపే" బాట్‌ను తయారు చేయాలనుకోలేదు. Azureకి కనెక్ట్ చేయడానికి మీకు క్రెడిట్ కార్డ్ అవసరం, కానీ విద్యార్థి దానిని ఎక్కడ నుండి పొందుతాడు? ప్రతిదీ అంత చెడ్డది కాదని గమనించాలి: ప్రధాన మేఘాలు ఒక రకమైన పరీక్ష వ్యవధిని ఉచితంగా ఇస్తాయి (కానీ మీకు ఇంకా క్రెడిట్ కార్డ్ నంబర్ అవసరం - మరియు దాని నుండి డాలర్ డెబిట్ చేయబడినట్లు అనిపిస్తుంది. నాకు గుర్తు లేదు అది తరువాత తిరిగి ఇవ్వబడింది.)

AI ML లేకుండా బోట్-పూర్-కవి-వీవర్‌ను తయారు చేయడం అంత ఆసక్తికరంగా లేదు.

డిక్షనరీలోని ఆంగ్ల పదాలను నాకు గుర్తు చేసే (లేదా నాకు కాదు) బాట్‌ని రూపొందించాలని నిర్ణయించుకున్నాను.
డేటాబేస్‌తో ఫిడ్లింగ్‌ను నివారించడానికి, నిఘంటువు టెక్స్ట్ ఫైల్‌లో నిల్వ చేయబడుతుంది మరియు మానవీయంగా నవీకరించబడుతుంది.
ఈ సందర్భంలో, పని యొక్క ప్రాథమికాలను చూపించడమే పని, మరియు కనీసం పాక్షికంగా పూర్తయిన ఉత్పత్తిని తయారు చేయకూడదు.

2. మొదటి సారి ఏమి మరియు ఎలా ప్రయత్నిస్తున్నారు

C:poshtranslate ఫోల్డర్‌ని క్రియేట్ చేద్దాం
ముందుగా, మనకు ఎలాంటి పవర్‌షెల్ ఉందో చూద్దాం, స్టార్ట్-రన్ ద్వారా ISEని ప్రారంభిద్దాం
పవర్‌షెల్ ise
లేదా ఇన్‌స్టాల్ చేసిన ప్రోగ్రామ్‌లలో పవర్‌షెల్ ISEని కనుగొనండి.
ప్రారంభించిన తర్వాత, సాధారణంగా తెలిసిన “ఒక రకమైన ఎడిటర్” తెరవబడుతుంది; టెక్స్ట్ ఫీల్డ్ లేకపోతే, మీరు ఎల్లప్పుడూ “ఫైల్ - కొత్తదాన్ని సృష్టించు” క్లిక్ చేయవచ్చు.

పవర్‌షెల్ యొక్క సంస్కరణను చూద్దాం - టెక్స్ట్ ఫీల్డ్‌లో వ్రాయండి:

get-host 

మరియు F5 నొక్కండి.

పవర్‌షెల్ సేవ్ చేయడానికి ఆఫర్ చేస్తుంది - “మీరు అమలు చేయబోతున్న స్క్రిప్ట్ సేవ్ చేయబడుతుంది.”, మేము అంగీకరిస్తాము మరియు పవర్‌షెల్ నుండి ఫైల్‌ను C: poshtranslate పేరుతో సేవ్ చేయండి myfirstbotBT100.

ప్రారంభించిన తర్వాత, దిగువ టెక్స్ట్ విండోలో మనకు డేటా టేబుల్ వస్తుంది:

Name             : Windows PowerShell ISE Host
Version          : 5.1.(и так далее)

నా దగ్గర 5.1 ఏదో ఉంది, అది సరిపోతుంది. మీరు పాత Windows 7/8ని కలిగి ఉన్నట్లయితే, పెద్ద విషయం ఏమీ లేదు - అయినప్పటికీ PowerShell సంస్కరణ 5కి నవీకరించబడాలి - ఉదా. సూచనలను.

దిగువ కమాండ్ లైన్‌లో Get-Date టైప్ చేయండి, ఎంటర్ నొక్కండి, సమయాన్ని చూడండి, ఆదేశంతో రూట్ ఫోల్డర్‌కి వెళ్లండి
cd
మరియు cls కమాండ్‌తో స్క్రీన్‌ను క్లియర్ చేయండి (లేదు, మీరు rm ఉపయోగించాల్సిన అవసరం లేదు)

ఇప్పుడు ఏమి పనిచేస్తుందో మరియు ఎలా పనిచేస్తుందో తనిఖీ చేద్దాం - కోడ్‌ని కూడా కాకుండా రెండు పంక్తులు వ్రాస్దాం మరియు వారు ఏమి చేస్తారో అర్థం చేసుకోవడానికి ప్రయత్నించండి. # గుర్తుతో గెట్-హోస్ట్‌తో లైన్‌ను వ్యాఖ్యానించండి మరియు కొద్దిగా జోడించండి.

# Пример шаблона бота 
# get-host
<# это пример многострочного комментария #>
$TimeNow = Get-Date
$TimeNow

(ఆసక్తికరమైన విషయం ఏమిటంటే, హబ్రేలో కోడ్ ఫార్మాటింగ్ డ్రాప్-డౌన్ జాబితాలో రెండు డజన్ల ఎంపికలు ఉన్నాయి - కానీ పవర్‌షెల్ లేదు. డాస్ ఉంది. పెర్ల్ ఉంది.)

మరియు GUI నుండి F5 లేదా ">" నొక్కడం ద్వారా కోడ్‌ని అమలు చేద్దాం.

మేము అవుట్పుట్ పొందుతాము:

Saturday, December 8, 2019 21:00:50 PM (или что-то типа)

ఇప్పుడు ఈ రెండు పంక్తులు మరియు కొన్ని ఆసక్తికరమైన అంశాలను చూద్దాం, తద్వారా మనం భవిష్యత్తులో దీనికి తిరిగి రాము.

పాస్కల్ (మరియు మాత్రమే కాదు), పవర్‌షెల్ స్వయంగా వేరియబుల్‌కు ఏ రకాన్ని కేటాయించాలో నిర్ణయించడానికి ప్రయత్నిస్తుంది; దీని గురించి మరిన్ని వివరాలు వ్యాసంలో వ్రాయబడ్డాయి ప్రోగ్రామింగ్ భాషలలో టైప్ చేయడంపై విద్యా కార్యక్రమం
అందువల్ల, $TimeNow వేరియబుల్‌ని సృష్టించి, దానికి ప్రస్తుత తేదీ మరియు సమయం (గెట్-డేట్) విలువను కేటాయించడం ద్వారా, అక్కడ ఏ రకమైన డేటా ఉంటుందనే దాని గురించి మనం పెద్దగా ఆందోళన చెందాల్సిన అవసరం లేదు.

నిజమే, ఈ అజ్ఞానం తరువాత బాధించవచ్చు, కానీ అది తరువాత కోసం. దిగువ వచనంలో ఒక ఉదాహరణ ఉంటుంది.
మనకు ఏమి లభించిందో చూద్దాం. అమలు చేద్దాం (కమాండ్ లైన్‌లో)

$TimeNow | Get-member

మరియు అపారమయిన వచనం యొక్క పేజీని పొందండి

అపారమయిన వచన సంఖ్య 1కి ఉదాహరణ

PS C:> $TimeNow | Get-member
   TypeName: System.DateTime
Name                 MemberType     Definition                                                                                                                                       
----                 ----------     ----------                                                                                                                                       
Add                  <b>Method         </b>datetime Add(timespan value)  
..
DisplayHint          NoteProperty   DisplayHintType DisplayHint=DateTime                                                                                                             
Date                 <b>Property       </b>datetime Date {get;}                                                                                                                             
Year                 Property       int Year {get;}   
..                                                                                                                               
DateTime             ScriptProperty System.Object DateTime {get=if ((& { Set-StrictMode -Version 1; $this.DisplayHint }) -ieq  "Date")...                                         

మీరు చూడగలిగినట్లుగా, టైప్ నేమ్ టైప్ యొక్క వేరియబుల్: System.DateTime అనేక పద్ధతులతో (ఈ వేరియబుల్ ఆబ్జెక్ట్‌తో మనం ఏమి చేయగలం అనే అర్థంలో) మరియు లక్షణాలతో సృష్టించబడింది.

పిలుద్దాం $TimeNow.DayOfYear - మేము సంవత్సరం రోజు సంఖ్యను పొందుతాము.
పిలుద్దాం $TimeNow.DayOfYear | Get-Member - మాకు దొరికింది TypeName: System.Int32 మరియు పద్ధతుల సమూహం.
పిలుద్దాం $TimeNow.ToUniversalTime() - మరియు UTCలో సమయాన్ని పొందండి

డీబగ్గర్

కొన్నిసార్లు ఇది ఒక నిర్దిష్ట లైన్ వరకు ప్రోగ్రామ్‌ను అమలు చేయడం మరియు ఆ సమయంలో ప్రోగ్రామ్ యొక్క స్థితిని చూడటం అవసరం. ఈ ప్రయోజనం కోసం, ISE డీబగ్ ఫంక్షన్‌ను కలిగి ఉంది - టోగుల్ బ్రేక్ పాయింట్
మధ్యలో ఎక్కడో బ్రేక్ పాయింట్ ఉంచండి, ఈ రెండు పంక్తులను రన్ చేసి, బ్రేక్ ఎలా ఉందో చూడండి.

3. టెలిగ్రామ్ బాట్‌తో పరస్పర చర్యను అర్థం చేసుకోవడం

వాస్తవానికి, బోట్‌తో పరస్పర చర్యపై, అన్ని గెట్‌పుష్‌లతో పాటు మరిన్ని సాహిత్యాలు వ్రాయబడ్డాయి, అయితే సిద్ధాంత సమస్యను ఐచ్ఛికంగా పరిగణించవచ్చు.

మా విషయంలో ఇది అవసరం:

• కరస్పాండెన్స్‌లో ఏదైనా పంపడం నేర్చుకోండి
• కరస్పాండెన్స్ నుండి ఏదైనా పొందడం నేర్చుకోండి

3.1 కరస్పాండెన్స్‌లో ఏదైనా పంపడం మరియు దాని నుండి స్వీకరించడం నేర్చుకోవడం

చిన్న కోడ్ - పార్ట్ 3

Write-output "This is part 3"
$MyToken = "1234544311:AbcDefNNNNNNNNNNNNN"
$MyChatID = "123456789"
$MyProxy = "http://1.2.3.4:5678" 

$TimeNow = Get-Date
$TimeNow.ToUniversalTime()
$ScriptDir = Split-Path $script:MyInvocation.MyCommand.Path
$BotVersion = "BT102"

$MyText01 = "Life is directed motion - " + $TimeNow

$URL4SEND = "https://api.telegram.org/bot$MyToken/sendMessage?chat_id=$MyChatID&text=$MyText01"

Invoke-WebRequest -Uri $URL4SEND

మరియు రష్యన్ ఫెడరేషన్‌లో ఈ సమయంలో మేము లోపాన్ని పొందుతాము రిమోట్ సర్వర్‌కు కనెక్ట్ చేయడం సాధ్యం కాదు.

లేదా మేము దానిని స్వీకరించలేము - టెలికాం ఆపరేటర్ మరియు ప్రాక్సీ కాన్ఫిగర్ చేయబడి పని చేస్తుందా అనే దానిపై ఆధారపడి ఉంటుంది
సరే, ప్రాక్సీని జోడించడమే మిగిలి ఉంది. ఎన్‌క్రిప్ట్ చేయని మరియు సాధారణంగా మోసపూరిత ప్రాక్సీని ఉపయోగించడం మీ ఆరోగ్యానికి అత్యంత ప్రమాదకరమని దయచేసి గమనించండి.

పని చేసే ప్రాక్సీని కనుగొనే పని చాలా కష్టం కాదు - ప్రచురించిన చాలా http ప్రాక్సీలు పని చేస్తాయి. ఐదవది నాకు పని చేస్తుందని నేను అనుకుంటున్నాను.

ప్రాక్సీని ఉపయోగించి సింటాక్స్:

Invoke-WebRequest -Uri $URL4SEND -Proxy $MyProxy

మీరు బోట్‌తో మీ చాట్‌లో సందేశాన్ని స్వీకరిస్తే, అంతా బాగానే ఉంది, మీరు కొనసాగవచ్చు. కాకపోతే, డీబగ్గింగ్ కొనసాగించండి.

మీరు మీ $URL4SEND స్ట్రింగ్ ఎలా మారుతుందో చూడవచ్చు మరియు బ్రౌజర్‌లో దీన్ని అభ్యర్థించడానికి ప్రయత్నించండి, ఇలా:

$URL4SEND2 = '"'+$URL4SEND+'"'
start chrome $URL4SEND2 

3.2 చాట్‌లో "ఏదో" ఎలా వ్రాయాలో మేము నేర్చుకున్నాము, ఇప్పుడు దానిని చదవడానికి ప్రయత్నిద్దాం

మరో 4 పంక్తులను జోడించి, లోపల ఏముందో చూద్దాం | సభ్యునిగా పొందండి

$URLGET = "https://api.telegram.org/bot$MyToken/getUpdates"
$MyMessageGet = Invoke-WebRequest -Uri $URLGET -Method Get -Proxy $MyProxy
Write-Host "Get-Member"
$MyMessageGet | Get-Member

అత్యంత ఆసక్తికరమైన విషయం మాకు అందించబడింది

Content           Property   string Content {get;}  
ParsedHtml        Property   mshtml.IHTMLDocument2 ParsedHtml {get;}                                    
RawContent        Property   string RawContent {get;set;}

వాటిలో ఏముందో చూద్దాం:

Write-Host "ParsedHtml"
$MyMessageGet.ParsedHtml # тут интересное
Write-Host "RawContent"
$MyMessageGet.RawContent # и тут интересное, но еще к тому же и читаемое. 
Write-Host "Content"
$MyMessageGet.Content

ప్రతిదీ మీ కోసం పని చేస్తే, మీరు లాంగ్ లైన్‌ని పొందుతారు:

{"ok":true,"result":[{"update_id":12345678,
"message":{"message_id":3,"from":{"id"

అదృష్టవశాత్తూ, సిస్టమ్ అడ్మినిస్ట్రేటర్ కోసం గతంలో ప్రచురించిన టెలిగ్రామ్ బాట్ కథనంలో ఈ లైన్ (అవును, $MyMessageGet.RawContent | ప్రకారం గెట్-మెంబర్ అనేది System.String), ఇప్పటికే విడదీయబడింది.

4. మీరు స్వీకరించిన వాటిని ప్రాసెస్ చేయండి (ఏదైనా ఎలా పంపాలో మాకు ఇప్పటికే తెలుసు)

ఇప్పటికే వ్రాసినట్లు ఇక్కడ, అత్యంత అవసరమైన విషయాలు కంటెంట్‌లో ఉంటాయి. దానిని నిశితంగా పరిశీలిద్దాం.

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

/message1
/message2
/message3

మరియు బ్రౌజర్ ద్వారా $URLGET వేరియబుల్‌లో ఏర్పడిన చిరునామాను చూడండి.

మేము ఇలాంటివి చూస్తాము:

{"ok":true,"result":[{"update_id":NNNNNNN,
"message":{"message_id":10, .. "text":"/message1"
"message":{"message_id":11, .. "text":"/message2 
"message":{"message_id":12, .. "text":"/message3 

అదేంటి? ఎండ్-టు-ఎండ్ మెసేజ్ ఐడెంటిఫైయర్, చాట్ ఐడెంటిఫైయర్, సెండింగ్ ఐడెంటిఫైయర్ మరియు చాలా ఇతర సమాచారాన్ని కలిగి ఉన్న వస్తువుల శ్రేణుల నుండి కొంత క్లిష్టమైన వస్తువు.

అయినప్పటికీ, “ఇది ఎలాంటి వస్తువు” అని మనం గుర్తించాల్సిన అవసరం లేదు - పనిలో కొంత భాగం ఇప్పటికే మన కోసం పూర్తి చేయబడింది. లోపల ఏముందో చూద్దాం:

అందుకున్న సందేశాలు లేదా పార్ట్ 4 చదవడం

Write-Host "This is part 4" <# конечно эта строка нам не нужна в итоговом тексте, но по ней удобно искать. #> 

$Content4Pars01 = ConvertFrom-Json $MyMessageGet.Content
$Content4Pars01 | Get-Member
$Content4Pars01.result
$Content4Pars01.result[0]
$Content4Pars01.result[0] | Get-Member
$Content4Pars01.result[0].update_id
$Content4Pars01.result[0].message
$Content4Pars01.result[0].message.text
$Content4Pars01.result[1].message.text
$Content4Pars01.result[2].message.text

5. దాని గురించి మనం ఇప్పుడు ఏమి చేయాలి?

ఫలితంగా వచ్చిన ఫైల్‌ను myfirstbotBT105 పేరుతో లేదా మీకు బాగా నచ్చిన దానితో సేవ్ చేద్దాం, టైటిల్‌ని మార్చండి మరియు ఇప్పటికే వ్రాసిన కోడ్‌ను దీని ద్వారా వ్యాఖ్యానించండి

<#start comment 105 end comment 105#>

ఇప్పుడు మనం నిఘంటువును ఎక్కడ పొందాలో నిర్ణయించుకోవాలి (బాగా, ఎక్కడ - ఫైల్‌లోని డిస్క్‌లో) మరియు అది ఎలా ఉంటుందో.

అయితే, మీరు స్క్రిప్ట్ యొక్క వచనంలో భారీ నిఘంటువును వ్రాయవచ్చు, కానీ ఇది పూర్తిగా పాయింట్ పక్కన ఉంది.
కాబట్టి, పవర్‌షెల్ సాధారణంగా పని చేయగలదో చూద్దాం.
సాధారణంగా, అతను ఏ ఫైల్తో పని చేయాలో పట్టించుకోడు, అది మాకు పట్టింపు లేదు.
మాకు ఎంపిక ఉంది: txt (మీరు చేయగలరు, కానీ ఎందుకు), csv, xml.
అందరినీ చూడగలమా?అందరినీ చూద్దాం.
క్లాస్ MyVocabClassExample1 మరియు వేరియబుల్ $MyVocabExample1ని సృష్టిద్దాం
తరగతి $ లేకుండా వ్రాయబడిందని నేను గమనించాను

కొన్ని కోడ్ #5

write-host "This is part 5"
class MyVocabClassExample1 {
    [string]$Original  # слово
    [string]$Transcript
    [string]$Translate
    [string]$Example
    [int]$VocWordID # очень интересный момент. Использование int с его ограничениями может порой приводить к диким последствиям, для примера - недавний случай с SSD HPE. Изначально я не стал добавлять этот элемент, потом все же дописал и закомментировал.
    }

$MyVocabExample1 = [MyVocabClassExample1]::new()
$MyVocabExample1.Original = "Apple"
$MyVocabExample1.Transcript = "[ ˈapəl ]"
$MyVocabExample1.Translate = "Яблоко"
$MyVocabExample1.Example = "An apple is a sweet, edible fruit produced by an apple tree (Malus domestica)"
# $MyVocabExample1.$VocWordID = 1

$MyVocabExample2 = [MyVocabClassExample1]::new()
$MyVocabExample2.Original = "Pear"
$MyVocabExample2.Transcript = "[ pe(ə)r ]"
$MyVocabExample2.Translate = "Груша"
$MyVocabExample2.Example = "The pear (/ˈpɛər/) tree and shrub are a species of genus Pyrus"
# $MyVocabExample1.$VocWordID = 2

దీన్ని ఉపయోగించి ఫైల్‌లలో వ్రాయడానికి ప్రయత్నిద్దాం నమూనా.

కొన్ని కోడ్ #5.1

Write-Host $ScriptDir # надеюсь $ScriptDir вы не закомментировали 
$MyFilenameExample01 = $ScriptDir + "Example01.txt"
$MyFilenameExample02 = $ScriptDir + "Example02.txt"
Write-Host $MyFilenameExample01
Out-File  -FilePath $MyFilenameExample01 -InputObject $MyVocabExample1

Out-File  -FilePath $MyFilenameExample01 -InputObject -Append $MyVocabExample2
notepad $MyFilenameExample01

- మరియు మేము Out-File -FilePath $MyFilenameExample01 -InputObject -Append $MyVocabExample2 లైన్‌లో ఎర్రర్‌ను పొందుతాము.

అతను జోడించడానికి ఇష్టపడడు, అయ్యో, ఎంత అవమానకరం.

$MyVocabExample3AsArray = @($MyVocabExample1,$MyVocabExample2)
Out-File  -FilePath $MyFilenameExample02 -InputObject $MyVocabExample3AsArray
notepad $MyFilenameExample02

చూద్దాం ఏం జరుగుతుందో. గొప్ప వచన వీక్షణ - అయితే దాన్ని తిరిగి ఎగుమతి చేయడం ఎలా? నేను కామాల వంటి కొన్ని రకాల టెక్స్ట్ సెపరేటర్‌లను పరిచయం చేయాలా?

మరియు చివరికి మీరు “కామాతో వేరు చేయబడిన విలువలు (CSV) ఫైల్ Aని పొందుతారు ఆగండి.
#

$MyFilenameExample03 = $ScriptDir + "Example03.csv"
$MyFilenameExample04 = $ScriptDir + "Example04.csv"
Export-Csv  -Path $MyFilenameExample03 -InputObject $MyVocabExample1 
Export-Csv  -Path $MyFilenameExample03 -InputObject $MyVocabExample2 -Append 
Export-Csv  -Path $MyFilenameExample04 -InputObject $MyVocabExample3AsArray 

చూడటం తేలికగా, MS దాని తర్కం ద్వారా ప్రత్యేకంగా గుర్తించబడదు; ఇదే విధమైన ప్రక్రియ కోసం, ఒక సందర్భంలో -FilePath ఉపయోగించబడుతుంది, మరొకటి -Path.

అదనంగా, మూడవ ఫైల్‌లో రష్యన్ భాష అదృశ్యమైంది, నాల్గవ ఫైల్‌లో అది తేలింది ... బాగా, ఏదో జరిగింది. #TYPE System.Object[] 00
# “కౌంట్”,”పొడవు”,”లాంగ్ లెంగ్త్”,”ర్యాంక్”,”SyncRoot”,”ReadOnly”,”IsFixedSize”,”Synchronized”
#
దీన్ని కొద్దిగా తిరిగి వ్రాద్దాం:

Export-Csv  -Path $MyFilenameExample03 -InputObject $MyVocabExample1 -Encoding Unicode
Export-Csv  -Path $MyFilenameExample03 -InputObject $MyVocabExample2 -Append -Encoding Unicode
notepad $MyFilenameExample03
notepad $MyFilenameExample04

ఇది సహాయం చేసినట్లు అనిపిస్తుంది, కానీ నాకు ఇప్పటికీ ఫార్మాట్ నచ్చలేదు.

నేను ఆబ్జెక్ట్ నుండి లైన్‌లను నేరుగా ఫైల్‌లో ఉంచలేను అని నేను ప్రత్యేకంగా ఇష్టపడను.
మార్గం ద్వారా, మేము ఫైల్‌లకు రాయడం ప్రారంభించినప్పటి నుండి, స్టార్టప్ లాగ్‌ను ఉంచడం ప్రారంభించవచ్చా? మనకు వేరియబుల్‌గా సమయం ఉంది, మనం ఫైల్ పేరును సెట్ చేయవచ్చు.

నిజమే, ఇంకా వ్రాయడానికి ఏమీ లేదు, కానీ మీరు లాగ్లను ఎలా ఉత్తమంగా తిప్పాలనే దాని గురించి ఆలోచించవచ్చు.
ప్రస్తుతానికి xmlని ప్రయత్నిద్దాం.

కొన్ని xml

$MyFilenameExample05 = $ScriptDir + "Example05.xml"
$MyFilenameExample06 = $ScriptDir + "Example06.xml"
Export-Clixml  -Path $MyFilenameExample05 -InputObject $MyVocabExample1 
Export-Clixml  -Path $MyFilenameExample05 -InputObject $MyVocabExample2 -Append -Encoding Unicode
Export-Clixml  -Path $MyFilenameExample06 -InputObject $MyVocabExample3AsArray
notepad $MyFilenameExample05
notepad $MyFilenameExample06

xmlకి ఎగుమతి చేయడం వల్ల అనేక ప్రయోజనాలు ఉన్నాయి - చదవగలిగే సామర్థ్యం, ​​మొత్తం వస్తువు యొక్క ఎగుమతి మరియు అప్పెండ్ చేయవలసిన అవసరం లేదు.

ప్రయత్నిద్దాం xml ఫైల్ చదవండి.

xml నుండి కొద్దిగా చదవడం

$MyFilenameExample06 = $ScriptDir + "Example06.xml"
$MyVocabExample4AsArray = Import-Clixml -Path $MyFilenameExample06
# $MyVocabExample4AsArray 
# $MyVocabExample4AsArray[0]
# и немного о совершенно неочевидных нюансах. Powershell время от времени ведет себя не так, как вроде бы как бы стоило бы ожидать бы.
# например у меня эти два вывода отличаются
# Write-Output $MyVocabExample4AsArray 
# write-host $MyVocabExample4AsArray 

పనికి తిరిగి వెళ్దాం. మేము ఒక పరీక్ష ఫైల్‌ను వ్రాసాము, దానిని చదవండి, నిల్వ ఆకృతి స్పష్టంగా ఉంది, అవసరమైతే, మీరు పంక్తులను జోడించడానికి మరియు తొలగించడానికి ప్రత్యేక చిన్న ఫైల్ ఎడిటర్‌ను వ్రాయవచ్చు.

చిన్న శిక్షణ బోట్‌ను తయారు చేయడమే పని అని నేను మీకు గుర్తు చేస్తాను.

పని ఆకృతి: నేను బోట్‌కి “ఉదాహరణ” ఆదేశాన్ని పంపుతాను, బోట్ నాకు యాదృచ్ఛికంగా ఎంచుకున్న పదం మరియు లిప్యంతరీకరణను పంపుతుంది మరియు 10 సెకన్ల తర్వాత నాకు అనువాదం మరియు వ్యాఖ్యను పంపుతుంది. ఆదేశాలను ఎలా చదవాలో మాకు తెలుసు, ప్రాక్సీలను స్వయంచాలకంగా ఎలా ఎంచుకోవాలి మరియు తనిఖీ చేయాలి మరియు మెసేజ్ కౌంటర్‌లను ఉపేక్షకు రీసెట్ చేయడం ఎలాగో కూడా మేము తెలుసుకోవాలనుకుంటున్నాము.

మునుపు అనవసరంగా వ్యాఖ్యానించిన ప్రతిదాన్ని అన్‌కామెంట్ చేద్దాం, ఇప్పుడు అనవసరమైన ఉదాహరణలను txt మరియు csvతో వ్యాఖ్యానించండి మరియు ఫైల్‌ను వెర్షన్ B106గా సేవ్ చేయండి

ఆ అవును. మళ్లీ బోట్‌కి ఏదైనా పంపుదాం.

6. ఫంక్షన్లు మరియు మరిన్నింటి నుండి పంపండి

రిసెప్షన్‌ను ప్రాసెస్ చేయడానికి ముందు, మీరు పరీక్ష సందేశం కాకుండా "కనీసం ఏదైనా" పంపడం కోసం ఒక ఫంక్షన్‌ను సృష్టించాలి.

వాస్తవానికి, ఉదాహరణలో మనకు ఒకే పంపడం మరియు ఒక ప్రాసెసింగ్ మాత్రమే ఉంటుంది, అయితే మనం అదే పనిని చాలాసార్లు చేయవలసి వస్తే ఏమి చేయాలి?

ఫంక్షన్ రాయడం సులభం. కాబట్టి, మేము ఫైల్ నుండి చదవబడిన $MyVocabExample4AsArray రకం వస్తువు యొక్క వేరియబుల్‌ని కలిగి ఉన్నాము, ఇది రెండు మూలకాల శ్రేణి రూపంలో ఉంటుంది.
చదవడానికి వెళ్దాం.

అదే సమయంలో, మేము గడియారంతో వ్యవహరిస్తాము; మాకు ఇది తరువాత అవసరం (వాస్తవానికి, ఈ ఉదాహరణలో మాకు ఇది అవసరం లేదు :)

కొన్ని కోడ్ #6.1

Write-Output "This is Part 6"
$Timezone = (Get-TimeZone)
IF($Timezone.SupportsDaylightSavingTime -eq $True){
    $TimeAdjust =  ($Timezone.BaseUtcOffset.TotalSeconds + 3600) } # приведенное время
    ELSE{$TimeAdjust = ($Timezone.BaseUtcOffset.TotalSeconds) 
    }
    
function MyFirstFunction($SomeExampleForFunction1){
$TimeNow = Get-Date
$TimeNow.ToUniversalTime()
# $MyText02 = $TimeNow + " " + $SomeExampleForFunction1 # и вот тут мы получим ошибку
$MyText02 = $SomeExampleForFunction1 + " " + $TimeNow # а тут не получим, кто догадается почему - тот молодец.

$URL4SendFromFunction = "https://api.telegram.org/bot$MyToken/sendMessage?chat_id=$MyChatID&text=$MyText02"
Invoke-WebRequest -Uri $URL4SendFromFunction -Proxy $MyProxy
}

మీరు సులభంగా చూడగలిగినట్లుగా, ఫంక్షన్ $MyToken మరియు $MyChatID అని పిలుస్తుంది, ఇవి ఇంతకు ముందు హార్డ్-కోడ్ చేయబడ్డాయి.

దీన్ని చేయవలసిన అవసరం లేదు మరియు ప్రతి బోట్‌కు $MyToken ఒకటి అయితే, చాట్‌ని బట్టి $MyChatID మారుతుంది.

అయితే, ఇది ఒక ఉదాహరణ కాబట్టి, మేము దానిని ప్రస్తుతానికి విస్మరిస్తాము.

$MyVocabExample4AsArray ఒక శ్రేణి కానందున, ఇది ఒకదానితో సమానంగా ఉన్నప్పటికీ, అప్పుడు మీరు దానిని తీసుకోలేరు దాని పొడవును అభ్యర్థించండి.

మరోసారి మనం చేయలేని పనిని చేయవలసి ఉంటుంది - పారాచూట్ కోడ్ ప్రకారం కాదు - దానిని తీసుకొని లెక్కించండి

కొన్ని కోడ్ #6.2

$MaxRandomExample = 0 
foreach ($Obj in $MyVocabExample4AsArray) {
$MaxRandomExample ++
}
Write-Output $MaxRandomExample
$RandomExample = Get-Random -Minimum 0 -Maximum ($MaxRandomExample)
$TextForExample1 = $MyVocabExample4AsArray[$RandomExample].Original
# MyFirstFunction($TextForExample1)
# или в одну строку
# MyFirstFunction($MyVocabExample4AsArray[Get-Random -Minimum 0 -Maximum ($MaxRandomExample -1)].Example)
# Угадайте сами, какой пример легче читается посторонними людьми.

యాధృచ్ఛిక ఆసక్తికరమైన ఫీచర్. మనం 0 లేదా 1ని అందుకోవాలని అనుకుందాం (అరేలో మనకు రెండు మూలకాలు మాత్రమే ఉన్నాయి). సరిహద్దులు 0..1 సెట్ చేసినప్పుడు, మనకు “1” లభిస్తుందా?
లేదు - మేము దానిని పొందలేము, మాకు ప్రత్యేక ఉదాహరణ ఉదాహరణ 2: 0 మరియు 99 గెట్-రాండమ్ -గరిష్టంగా 100 మధ్య యాదృచ్ఛిక పూర్ణాంకాన్ని పొందండి
కాబట్టి, 0..1 కోసం మనం గరిష్ట మూలకం సంఖ్య = 0తో 2..1 పరిమాణాన్ని సెట్ చేయాలి.

7. ఇన్‌కమింగ్ సందేశాల ప్రాసెసింగ్ మరియు గరిష్ట క్యూ పొడవు

ఇంతకు ముందు ఎక్కడ ఆగాము? మేము అందుకున్న వేరియబుల్ $MyMessageGetని కలిగి ఉన్నాము
మరియు దాని నుండి $Content4Pars01 పొందబడింది, వీటిలో మేము Content4Pars01.result శ్రేణిలోని అంశాల పట్ల ఆసక్తి కలిగి ఉన్నాము

$Content4Pars01.result[0].update_id
$Content4Pars01.result[0].message
$Content4Pars01.result[0].message.text

బాట్ /message10, /message11, /message12, /word మరియు మళ్లీ /word మరియు /helloని పంపుదాం.
మనకు ఏమి లభించిందో చూద్దాం:

$Content4Pars01.result[0].message.text
$Content4Pars01.result[2].message.text

అందిన ప్రతిదానిని పరిశీలిద్దాం మరియు సందేశం /పదం అయితే ప్రతిస్పందనను పంపండి
నిర్మాణం విషయంలో, కొందరు if-elseif అని వర్ణించే దానిని పవర్‌షెల్‌లో పిలుస్తారు స్విచ్ ద్వారా. అదే సమయంలో, దిగువ కోడ్ -wildcard కీని ఉపయోగిస్తుంది, ఇది పూర్తిగా అనవసరమైనది మరియు హానికరం కూడా.

కొన్ని కోడ్ #7.1

Write-Output "This is part 7"
Foreach ($Result in $Content4Pars01.result) # Да, можно сделать быстрее 
 { 
    switch -wildcard ($Result.message.text) 
            {
            "/word" {MyFirstFunction($TextForExample1)}
            }
}

స్క్రిప్ట్‌ని రెండుసార్లు రన్ చేద్దాం. ప్రతి అమలు ప్రయత్నానికి మేము ఒకే పదాన్ని రెండుసార్లు పొందుతాము, ప్రత్యేకించి మేము యాదృచ్ఛికంగా అమలు చేయడంలో పొరపాటు చేస్తే.

కానీ ఆపండి. మేము మళ్లీ / పదాన్ని పంపలేదు, కాబట్టి సందేశం మళ్లీ ఎందుకు ప్రాసెస్ చేయబడుతోంది?

బోట్‌కు సందేశాలను పంపే క్యూ పరిమిత పొడవు (100 లేదా 200 సందేశాలు, నేను అనుకుంటున్నాను) మరియు మాన్యువల్‌గా క్లియర్ చేయబడాలి.

ఇది డాక్యుమెంటేషన్‌లో వివరించబడింది, కానీ మీరు దీన్ని చదవాలి!

ఈ సందర్భంలో, మనకు ?chat_id పారామీటర్ అవసరం మరియు &సమయం, &పరిమితి, &parse_mode=HTML మరియు &disable_web_page_preview=true ఇంకా అవసరం లేదు.

కోసం డాక్యుమెంటేషన్ టెలిగ్రామ్ api ఇక్కడ ఉంది
ఇది తెలుపు మరియు ఆంగ్లంలో ఇలా చెబుతోంది:
తిరిగి ఇవ్వాల్సిన మొదటి నవీకరణ యొక్క ఐడెంటిఫైయర్. మునుపు అందుకున్న అప్‌డేట్‌ల ఐడెంటిఫైయర్‌లలో అత్యధికం కంటే ఒకటి ఎక్కువగా ఉండాలి. డిఫాల్ట్‌గా, అప్‌డేట్‌లు ముందుగా ప్రారంభమవుతాయి
ధ్రువీకరించని నవీకరణ తిరిగి ఇవ్వబడింది. గెట్‌అప్‌డేట్‌లకు కాల్ చేసిన వెంటనే అప్‌డేట్ ధృవీకరించబడినదిగా పరిగణించబడుతుంది ఆఫ్సెట్ ఉన్నత దాని update_id కంటే. నవీకరణల క్యూ చివరి నుండి -offset నవీకరణ నుండి ప్రారంభమయ్యే నవీకరణలను తిరిగి పొందేందుకు ప్రతికూల ఆఫ్‌సెట్‌ను పేర్కొనవచ్చు. మునుపటి అప్‌డేట్‌లన్నీ విస్మరించబడతాయి.

చూద్దాం:

$Content4Pars01.result[0].update_id
$Content4Pars01.result[1].update_id 
$Content4Pars01.result | select -last 1
($Content4Pars01.result | select -last 1).update_id

అవును, మరియు మేము దానిని రీసెట్ చేస్తాము మరియు ఫంక్షన్‌ను కొద్దిగా తిరిగి వ్రాస్తాము. మాకు రెండు ఎంపికలు ఉన్నాయి - మొత్తం సందేశాన్ని ఫంక్షన్‌కు పంపండి మరియు దాన్ని పూర్తిగా ఫంక్షన్‌లో ప్రాసెస్ చేయండి లేదా సందేశ IDని మాత్రమే ఇచ్చి దాన్ని రీసెట్ చేయండి. ఉదాహరణకు, రెండవది సరళంగా కనిపిస్తుంది.

గతంలో, మా “అన్ని సందేశాలు” ప్రశ్న స్ట్రింగ్ ఇలా ఉండేది

$URLGET = "https://api.telegram.org/bot$MyToken/getUpdates"

మరియు అది కనిపిస్తుంది

$LastMessageId = ($Content4Pars01.result | select -last 1).update_id
$URLGET1 = "https://api.telegram.org/bot$mytoken/getUpdates?offset=$LastMessageId&limit=100" 
$MyMessageGet = Invoke-WebRequest -Uri $URLGET1 -Method Get -Proxy $MyProxy 

మీరు మొదట అన్ని సందేశాలను స్వీకరించడాన్ని, వాటిని ప్రాసెస్ చేయడాన్ని ఎవరూ నిషేధించరు మరియు విజయవంతమైన ప్రాసెసింగ్ అభ్యర్థన ధృవీకరించబడిన తర్వాత మాత్రమే -> ధృవీకరించబడలేదు.

అన్ని ప్రాసెసింగ్ పూర్తయిన తర్వాత నిర్ధారణకు కాల్ చేయడం ఎందుకు సమంజసం? అమలు మధ్యలో వైఫల్యం సాధ్యమవుతుంది మరియు ఉచిత చాట్‌బాట్ యొక్క ఉదాహరణ కోసం, ఒక సందేశాన్ని కోల్పోవడం ప్రత్యేకంగా ఏమీ లేదు, మీరు ఎవరి జీతం లేదా కార్డ్ లావాదేవీని ప్రాసెస్ చేస్తుంటే, ఫలితం అధ్వాన్నంగా ఉండవచ్చు.

కోడ్ యొక్క రెండు పంక్తులు

$LastMessageId = ($Content4Pars01.result | select -last 1).update_id  #ошибку в этом месте предполагается исправить самостоятельно. 
$URLGET1 = "https://api.telegram.org/bot$mytoken/getUpdates?offset=$LastMessageId&limit=100" 
Invoke-WebRequest -Uri $URLGET1 -Method Get -Proxy $MyProxy

8. ముగింపుకు బదులుగా

ప్రాథమిక విధులు - సందేశాలను చదవడం, క్యూను రీసెట్ చేయడం, ఫైల్ నుండి చదవడం మరియు ఫైల్‌కు వ్రాయడం పూర్తి చేసి చూపబడతాయి.

చేయడానికి కేవలం నాలుగు విషయాలు మాత్రమే మిగిలి ఉన్నాయి:

• చాట్‌లోని అభ్యర్థనకు సరైన సమాధానాన్ని పంపడం
• బాట్ జోడించబడిన ఏదైనా చాట్‌కు ప్రతిస్పందనను పంపడం
• లూప్‌లో కోడ్‌ని అమలు చేయడం
• విండోస్ షెడ్యూలర్ నుండి బాట్‌ను ప్రారంభించడం.

ఈ పనులన్నీ సరళమైనవి మరియు పారామితుల గురించి డాక్యుమెంటేషన్ చదవడం ద్వారా సులభంగా సాధించవచ్చు
సెట్-ఎగ్జిక్యూషన్ పాలసీ అనియంత్రిత మరియు -ఎగ్జిక్యూషన్ పాలసీ బైపాస్
రూపం యొక్క చక్రం

$TimeToSleep = 3 # опрос каждые 3 секунды
$TimeToWork = 10 # минут
$HowManyTimes = $TimeToWork*60/$TimeToSleep # счетчик для цикла
$MainCounter = 0
for ($MainCounter=0; $MainCounter -le $HowManyTimes) {
sleep $TimeToSleep
$MainCounter ++

చదివిన ప్రతి ఒక్కరికీ ధన్యవాదాలు.

మూలం: www.habr.com