შაბლონი მარტივი ტელეგრამის ბოტისთვის 7-9 კლასების მოსწავლეებისთვის Powershell-ის გამოყენებით

მეგობართან საუბრისას უცებ გავიგე, რომ მათ სკოლაში 8-10 კლასების ბავშვებს პროგრამირებას საერთოდ არ ასწავლიან. Word, Excel და ყველაფერი. არც ლოგო, არც პასკალი, არც VBA Excel-ისთვის.

ძალიან გამიკვირდა, გავხსენი ინტერნეტი და დავიწყე კითხვა -
სპეციალიზებული სკოლის ერთ-ერთი ამოცანაა ხელი შეუწყოს ახალი თაობის განათლებას, რომელიც აკმაყოფილებს ინფორმაციული საზოგადოების პირობებს მისი განვითარების დონით და ცხოვრების წესით.
ეს კურსი სტუდენტებს საშუალებას მისცემს პრაქტიკაში გააერთიანონ თავიანთი ცოდნა პასკალის პროგრამირების ენის ძირითადი კონსტრუქციების შესახებ. (ზოგიერთი გიმნაზიის 2017 წლის პროგრამიდან)

საბოლოოდ, გადავწყვიტე, რამდენიმე საათი დამეხარჯა და გამომესახა მაგალითი იმისა, თუ როგორ შევქმნათ მარტივი ბოტი სკოლის მოსწავლეებისთვის.

ჭრილის ქვემოთ მოცემულია, თუ როგორ უნდა დაწეროთ კიდევ ერთი მარტივი ბოტი Powershell-ში და ის იმუშაოს ვებჰუკის, თეთრი IP-ების, გამოყოფილი სერვერების, ღრუბელში განლაგებული ვირტუალური მანქანების გარეშე და ასე შემდეგ - ჩვეულებრივ სახლის კომპიუტერზე რეგულარული Windows-ით.

TLDR: კიდევ ერთი მოსაწყენი სტატია გრამატიკული და ფაქტობრივი შეცდომებით, წასაკითხი არაფერია, არც იუმორი, არც სურათები.

სტატიაში ახალი არაფერია, თითქმის ყველაფერი ადრე დაწერილი უკვე ჰაბრეზე იყო, მაგალითად სტატიებში ინსტრუქცია: როგორ შევქმნათ ბოტები Telegram-ში и Telegram ბოტი სისტემის ადმინისტრატორისთვის.
უფრო მეტიც, სტატია შეგნებულად ზედმეტია, რათა ყოველ ჯერზე არ მივმართოთ საგანმანათლებლო ლიტერატურას. ტექსტში არ არის მითითებები Gang 4-ზე, PowerShell Deep Dives-ზე ან, ვთქვათ, AWS კარგად არქიტექტურული ჩარჩოს 5 სვეტზე.

წინასიტყვაობის ნაცვლად, შეგიძლიათ გამოტოვოთ

მოგერიდებათ გამოტოვოთ2006 წელს Microsoft-მა გამოუშვა PowerShell 1.0 იმდროინდელი Windows XP, Vista და Server 2003-ისთვის. გარკვეულწილად, მან შეცვალა ისეთი რამ, როგორიცაა cmdbat სკრიპტები, vb სკრიპტები, Windows Script Host და JScript.

ახლაც კი, PowerShell შეიძლება ჩაითვალოს მხოლოდ ლოგოს ვარიანტების შემდეგ შემდეგ ეტაპზე, ნაცვლად ალბათ ჯერ კიდევ გამოყენებული Delphi-ისა (ან უფრო ძველი), მიუხედავად მარყუჟების, კლასების, ფუნქციების, MS GUI ზარების არსებობისა, Git ინტეგრაცია და ასე შემდეგ.

Powershell გამოიყენება შედარებით იშვიათად; თქვენ შეგიძლიათ შეხვდეთ მას მხოლოდ PowerShell Core, VMware vSphere PowerCLI, Azure PowerShell, MS Exchange, სასურველი მდგომარეობის კონფიგურაციის სახით, PowerShell ვებ წვდომა და ათეული ან უფრო იშვიათად გამოყენებული პროგრამა და ფუნქცია. ალბათ ის მეორე ქარს მიიღებს გათავისუფლებით WSL2, მაგრამ ზუსტად ასე არ არის.

