Powershell નો ઉપયોગ કરીને ગ્રેડ 7-9 માં શાળાના બાળકો માટે સરળ ટેલિગ્રામ બોટ માટેનો નમૂનો

એક મિત્ર સાથે વાતચીત દરમિયાન, મને અચાનક ખબર પડી કે તેમની શાળામાં ધોરણ 8-10ના બાળકોને પ્રોગ્રામિંગ શીખવવામાં આવતું નથી. વર્ડ, એક્સેલ અને બધું. એક્સેલ માટે કોઈ લોગો નહીં, પાસ્કલ પણ નહીં, VBA પણ નહીં.

મને ખૂબ જ આશ્ચર્ય થયું, ઈન્ટરનેટ ખોલ્યું અને વાંચવાનું શરૂ કર્યું -
વિશિષ્ટ શાળાના કાર્યોમાંનું એક નવી પેઢીના શિક્ષણને પ્રોત્સાહન આપવાનું છે જે તેના વિકાસ અને જીવનશૈલીના સ્તરમાં માહિતી સમાજની શરતોને પૂર્ણ કરે છે.
આ અભ્યાસક્રમ વિદ્યાર્થીઓને પાસ્કલ પ્રોગ્રામિંગ ભાષાની મૂળભૂત રચનાઓ વિશેના તેમના જ્ઞાનને વ્યવહારમાં એકીકૃત કરવાની મંજૂરી આપશે. (2017 માટે અમુક વ્યાયામશાળાના કાર્યક્રમમાંથી)

અંતે, મેં થોડા કલાકો ગાળવાનું નક્કી કર્યું અને "શાળાના બાળકો માટે એક સરળ બૉટ કેવી રીતે બનાવવો" તેનું ઉદાહરણ સ્કેચ કર્યું.

કટની નીચે પાવરશેલમાં બીજો સરળ બોટ કેવી રીતે લખવો અને તેને વેબહૂક, સફેદ IP, સમર્પિત સર્વર્સ, ક્લાઉડમાં તૈનાત વર્ચ્યુઅલ મશીનો અને તેથી વધુ - નિયમિત વિન્ડોઝ સાથે નિયમિત હોમ પીસી પર કેવી રીતે કામ કરવું તે છે.

TLDR: વ્યાકરણ અને હકીકતલક્ષી ભૂલો સાથેનો બીજો કંટાળાજનક લેખ, વાંચવા માટે કંઈ નથી, રમૂજ નથી, ચિત્રો નથી.

લેખમાં કંઈ નવું નથી, અગાઉ લખેલી લગભગ દરેક વસ્તુ Habré પર પહેલેથી જ છે, ઉદાહરણ તરીકે લેખોમાં સૂચનાઓ: ટેલિગ્રામમાં બૉટો કેવી રીતે બનાવવી и સિસ્ટમ એડમિનિસ્ટ્રેટર માટે ટેલિગ્રામ બોટ.
તદુપરાંત, લેખ ઇરાદાપૂર્વક બિનજરૂરી છે જેથી દરેક વખતે શૈક્ષણિક સાહિત્યનો સંદર્ભ ન લેવાય. ટેક્સ્ટમાં ગેંગ 4, પાવરશેલ ડીપ ડાઇવ્સ અથવા, કહો કે, AWS વેલ-આર્કિટેક્ટેડ ફ્રેમવર્કના 5 પિલર્સનો કોઈ સંદર્ભ નથી.

પ્રસ્તાવનાને બદલે, તમે છોડી શકો છો

અવગણો2006 માં, માઇક્રોસોફ્ટે તે સમયના વિન્ડોઝ XP, વિસ્ટા અને સર્વર 1.0 માટે પાવરશેલ 2003 રજૂ કર્યું. કેટલીક રીતે, તેણે cmdbat સ્ક્રિપ્ટ્સ, vb સ્ક્રિપ્ટ્સ, Windows Script Host અને JScript જેવી વસ્તુઓને બદલી નાખી.

અત્યારે પણ, લૂપ્સ, વર્ગો, ફંક્શન્સ, MS GUI કૉલ્સની હાજરી હોવા છતાં, કદાચ હજુ પણ ઉપયોગમાં લેવાતી ડેલ્ફી (અથવા કંઈક જૂની) ને બદલે, પાવરશેલને ફક્ત લોગો વિકલ્પો પછીનું આગલું પગલું ગણી શકાય. Git એકીકરણ અને તેથી પર.

