Query console 1s 8.3 este o aplicație obișnuită. Lucrul cu consola de interogări
Deci, să începem cu ceva simplu: creați o Procesare nouă în configurator, denumiți-o Consola de interogări sau Generator de interogări, după cum doriți.
Putem adăuga imediat un tabel în „Date” pentru parametrii viitori de care avem nevoie, astfel încât în Consola noastră să rulăm nu cea mai primitivă cerere, ci cu parametri și legături, de exemplu, pentru munca noastră vom crea o solicitare la registrele periodice , dar aici fără Parameter instructions=&Date nicăieri.
Pentru a crea tabelul nostru Parametri, în fila „Date” din „partea tabulară” vom adăuga un nou tabel, numim Parametri de interogare, aici vom adăuga coloanele acestui tabel: 1) ParameterName, tastați șir = 25 de caractere; ParameterValue, aici este un tip de date compus, vezi Fig:
Prin urmare, așa cum se arată în imagine, selectăm un tip compus pentru coloana Valoare parametru: în meniul tip care se deschide, bifați caseta de selectare „Tip compus”, selectați numărul, șirul (specificați 20 de caractere), data, boolean și bifați caseta de selectare de jos - AnyLink - înseamnă ceea ce urmează, atunci când specificăm Parametrii solicitării noastre, ne putem referi la orice obiect al configurației noastre, de exemplu, directoare sau documente.
Acum trebuie să creăm forma viitoarei noastre Console de interogări. În procesare, să mergem la fila „Formulare” și să adăugăm unul nou. Introducem acest formular și există deja un câmp nelimitat pentru creativitate - puteți aranja cele două detalii pe care tocmai le-ați creat și o placă cu parametrii după cum doriți! Pentru a face acest lucru, puteți utiliza elemente de formular standard, cum ar fi un grup sau o pagină cu pagini (dacă preferați să răsturnați paginile.
Principalul lucru aici este un lucru: după ce trageți atributul „TextValues” în câmpul din stânga al editării formularului, asigurați-vă că setați „View”=Text Document Field în proprietățile sale.
În proprietățile atributului „Tabel de interogări”, puteți specifica opțional „Grilă de afișare” și „Afișare anteturi”.
Apoi, în fereastra de editare a formularului din dreapta, mergeți la fila „Comenzi” și adăugați un buton nou, când faceți clic, Consola noastră va efectua o anumită acțiune. Să creăm un buton „Constructor de interogări”, dacă doriți, puteți adăuga o pictogramă la buton, principalul lucru este să plasați butonul în sine în fereastra de editare a formularului din stânga - astfel încât să-l putem vedea apoi în forma corectă fereastra de editare, faceți clic dreapta pe butonul nostru și selectați proprietăți - în proprietăți, faceți clic pe elementul „Acțiune”, va apărea o fereastră modală cu o întrebare - unde exact va fi codul programului, pe care îl vom atribui butonului - selectați „Pe client”.
Modulul de formular se va deschide cu o procedură goală gata făcută „Constructor de interogare de procedură (comandă)”. În această procedură vom descrie apelul la standardul 1c8 Query Builder. Este foarte usor: Constructor = New Request Constructor; Dar există capcane aici - Constructorul de interogări încorporat în platformă funcționează în modul utilizator NUMAI sub un client gros! Prin urmare, vom introduce condiția instrucțiunii preprocesorului #Dacă, dar aici decideți singur, în funcție de platforma dvs., sau aveți formulare obișnuite, apoi selectați „ FatClientRegularApp„sau aveți o platformă bazată pe formulare gestionate, atunci” ThickClientManagedApplication„.vezi fig.
Acum rămâne să adăugăm la această procedură o condiție pentru înregistrarea textului cererii, pe care Generatorul de interogări o va genera pentru noi în detaliile formularului nostru „Text de solicitare”:
Dacă Constructor.OpenModal()=True, atunci Object.RequestText=Constructor.Text;
endIf;
Dar putem schimba manual ceva în textul solicitării (în modul utilizator - în fereastra de atribut „Text solicitat”), astfel încât modificările noastre să intre în Constructorul de interogări atunci când este apelat din nou - vom adăuga o condiție simplă aici:
Dacă nu EmptyString(Object.QueryText) atunci Constructor.Text = Object.QueryText;
endIf;
Deci, rulăm Constructorul de interogări, putem începe să punem împreună interogarea viitoare în el, dar suntem interesați să vedem cum va funcționa interogarea pe care am creat-o! Și pentru a face acest lucru, trebuie să creăm un alt buton în configurator atunci când edităm formularul consolei noastre, să-l numim „Run Query”. În proprietățile butonului „Run Query”, faceți clic pe „Action”, apare din nou un meniu în care suntem întrebați unde va fi procesat codul programului nostru, în în acest caz, selectați „Atât pe client, cât și pe server”, din nou intrăm în Modulul Formulare.
În procedura Execute Query(), pe care o avem pe client, vom scrie o condiție dacă utilizatorul nu a introdus textul de interogare, dar cere să îl execute:
If EmptyString(Object.QueryText) Then report("Introduceți textul interogării!");
endIf;
Sistemul a generat deja automat o legătură către procedura Execute RequestOnServer() ; - e bine, să trecem la această procedură, care se execută pe server, și să scriem aici codul pentru executarea cererii noastre introduse. Există opțiuni aici: Puteți scrie singur toate expresiile legate de crearea interogărilor, de ex. manual, dar sunt mai multe varianta mai simpla
- în cadrul procedurii, faceți clic dreapta și în meniul derulant selectați „Generator de interogări cu procesarea rezultatelor, vezi figura.”:
Dacă ați făcut clic pe elementul „Proiectare de interogări cu procesare a rezultatelor”, va apărea o fereastră modală „Textul de interogare nu a fost găsit”, faceți clic pe Da, în care se va deschide pe prima filă „Procesarea rezultatului” - selectați primul element „Ocolirea rezultatului, nu avem nevoie de nimic altceva de la acest constructor, faceți clic pe butonul „Ok” - va apărea o fereastră modală: „Nu”. câmpurile sunt selectate în cerere, faceți clic pe „OK”.
După aceasta, următorul șablon gata făcut va apărea în cadrul procedurii noastre ExecuteRequestOnServer():
Să trecem la expresia construită de constructor:
Solicitare.Text = "";
Este atât de simplu, butonul nostru „Execută cererea” de pe formularul de procesare este deja practic operațional, până acum poate procesa doar cereri simple fără parametri, dar principalul lucru este că funcționează! Tot ce rămâne este să afișam vizual rezultatele solicitării noastre în atributul „Tabelul de valori” din formularul de procesare. Permiteți-mi să vă reamintesc că atributul nostru „Tabelul de valori” este de tip „Document tabelar”, deoarece altfel nu vom vedea rezultatele noastre în modul utilizator. Ieșirea datelor tabulare către utilizator este întotdeauna gestionată fie de un document tabelar, fie de un Layout. Aș dori foarte mult să fie posibilă afișarea datelor printr-un tabel de valori - deoarece este foarte ușor de utilizat și familiar, dar. , din păcate, un tabel de valori este doar un instrument de care are nevoie un dezvoltator, nu puteți afișa date pe ecran folosindu-l...
Să aruncăm o privire mai atentă la ce este un document de foaie de calcul - este ca o foaie Excel - poți ajunge la o înregistrare într-o anumită celulă doar folosind celulele tabelului, aici le numim o zonă, dar noi înșine putem selecta intervalul acestei zone într-o singură celulă specifică:
Deci, ne-am dat seama ce este un document de foaie de calcul și am stabilit pentru noi înșine că va trebui să definim datele din interogarea noastră într-o anumită celulă a acestui document de foaie de calcul. Dar să ne gândim: care este „Rezultatul interogării” pe care designerul l-a generat atât de repede pentru noi? Deschideți ajutorul - Rezultatul interogării este un tabel care are proprietățile corespunzătoare! vezi fig.
Și dacă scriem acum după expresia Query Result = Query.Execute( (creat de constructor), iată un ciclu atât de simplu pentru Colecții:
Pentru fiecare ColumnName Din Query Result.Columns Loop report(ColumnName.Name);
EndCycle;
După acest ciclu, deocamdată, notează toate expresiile construite automat de constructor. Și rulați 1C:Enterprise8 sub clientul gros Creați orice interogare simplă (puteți utiliza Generatorul de interogări - funcționează deja pentru noi) și faceți clic pe butonul „Run Query”:
Apoi veți vedea în partea de jos a ferestrei de mesaj - că tabelul Rezultatele interogării stochează numele câmpurilor pe care tocmai le-am selectat prin crearea unei interogări simple.
Acum să afișăm aceste nume ale câmpurilor suferinței noastre într-un document de calcul:
Pentru a afișa detaliile datelor interogării, să analizăm expresiile create automat de designer și să introducem în bucla de sortare „SelectionDetailedRecords” a interogării în sine exact aceeași buclă pe care am folosit-o pentru a afișa numele coloanelor, doar că acum trebuie să trecem nu datele din tabelul „Rezultatul interogării” în textul celulei și datele selecției în sine, să vedem în ajutor cum puteți accesa câmpul Selecție detaliată al cererii:
SelectionDetailRecords = QueryResult.Select();
În timp ce SelectionDetailedRecords.Next() Loop //în prima linie avem deja scrise numele coloanelor din tabel, așa că încărcăm datele sub prima lineDocRowNumber=Object.QueryTable.TableHeight+1;
Pentru fiecare ColumnName din Query Result.Columns Cycle Cell=Object.QueryTable.Area(DocRowNumber,QueryResult.Columns.Index(ColumnName)+1);
Cell.Text = SelectionDetailedRecords[ColumnName.Name];
EndCycle; EndCycle; Gata, putem verifica, încărca întreprinderea sub un client gros, introduceți o cerere simplă fără parametri, faceți clic pe butonul „Run Query”, vezi figura:
Ura, totul merge!!!
Este foarte convenabil când, la deschiderea/închiderea Consolei noastre de interogări, textul de interogare, cu care am lucrat înainte de a închide consola, este din nou scris în câmpul „Text de interogare”. Pentru a face acest lucru, trebuie doar să activați proprietatea formularului = Salvare automată, vezi fig:
Gata, consola noastră funcționează. Pentru a putea scrie interogări mai complexe cu parametri specificați în ele, trebuie să creăm un alt buton „Găsiți parametri”, precum și codul pentru butonul „Run Query” - va fi executat codul pentru butonul „Găsiți parametri”. pe client și pe server. Apoi, în procedura serverului, lansăm solicitarea exact în același mod cu textul trecut în ea din fereastra „Request Text”, folosind expresia „Request.FindParameters()” găsim parametrii trecuți și pur și simplu îi introducem în bucla
Descărcarea conține o mostră a Consolei de interogări pe care tocmai am creat-o.
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
Upgrade la Query Console:
1) Acum, Consola noastră de interogări de casă, cu un Generator de interogări încorporat, va rula sub orice client: sub un client gros de formulare obișnuite și gestionate și sub un client subțire și web.
p.s. Forma și aspectul Generatorului de interogări încorporat sunt diferite - în funcție de clientul în care am lansat Consola (eu personal sunt mai familiar și mai convenabil cu forma Generatorului de interogări sub un client gros)
&Pe Client Procedure Query Constructor (Comandă) //apelarea standard Query Constructor este posibilă numai sub un client gros #If ThickClientManagedApplication sau ThickClientNormalApplication Then Constructor=New Query Constructor;
Dacă nu EmptyString(Object.QueryText) atunci Constructor.Text = Object.QueryText;
endIf;
Dacă Constructor.OpenModal()=True, atunci Object.RequestText=Constructor.Text;
SELECTAȚI ExternalData.Product, ExternalData.Quantity PLACE ExternalData FROM &ExternalData AS ExternalData; //////////////////////////////////////////////////////////////////// ////////////////////////// SELECT ExternalData.Product, ExternalData.Quantity, ISNULL(RemainingProductRemaining.QuantityRemaining, 0) AS Field1, ISNULL(Remaining ProductsRemainings.QuantityRemaining, 0) - ExternalData.Quantity AS Remaining FROM ExternalData AS ExternalData LEFT JOIN Register Accumulations.Remaining Products.Remainings(&Date, Product IN (SELECT ExternalData.Product FROM ExternalData AS ExternalData)) =Remaining Products Remaining Products.Data ca produs extern RemainingProductRemainingProduct
Pe baza exemplului și asemănării codului de interogare de mai sus, vă puteți crea propria interogare complexă, ținând cont de obiectele dvs. de date.
Deci, în designerul de interogări am creat interogarea de mai sus, închizând Constructorul - textul interogării va intra în câmpul consolei noastre „Text interogare”, faceți clic pe butonul „Găsiți parametri”, vedem că în tabelul Parametri a apărut o linie = "Date externe", Value type="Value Table" ,vezi fig.
În acest tabel de parametri - introduceți parametrul Data, de exemplu, data de astăzi, apoi faceți clic pentru a încerca să editați parametrul nostru temporar de tabel „Date externe”, faceți clic în câmpul cu „Tabel de valori” pe trei puncte - o selecție de tipuri va apare, faceți clic pe Rând, mecanismul nostru ne întoarce pagina din formular, unde trebuie să introducem manual acest tabel foarte temporar.
Rețineți aici că, în acest caz, pe pagina „Orare” din partea de jos a câmpului „Numele tabelului temporar în parametri”, va apărea numele tabelului nostru temporar (este copiat din tabelul Parametri).
Până acum, pe pagina „Tabele de timp” vedem un singur tabel gol - acesta este tabelul Tipurilor viitorului nostru tabel temporar. Folosind butonul „Adăugați”, vom adăuga numele atributului și tipul tabelului viitor . Fiți atenți - numele și tipul trebuie să corespundă cu ceea ce am specificat în cererea pentru &ExternalData:
Acum apăsăm butonul „Actualizați tabelul temporar” - și vom avea aici un al doilea tabel - îl vom completa direct cu date temporare ale tabelului prin butonul „Adăugați”.
Gata, ne putem verifica încă o dată dacă am introdus datele primitive ale parametrilor de interogare în tabelul cu parametri de pe prima pagină de procesare și faceți clic pe butonul „Run Query” - totul este calculat și selectat în consecință cu limitarea datelor trecute în parametrul tabelului nostru temporar
p.s. Dacă ați făcut o greșeală când ați introdus numele detaliilor și tipurile acestora (în primul tabel) - doar închideți Consola și deschideți-o din nou - tabelul de date temporar va fi șters - și tabelul Tipuri poate fi editat din nou. noul tabel de date poate fi creat din nou.
Asta e tot, putem crea un instrument de lucru foarte puternic cu propriile noastre mâini, în plus, consola noastră este încă foarte rapidă în comparație cu cele profesionale - și acesta este un avantaj foarte mare pentru dezvoltatori! Și, desigur, acum consola noastră funcționează sub orice client! Mult succes in dezvoltarile tale creative!!!
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
Lucrez constant cu Consola mea de interogări, iar recent am dat peste o interogare foarte interesantă în care tabelele temporare nu se aflau în primul pachet de interogări, ci în următoarele - și aici consola mea a devenit puțin deprimată... A trebuit să fac un alt upgrade.
Deci, Managerul de tabele temporare dintr-o interogare nu înțelege întotdeauna că lucrează cu ea)) Prin urmare, trebuie să setați în mod explicit acest Manager de tabele temporare:
&Pe server Procedura Executare interogare pe server () //upgrade2 - definiție explicită a managerului de tabele temporare!
ManagerVT=New TemporaryTablesManager;
Solicitare = Solicitare nouă;
//upgrade2 - definiție explicită a managerului tabelului temporar!
Query.TemporaryTableManager = VTManager;
Request.Text = Object.RequestText;
Această versiune a consolei se află la a treia descărcare. Și obțineți rapid informații. În acest articol, voi încerca să descriu cum să utilizați Query Console și să ofer un link pentru a descărca Query Console. Să aruncăm o privire mai atentă la acest instrument. Descărcați consola de interogări 1C).
În primul rând, pentru a începe să lucrați cu consola de interogări, trebuie să o descărcați de undeva. Procesarea este de obicei împărțită în două tipuri - forme controlate și convenționale (sau uneori numite 8.1 și 8.2/8.3).
Am încercat să combin aceste două tipuri într-un singur tratament - în
modul dorit
munca deschide formularul necesar (
în modul gestionat consola funcționează doar în modul gros
Primul grup de butoane din bara de comandă este responsabil pentru salvarea interogărilor curente într-un fișier extern. Acest lucru este foarte convenabil, puteți reveni oricând la scrierea unei cereri complexe. Sau, de exemplu, stocați o listă de exemple tipice ale anumitor modele.
În stânga, în câmpul „Solicitare”, puteți crea cereri noi și le puteți salva într-o structură arborescentă. Al doilea grup de butoane este responsabil de gestionarea listei de solicitări. Folosind-o puteți crea, copia, șterge, muta o solicitare.
Obțineți 267 de lecții video pe 1C gratuit:
- Executați cererea— execuție simplă și obținere de rezultate;
- Executați pachetul— vă permite să vizualizați toate solicitările intermediare în
- Vizualizarea tabelelor temporare— vă permite să vedeți rezultatele returnate de interogările temporare în tabel.
Parametri de solicitare:
Vă permite să setați parametrii actuali pentru cerere.
În fereastra parametrilor de interogare, următoarele sunt interesante:
- Buton Ia de la cerere găsește automat toți parametrii din cerere pentru confortul dezvoltatorului.
- Pavilion Parametri comuni pentru toate cererile— la instalare, procesarea acestuia nu șterge parametrii la trecerea de la cerere la cerere în lista generală de solicitări.
Setați un parametru cu o listă de valori Este foarte simplu, doar când alegeți o valoare a parametrului, faceți clic pe butonul de ștergere a valorii (cruce), sistemul vă va solicita să selectați tipul de date, unde trebuie să selectați „Lista de valori”:
De asemenea, în panoul de sus există un buton pentru a apela setările consolei de interogare:
Unde puteți specifica parametrii de salvare automată a interogării și parametrii de execuție a interogării.
Textul solicitării este introdus în câmpul de cerere de consolă. Acest lucru se poate face prin simpla tastare a unui test de interogare sau apelând un instrument special - designerul de interogări.
Apelat din meniul contextual ( butonul din dreapta mouse) când faceți clic pe câmpul de introducere:
De asemenea, în acest meniu sunt și așa caracteristici utile, cum ar fi ștergerea sau adăugarea cratimelor (“|”) la solicitare sau obținerea codului de solicitare în această formă convenabilă:
Solicitare = Solicitare nouă; Cerere. Text = " |SELECTARE | Monede.Link |DIN| Directory.Currencies AS Monede"
;
RequestResult = Solicitare. Run() ;
Câmpul inferior al consolei de interogări afișează câmpul rezultat al interogării, motiv pentru care a fost creată această procesare:
Puteți găsi multe console diferite pe Internet. Pentru formularele obișnuite și gestionate, acestea sunt de obicei console complet diferite. Folosind aceasta, puteți descărca consola universală de interogare 1C 8.3 și 8.2, care va funcționa în ambele cazuri. Rețineți că consola de pe interfața gestionată se va deschide doar în clientul gros.
Lucrul cu consola de interogări
În programul 1C, consola de interogări se deschide în același mod ca orice procesare externă: meniul „Fișier” - „Deschidere” sau folosind combinația de taste rapide „Ctrl + O”. Dacă este folosit frecvent, poate fi adăugat la procesarea externă a bazei de informații în sine.
Partea stângă a consolei de solicitări afișează lista solicitărilor dvs. Acest lucru vă permite să stocați nu doar o singură solicitare, ci mai multe simultan. Arborele de interogări are o structură ierarhică, care este foarte convenabilă pentru gruparea acestora.
Făcând clic pe butonul „Adăugați”, puteți adăuga o nouă solicitare, dându-i singur un nume. De asemenea, funcționalitatea încorporată vă permite să creați interogări cu copiere, să mutați în sus sau în jos în listă și multe altele.
Textul cererii în sine este afișat în partea dreaptă a formularului de procesare. Poate fi scris manual sau folosind un generator de interogări. Generatorul de interogări funcționează numai în clientul gros.
În dreapta butonului designerului se află butonul „Insert Query Statements”. Va adăuga imediat o structură de interogare goală cu condiție, grupare, ordine și totaluri.
În dreapta sunt butoane foarte utile care vă vor ajuta dacă această cerere pe care le utilizați când dezvoltați soluții pe 1C.
Butonul vă permite să convertiți solicitarea scrisă în text. În cazul nostru, va arăta ca în figura de mai jos.
Puteți salva cererile într-un fișier sau le puteți încărca din acesta. Acest lucru este foarte convenabil pentru utilizare ulterioară.
Înainte de a executa direct cererea, trebuie să setați parametrii de intrare ai acesteia (dacă există), apoi faceți clic pe butonul „Run request”. De asemenea, este posibil să se execute cereri nu ca un întreg, ci separat ca un pachet.
Modul de vizualizare determină modul în care va fi afișat rezultatul interogării: ca listă, listă ierarhică sau arbore.
Rezultatul execuției va fi afișat în partea de jos a consolei de solicitări. De asemenea, afișează numărul de rânduri primite și timpul de execuție. Dacă este necesar, puteți muta rândurile cu rezultatele interogării.
Foarte des, utilizatorii cer să selecteze unele date și să le salveze în Excel. S-ar putea să ai nevoie și de asta. Pentru a finaliza sarcina, trebuie doar să selectați „Afișare listă” în meniul „Mai multe”. Programul vă va solicita să marcați coloanele necesare.
Pe lângă specificarea unei liste de coloane pentru ieșire, puteți specifica și anumite rânduri aici. Acest lucru este implementat prin evidențierea rândurilor din interogarea în sine. Apoi, în formularul de selecție a coloanei, trebuie doar să setați steagul în setarea „Numai selectat”.
În exemplul nostru, am afișat toate datele rezultatelor interogării. Salvați-le în fișier extern, poate fi copiat din foaia de calcul deschis sau folosind combinația de taste rapide „Ctrl+O”. Există multe opțiuni pentru salvarea formatelor pe care le-am ales „*. xlsx".
După cum puteți vedea, lucrul în consola de interogări este foarte convenabil și util, așa că vă recomandăm insistent să o descărcați și să o puneți în practică.
Una dintre cele mai multe instrumente puternice 1C Enterprise 8 este, fără îndoială, un Generator de interogări. Constructorul este un instrument vizual pentru lucrul cu interogări în limbajul 1C. Dar constructorul are un mare dezavantaj - nu arată rezultatul executării interogărilor. Acest dezavantaj este resimțit în special de dezvoltatorii începători de soluții de aplicații pe platforma 1C:Enterprise 8.3 și 8.2.
În plus, chiar și programatorii 1C experimentați se confruntă adesea cu o situație în care este necesar să facă o analiză „o singură dată” a datelor de bază de informații în diferite secțiuni, dar nu doresc să scrie un raport cu drepturi depline de dragul a unei astfel de „concluzii unice”.
Pentru toate acestea și multe alte cazuri, suntem încântați să vă oferim procesare externă Consolă de interogări cu capacitatea de a procesa rezultate pentru 1C 8.3 și 1C 8.2!
Principalele caracteristici ale Consolei de interogări pentru 1C 8.3 și 1C 8.2:
Procesare universală, rulează pe orice configurație de platforme 1C: Enterprise 8.1 – 8.3;
- rulează în modul 1C:Enterprise;
- interogarea poate fi scrisă manual, sau puteți apela Query Builder;
- arata rezultatul cererii;
- puteți specifica parametrii raportului direct în Query Console;
- poate salva și încărca fișiere de solicitare.
Pentru a lansa Query Console, trebuie să lansați configurația în modul 1C:Enterprise și să deschideți procesarea externă Query Console ca orice alt fișier stocat pe disc. Această procesare va funcționa exact la fel ca și cum ar fi parte dintr-o soluție de aplicație.
Procesare externă Consola de interogări se repetă interfață familiară iar majoritatea funcţionalitate instrumente standard pentru elaborarea interogărilor sistemului 1C:Enterprise 8.3 și 8.2. De asemenea, vă permite să preluați rezultatele interogărilor, interogărilor lot și tabelelor temporare.
Consola de interogări este executată atât în modurile de operare client-server, cât și în serverul de fișiere ale sistemului, atât sub client gros, cât și sub client! Query Console integrează un Query Builder standard, numit prin meniul contextualîn câmpul de text al cererii.
IMPORTANT! Designerul de interogări din clientul subțire nu funcționează, acest element din meniul de deschidere al designerului nu este disponibil. În clientul gros, Generatorul de interogări este disponibil!
În clientul subțire, putem scrie cereri doar manual, toate celelalte funcții funcționează fără modificări.