Powershell-ს ასევე აქვს სამი დიდი უპირატესობა:

1. ეს შედარებით მარტივია, ამის შესახებ ბევრი ლიტერატურა და მაგალითია და თუნდაც რუსულ ენაზე, მაგალითად, სტატია Foreach-ის შესახებ - წიგნიდან. PowerShell სიღრმისეულად - განსხვავების შესახებ () და {}
2. ის მიდის რედაქტორთან ISEმოყვება Windows. იქ არის რაღაც გამართულიც კი.
3. მისგან დარეკვა ადვილია კომპონენტები გრაფიკული ინტერფეისის შესაქმნელად.

0. მომზადება.

ჩვენ გვჭირდება:

• Windows PC (მე მაქვს Windows 10)
• მინიმუმ რაიმე სახის ინტერნეტი (მაგალითად, NAT-ის საშუალებით)
• მათთვის, ვისაც შეზღუდული წვდომა აქვს ტელეგრამაზე - დაინსტალირებული და კონფიგურირებული freegate ბრაუზერში, ზოგიერთ რთულ შემთხვევაში, Symple DNS Crypt-თან ერთად
• თქვენს ტელეფონზე სამუშაო ტელეგრამის კლიენტის ქონა
• საფუძვლების გაგება - რა არის ცვლადი, მასივი, მარყუჟი.

გახსნა და წაიკითხა სტატიები - ინსტრუქცია: როგორ შევქმნათ ბოტები Telegram-ში и Telegram ბოტი სისტემის ადმინისტრატორისთვის

1. შევქმნათ კიდევ ერთი სატესტო ბოტი.

ვინაიდან ეს უკვე ყველამ იცის და უკვე მოხდა, თქვენ ასევე შეგიძლიათ გამოტოვოთ ესროგორც ზემოთ სტატიაშია ნათქვამი - პირველ რიგში, ბოტი Telegram-ისთვის - ეს ჯერ კიდევ არის აპლიკაცია, რომელიც მუშაობს თქვენს მხარეს და აკეთებს მოთხოვნებს Telegram Bot API-ზე. უფრო მეტიც, API ნათელია - ბოტი წვდება კონკრეტულ URL-ს პარამეტრებით, ხოლო Telegram პასუხობს JSON ობიექტით.

დაკავშირებული პრობლემები: თუ რაიმე უცნობი გზით აიღებთ კოდს JSON ობიექტიდან და როგორმე გაგზავნით შესასრულებლად (არა განზრახ), კოდი შესრულდება თქვენთვის.

შექმნის პროცესი აღწერილია ზემოთ ორ სტატიაში, მაგრამ ვიმეორებ: ტელეგრამაში ვხსნით კონტაქტებს, ვეძებთ @botfather, ვუთხარით მას /newbot, შექმენით ბოტი Botfortest12344321, დავარქვათ მას Mynext1234bot და ვიღებთ შეტყობინებას უნიკალური გასაღებით. ფორმა 1234544311: AbcDefNNNNNNNNNNNNNN

გაუფრთხილდი გასაღებს და არ გასცე!

შემდეგ შეგიძლიათ ბოტის კონფიგურაცია, მაგალითად, აკრძალოთ მისი დამატება ჯგუფებში, მაგრამ პირველ ნაბიჯებში ეს არ არის საჭირო.

ვთხოვოთ BotFather-ს „/mybot“ და შევასწოროთ პარამეტრები, თუ რამე არ მოგვწონს.

მოდით ისევ გავხსნათ კონტაქტები, ვიპოვოთ იქ @Botfortest12344321 (სავალდებულოა ძიების დაწყება @-ით), დააწკაპუნეთ „დაწყება“ და მივწეროთ ბოტს „/Glory to the robots“. ნიშანი / აუცილებელია, ციტატები არ არის საჭირო.
ბოტი, რა თქმა უნდა, არაფერს უპასუხებს.

შევამოწმოთ, რომ ბოტი შეიქმნა და გავხსნათ.

api.telegram.org/bot1234544311:AbcDefNNNNNNNNNNNNNN/getMe
სადაც 1234544311:AbcDefNNNNNNNNNNNNNN არის ადრე მიღებული გასაღები,
და მიიღეთ ხაზი მსგავსი
{"ok":true,"შედეგი":{""}}