પાવરશેલનો ઉપયોગ પ્રમાણમાં ભાગ્યે જ થાય છે; તમે તેને પાવરશેલ કોર, VMware vSphere PowerCLI, Azure PowerShell, MS એક્સચેન્જ, ઇચ્છિત સ્ટેટ કન્ફિગરેશનના સ્વરૂપમાં જ મળી શકો છો. પાવરશેલ વેબ એક્સેસ અને એક ડઝન કે તેથી વધુ ભાગ્યે જ ઉપયોગમાં લેવાતા કાર્યક્રમો અને કાર્યો. કદાચ તેને રિલીઝ સાથે બીજો પવન મળશે ડબલ્યુએસએલ 2, પરંતુ તે બરાબર નથી.

પાવરશેલના ત્રણ મોટા ફાયદા પણ છે:

1. તે પ્રમાણમાં સરળ છે, તેના વિશે ઘણું સાહિત્ય અને ઉદાહરણો છે, અને રશિયનમાં પણ, ઉદાહરણ તરીકે, ફોરચ વિશેનો લેખ - પુસ્તકમાંથી ઉંડાણમાં પાવરશેલ - તફાવત () અને {} વિશે
2. તે તંત્રી સાથે જાય છે ISE, વિન્ડોઝ સાથે સમાવેશ થાય છે. ત્યાં પણ અમુક પ્રકારનું ડીબગર છે.
3. તેમાંથી કૉલ કરવો સરળ છે ગ્રાફિકલ ઇન્ટરફેસ બનાવવા માટેના ઘટકો.

0. તૈયારી.

અમને જરૂર પડશે:

• Windows PC (મારી પાસે Windows 10 છે)
• ઓછામાં ઓછું અમુક પ્રકારની ઇન્ટરનેટ ઍક્સેસ (ઉદાહરણ તરીકે NAT દ્વારા)
• ટેલિગ્રામની મર્યાદિત ઍક્સેસ ધરાવતા લોકો માટે - બ્રાઉઝરમાં ફ્રીગેટ ઇન્સ્ટોલ અને ગોઠવેલ છે, કેટલાક મુશ્કેલ કિસ્સાઓમાં, સિમ્પલ DNS ક્રિપ્ટ સાથે
• તમારા ફોન પર ટેલિગ્રામ ક્લાયંટ કાર્યરત છે
• ખૂબ જ મૂળભૂત બાબતોને સમજવું - ચલ, એરે, લૂપ શું છે.

લેખો ખોલ્યા અને વાંચો - સૂચનાઓ: ટેલિગ્રામમાં બૉટો કેવી રીતે બનાવવી и સિસ્ટમ એડમિનિસ્ટ્રેટર માટે ટેલિગ્રામ બોટ

1. ચાલો બીજો ટેસ્ટ બોટ બનાવીએ.

કારણ કે દરેક જણ આ પહેલેથી જ જાણે છે, અને થઈ ચૂક્યું છે, તમે તેને છોડી પણ શકો છોઉપરના લેખમાં જણાવ્યા મુજબ - સૌ પ્રથમ, ટેલિગ્રામ માટે બોટ - તે હજી પણ તમારી બાજુ પર ચાલી રહેલી એપ્લિકેશન છે અને ટેલિગ્રામ બોટ API ને વિનંતી કરે છે. વધુમાં, API સ્પષ્ટ છે - બોટ પરિમાણો સાથે ચોક્કસ URL ને ઍક્સેસ કરે છે, અને ટેલિગ્રામ JSON ઑબ્જેક્ટ સાથે પ્રતિસાદ આપે છે.

સંબંધિત સમસ્યાઓ: જો કોઈ અજ્ઞાત રીતે તમે JSON ઑબ્જેક્ટમાંથી કોડ લો અને કોઈક રીતે તેને અમલ માટે મોકલો (ઉદ્દેશ માટે નહીં), તો કોડ તમારા માટે એક્ઝિક્યુટ કરવામાં આવશે.

સર્જન પ્રક્રિયા ઉપરના બે લેખોમાં વર્ણવેલ છે, પરંતુ હું પુનરાવર્તન કરું છું: ટેલિગ્રામમાં આપણે સંપર્કો ખોલીએ છીએ, @botfather શોધીએ છીએ, તેને /newbot કહો, બોટફોર્ટેસ્ટ12344321 બોટ બનાવો, તેને Mynext1234bot કહો, અને એક અનન્ય કી સાથે સંદેશ પ્રાપ્ત કરો. ફોર્મ 1234544311:AbcDefNNNNNNNNNNNNNN

ચાવીની કાળજી લો અને તેને આપશો નહીં!

પછી તમે બૉટને ગોઠવી શકો છો, ઉદાહરણ તરીકે, તેને જૂથોમાં ઉમેરવાની મનાઈ કરો, પરંતુ પ્રથમ પગલાઓમાં આ જરૂરી નથી.

ચાલો BotFather ને “/mybot” માટે પૂછીએ અને જો અમને કંઈક ગમતું ન હોય તો સેટિંગ્સને સમાયોજિત કરીએ.

ચાલો ફરીથી સંપર્કો ખોલીએ, ત્યાં @Botfortest12344321 શોધો (@ સાથે શોધ શરૂ કરવી ફરજિયાત છે), “સ્ટાર્ટ” પર ક્લિક કરો અને બોટ પર લખો “/Glory to the robots.” / ચિહ્ન જરૂરી છે, અવતરણની જરૂર નથી.
બોટ, અલબત્ત, કંઈપણ જવાબ આપશે નહીં.

ચાલો તપાસો કે બોટ બનાવવામાં આવ્યો છે અને તેને ખોલો.

api.telegram.org/bot1234544311:AbcDefNNNNNNNNNNNNNN/getMe
જ્યાં 1234544311:AbcDefNNNNNNNNNNNNNN એ અગાઉ પ્રાપ્ત થયેલ કી છે,
અને જેવી લાઇન મેળવો
{"ઓકે":સત્ય,"રિઝલ્ટ":{""}}

અમારી પાસે પ્રથમ ગુપ્ત શબ્દસમૂહ (ટોકન) છે. હવે આપણે બીજો ગુપ્ત નંબર શોધવાની જરૂર છે - બોટ સાથેની ચેટની 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 કંઈક છે, તે પૂરતું છે. જો તમારી પાસે જૂની વિન્ડોઝ 7/8 હોય તો કોઈ મોટી વાત નથી - જો કે પાવરશેલને વર્ઝન 5 માં અપડેટ કરવાની જરૂર પડશે - દા.ત. સૂચનો.

નીચેની આદેશ વાક્યમાં Get-Date લખો, Enter દબાવો, સમય જુઓ, આદેશ સાથે રૂટ ફોલ્ડરમાં જાઓ
cd
અને cls આદેશ વડે સ્ક્રીન સાફ કરો (ના, તમારે rm વાપરવાની જરૂર નથી)

હવે ચાલો તપાસીએ કે શું કામ કરે છે અને કેવી રીતે - ચાલો કોડ પણ નહીં, પણ બે લીટીઓ લખીએ, અને તેઓ શું કરે છે તે સમજવાનો પ્રયાસ કરીએ. ચાલો # સિમ્બોલ સાથે get-host સાથે લાઇન પર ટિપ્પણી કરીએ અને થોડું ઉમેરો.

# Пример шаблона бота 
# 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")...                                         

જેમ તમે જોઈ શકો છો, પ્રકારનું ચલ TypeName: 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 | અનુસાર get-member એ 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
# “ગણતરી”,”લંબાઈ”,”લાંબી લંબાઈ”,”રેન્ક”,”સિંકરૂટ”,”ઇઝરીડ ઓન્લી”,”ઇઝ ફિક્સ્ડસાઇઝ”,”ઇઝ સિંક્રોનાઇઝ્ડ”
#
ચાલો તેને થોડું ફરીથી લખીએ:

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 તરીકે વર્ણવે છે, તેને પાવરશેલમાં કહેવામાં આવે છે સ્વીચ દ્વારા. તે જ સમયે, નીચેનો કોડ -વાઇલ્ડકાર્ડ કીનો ઉપયોગ કરે છે, જે સંપૂર્ણપણે બિનજરૂરી અને હાનિકારક પણ છે.

કેટલાક કોડ #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 પરિમાણની જરૂર છે, અને &timeout, &limit, &parse_mode=HTML અને &disable_web_page_preview=true હજુ જરૂરી નથી.

માટે દસ્તાવેજીકરણ ટેલિગ્રામ એપીઆઈ અહીં છે
તે સફેદ અને અંગ્રેજીમાં કહે છે:
પરત કરવામાં આવનાર પ્રથમ અપડેટનું ઓળખકર્તા. અગાઉ પ્રાપ્ત થયેલ અપડેટ્સના ઓળખકર્તાઓમાં સૌથી વધુ એક કરતા વધુ હોવા જોઈએ. ડિફૉલ્ટ રૂપે, અપડેટ્સ સૌથી વહેલાથી શરૂ થાય છે
અપ્રમાણિત અપડેટ પરત કરવામાં આવે છે. જેમ જેમ getUpdates ને કોલ કરવામાં આવે છે કે તરત જ અપડેટ કન્ફર્મ માનવામાં આવે છે ઑફસેટ ઉચ્ચ તેના અપડેટ_આઈડી કરતાં. અપડેટ્સ કતારના અંતથી -ઑફસેટ અપડેટથી શરૂ થતા અપડેટ્સને પુનઃપ્રાપ્ત કરવા માટે નકારાત્મક ઑફસેટનો ઉલ્લેખ કરી શકાય છે. અગાઉના તમામ અપડેટ્સ ભૂલી જશે.

ચાલો જોઈએ:

$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