გვაქვს პირველი საიდუმლო ფრაზა (ჟეტონი). ახლა ჩვენ უნდა გავარკვიოთ მეორე საიდუმლო ნომერი - ბოტთან ჩატის ID. თითოეული ჩატი, ჯგუფი და ა.შ. ინდივიდუალურია და აქვს თავისი ნომერი (ზოგჯერ მინუსით - ღია ჯგუფებისთვის). ამ ნომრის გასარკვევად, ბრაუზერში უნდა მოვითხოვოთ (ფაქტობრივად, ბრაუზერში ეს სულაც არ არის საჭირო, მაგრამ უკეთ გასაგებად შეგიძლიათ დაიწყოთ) მისამართი (სადაც 1234544311:NNNNNNNNNN არის თქვენი ნიშანი.

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

და მიიღეთ მსგავსი პასუხი

{"ok":true,"შედეგი":[{"update_id":...,... სტატისტიკა":{"id":123456789

ჩვენ გვჭირდება chat_id.

მოდით შევამოწმოთ, რომ შეგვიძლია ჩატში ხელით ჩაწერა: დარეკეთ მისამართზე ბრაუზერიდან

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

თუ თქვენ მიიღებთ შეტყობინებას ბოტისგან თქვენს ჩატში, კარგი, გადადით შემდეგ ეტაპზე.

ამ გზით (ბრაუზერის საშუალებით) ყოველთვის შეგიძლიათ შეამოწმოთ, არის თუ არა პრობლემები ბმულის გენერაციასთან დაკავშირებით, ან არის თუ არა რაიმე დამალული სადმე და არ მუშაობს.

რა უნდა იცოდეთ კითხვის გაგრძელებამდე

Telegram-ს აქვს რამდენიმე ტიპის ჯგუფური ჩატი (ღია, დახურული). ამ ჩატებისთვის, ზოგიერთი ფუნქცია (მაგალითად, id) განსხვავებულია, რაც ზოგჯერ გარკვეულ პრობლემებს იწვევს.

დავუშვათ, რომ 2019 წლის ბოლოა და ჩვენი დროის გმირიც კი, ცნობილი Man-Orchestra (ადმინისტრატორი, იურისტი, ინფორმაციული უსაფრთხოების სპეციალისტი, პროგრამისტი და პრაქტიკულად MVP) ევგენი ვ. განასხვავებს $i ცვლადს მასივისაგან. აითვისა მარყუჟები, შეხედეთ მომდევნო რამდენიმე წელიწადში დაეუფლება შოკოლადს და შემდეგ პარალელური დამუშავება PowerShell-ით и ForEach-Object პარალელურად მოვა.

1. ვფიქრობთ, რას გააკეთებს ჩვენი ბოტი

წარმოდგენა არ მქონდა, უნდა მეფიქრა. მე უკვე დავწერე ბოტ-რვეული. არ მინდოდა ბოტის შექმნა, „რომელიც სადღაც რაღაცას აგზავნის“. Azure-თან დასაკავშირებლად გჭირდებათ საკრედიტო ბარათი, მაგრამ საიდან იღებს სტუდენტს? უნდა აღინიშნოს, რომ ყველაფერი არც ისე ცუდია: მთავარი ღრუბლები იძლევა რაიმე სახის ტესტის პერიოდს უფასოდ (მაგრამ მაინც გჭირდებათ საკრედიტო ბარათის ნომერი - და, როგორც ჩანს, მისგან დოლარი ჩამოგეჭრებათ. არ მახსოვს, თუ მოგვიანებით დააბრუნეს.)

AI ML-ის გარეშე არც ისე საინტერესოა ბოტი-ღარიბი-პოეტი-ქსოველის გაკეთება.

გადავწყვიტე შემექმნა ბოტი, რომელიც შემახსენებს (ან არა) ინგლისურ სიტყვებს ლექსიკონიდან.
მონაცემთა ბაზაში შეფერხების თავიდან ასაცილებლად, ლექსიკონი შეინახება ტექსტურ ფაილში და განახლდება ხელით.
ამ შემთხვევაში, ამოცანაა სამუშაოს საფუძვლების ჩვენება და არა ნაწილობრივ მზა პროდუქტის დამზადება.

2. პირველად ცდა რა და როგორ

მოდით შევქმნათ საქაღალდე C:poshtranslate
პირველი, ვნახოთ, როგორი powershell გვაქვს, მოდით გავუშვათ ISE start-run-ით
powershell ise
ან იპოვეთ Powershell ISE დაინსტალირებული პროგრამებში.
გაშვების შემდეგ გაიხსნება ჩვეულებრივი ნაცნობი „რაღაც რედაქტორი“; თუ ტექსტის ველი არ არის, მაშინ ყოველთვის შეგიძლიათ დააჭიროთ „ფაილი - შექმენით ახალი“.

მოდით შევხედოთ powershell-ის ვერსიას - ჩაწერეთ ტექსტის ველში:

get-host 

და დააჭირეთ F5.

Powershell შემოგთავაზებთ შენახვას - „სკრიპტი, რომლის გაშვებასაც აპირებთ, შეინახება.“ ჩვენ ვეთანხმებით და შეინახეთ ფაილი powershell-იდან, სახელწოდებით C: poshtranslate. myfirstbotBT100.

გაშვების შემდეგ, ქვედა ტექსტის ფანჯარაში ვიღებთ მონაცემთა ცხრილს:

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

რაღაც 5.1 მაქვს, საკმარისია. თუ თქვენ გაქვთ ძველი Windows 7/8, მაშინ არაფერია დიდი - თუმცა PowerShell-ს დასჭირდება განახლება 5 ვერსიაზე - მაგ. ინსტრუქციები.

ჩაწერეთ Get-Date ბრძანების სტრიქონში ქვემოთ, დააჭირეთ Enter, დაათვალიერეთ დრო, გადადით root საქაღალდეში ბრძანებით.
cd
და გაასუფთავეთ ეკრანი cls ბრძანებით (არა, თქვენ არ გჭირდებათ rm-ის გამოყენება)

ახლა მოდით შევამოწმოთ რა მუშაობს და როგორ - დავწეროთ არა კოდი, არამედ ორი სტრიქონი და შევეცადოთ გავიგოთ რას აკეთებენ ისინი. მოდით გამოვყოთ ხაზი get-host-ით # სიმბოლოთი და დავამატოთ ცოტა.

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

(საინტერესო ის არის, რომ კოდის ფორმატირების ჩამოსაშლელ სიაში Habré-ზე არის ორი ათეული ვარიანტი - მაგრამ Powershell არ არის იქ. Dos არის იქ. Perl არის იქ.)

და მოდით გავუშვათ კოდი F5 ან ">"-ის დაჭერით GUI-დან.

ჩვენ ვიღებთ გამომავალს:

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

ახლა მოდით გადავხედოთ ამ ორ სტრიქონს და რამდენიმე საინტერესო პუნქტს, რათა მომავალში არ დავუბრუნდეთ ამას.

პასკალისგან განსხვავებით (და არა მხოლოდ), PowerShell თავად ცდილობს განსაზღვროს რა ტიპის მინიჭება ცვლადს; ამის შესახებ მეტი დეტალები წერია სტატიაში. საგანმანათლებლო პროგრამა პროგრამირების ენებზე აკრეფის შესახებ
ამიტომ, $TimeNow ცვლადის შექმნით და მას მიმდინარე თარიღისა და დროის მნიშვნელობის მინიჭებით (Get-Date), ჩვენ არ უნდა ვიფიქროთ იმაზე, თუ რა ტიპის მონაცემები იქნება იქ.

მართალია, ამ უცოდინრობამ შეიძლება მოგვიანებით დააზარალოს, მაგრამ ეს მოგვიანებით. ტექსტის ქვემოთ იქნება მაგალითი.
ვნახოთ რა მივიღეთ. მოდით შევასრულოთ (ბრძანების ხაზზე)

$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. Telegram ბოტთან ურთიერთობის გაგება

რა თქმა უნდა, კიდევ უფრო მეტი ლიტერატურა დაიწერა ბოტთან ურთიერთქმედების, ყველა getpush-ის და ასე შემდეგ, მაგრამ თეორიის საკითხი შეიძლება ჩაითვალოს სურვილისამებრ.

ჩვენს შემთხვევაში აუცილებელია:

• ისწავლეთ რაიმეს გაგზავნა მიმოწერაში
• ისწავლეთ რაღაცის მიღება მიმოწერიდან

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"

საბედნიეროდ, ადრე გამოქვეყნებულ სტატიაში Telegram bot სისტემის ადმინისტრატორისთვის ეს ხაზი (დიახ, $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#>

ახლა ჩვენ უნდა გადავწყვიტოთ სად მივიღოთ ლექსიკონი (კარგად, სად - დისკზე ფაილში) და როგორი იქნება ის.

რა თქმა უნდა, თქვენ შეგიძლიათ დაწეროთ უზარმაზარი ლექსიკონი პირდაპირ სკრიპტის ტექსტში, მაგრამ ეს სრულიად მიღმაა.
მოდით ვნახოთ, რა Powershell-თან შეუძლია ნორმალურად მუშაობა.
ზოგადად, მას არ აინტერესებს რომელ ფაილთან უნდა იმუშაოს, ჩვენთვის არ აქვს მნიშვნელობა.
ჩვენ გვაქვს არჩევანი: 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
# "Count", "Length", "LongLength", "Rank", "SyncRoot", "IsReadOnly", "IsFixedSize", "IsSynchronized"
#
ცოტა გადავიწეროთ:

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

მოდით გადავხედოთ ყველა მიღებულს და გავაგზავნოთ პასუხი, თუ შეტყობინება იყო /word
კონსტრუქციის შემთხვევას, რასაც ზოგიერთი აღწერს, როგორც if-elseif, Powershell-ში ეწოდება გადამრთველის საშუალებით. ამავდროულად, ქვემოთ მოცემული კოდი იყენებს -wildcard კლავიშს, რომელიც სრულიად არასაჭირო და საზიანოც კი არის.

ზოგიერთი კოდი #7.1

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

მოდით გავუშვათ სკრიპტი რამდენჯერმე. ჩვენ ორჯერ მივიღებთ ერთსა და იმავე სიტყვას თითოეული შესრულების მცდელობისთვის, განსაკუთრებით თუ შეცდომა დავუშვით შემთხვევითი განხორციელებისას.

მაგრამ გაჩერდი. ჩვენ ისევ არ გავუგზავნეთ /word, რატომ მუშავდება შეტყობინება ხელახლა?

ბოტზე შეტყობინებების გაგზავნის რიგს აქვს სასრული სიგრძე (100 ან 200 შეტყობინება, ვფიქრობ) და ხელით უნდა გაიწმინდოს.

ეს, რა თქმა უნდა, აღწერილია დოკუმენტაციაში, მაგრამ თქვენ უნდა წაიკითხოთ!

ამ შემთხვევაში, ჩვენ გვჭირდება ?chat_id პარამეტრი, ხოლო &timeout, &limit, &parse_mode=HTML და &disable_web_page_preview=true ჯერ არ არის საჭირო.

დოკუმენტაცია ამისთვის telegram api აქ არის
თეთრად და ინგლისურად წერია:
დასაბრუნებელი პირველი განახლების იდენტიფიკატორი. უნდა იყოს ერთით მეტი, ვიდრე უმაღლესი ადრე მიღებული განახლებების იდენტიფიკატორებს შორის. ნაგულისხმევად, განახლებები იწყება ყველაზე ადრე
დაუზუსტებელი განახლება დაბრუნდა. განახლება ითვლება დადასტურებულად, როგორც კი getUpdates გამოიძახება ოფსეტური უმაღლესი ვიდრე მისი 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. დასკვნის ნაცვლად

ძირითადი ფუნქციები - შეტყობინებების წაკითხვა, რიგის გადატვირთვა, ფაილიდან კითხვა და ფაილში ჩაწერა შესრულებულია და ნაჩვენებია.

დარჩენილია მხოლოდ ოთხი საქმე:

• სწორი პასუხის გაგზავნა მოთხოვნაზე ჩატში
• პასუხის გაგზავნა ნებისმიერ ჩატზე, რომელშიც დამატებულია ბოტი
• კოდის მარყუჟში შესრულება
• ბოტის გაშვება windows განრიგიდან.

ყველა ეს დავალება მარტივია და ადვილად შესრულდება ისეთი პარამეტრების შესახებ დოკუმენტაციის წაკითხვით, როგორიცაა
Set-ExecutionPolicy შეუზღუდავი და -ExecutionPolicy Bypass
ფორმის ციკლი

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

მადლობა ყველას წაკითხვისთვის.

წყარო: www.habr.com