Wat is een script voor 1s. "Maak een oproep!" stelt u in staat een gesloten cyclus van interacties met de klant op te bouwen

In dit artikel zal ik proberen een aantal tips te geven over het instellen van scriptactivering op sites die 1C gebruiken.

Waarom zou dit nodig kunnen zijn? In mijn voorbeeld moest ik het php-script uitvoeren om de download op de site te activeren, waarvan het cms 1C-Bitrix is. Die. het bestand wordt verwijderd uit 1C en geeft de site een signaal om het bestand op te halen. Aldus wordt een hoge efficiëntie van uitwisseling met de site bereikt.

In feite is er niets moeilijks in dit proces, maar vanwege de specifieke kenmerken van deze procedure kan de programmeur wat problemen hebben met deze actie.

Taakomschrijving:

Na het uploaden van het databestand vanuit 1C was het noodzakelijk om het bestand zo snel mogelijk te uploaden naar de sitedatabase. Om dit te doen, heeft de programmeur die de site ontwikkelt een script gemaakt dat twee acties uitvoerde: het controleerde de autorisatie en activeerde de uitwisseling vanaf de site. Het php-script zelf zag er als volgt uit: "http:// /1c_prices_import_run.php".

Laten we eens kijken hoe dit script werd gelanceerd.

GET-verzoek van 1C

Eerst wordt een object gemaakt HTTP-verbinding", met behulp waarvan wij autorisatie uitvoeren:

Krijg gratis 267 1C-videolessen:

HTTP = Nieuwe HTTP-verbinding(" /1c_prices_import_run.php

In de parameters die ik pass php script adres, wachtwoord en login. Dit is voldoende als u geen andere lastige voorwaarden heeft, zoals beveiligde autorisatie en een proxyserver.

Mijn tweede stap was om de verbinding te controleren, in het geval van een succesvolle autorisatie, stuurde dit script het woord "succes" naar mij terug:

HTTP.Get(" http:// /1c_prices_import_run.php?mode=checkauth", ResponseFileName); // autorisatiecontrole

In de parameters van de Get-methode (vergelijkbaar met GET), specificeren we de parameter " ?mode=controleren", waaruit blijkt dat het gewoon een ping is. De tweede parameter, "ResponseFileName", is het bestand waarnaar het antwoord van de server wordt geschreven.

HTTP.Get(" http:// /1c_prices_import_run.php?mode=query", RequestFileName);

Dat is alles. Alles is vrij eenvoudig en werkt perfect aan de 1C-kant.

Nou, uiteindelijk zal ik de hele code in zijn geheel laten zien:

RequestFileName= GetTempFileName();

HTTP = Nieuwe HTTP-verbinding(" http:// /1c_prices_import_run.php«,SettingDataExchange.HTTPExchangeUserName,SettingDataExchange.HTTPExchangePassword,); //verbinding

Uitzondering

Einde poging;

HTTP.Get( http:// /1c_prices_import_run.php?mode=checkauth", RequestFileName); // autorisatiecontrole

Uitzondering

Einde poging;

ResponseFile = Nieuw bestand (ResponseFileName);

Als ResponseFile.Exists() Dan

De stelling dat open source is gemaakt door enthousiaste geeks heeft in onze tijd zijn relevantie verloren. Desalniettemin werd de ideologie van open source zomaar geboren. Coole programma's die 's nachts zijn geschreven door bebaarde (en niet zo) gekken, ongeïnteresseerd, alleen om de wereld een betere plek te maken - hebben de wereld van softwareontwikkeling veranderd.

Elke programmeur droomt er stiekem van om iets groots en helders te doen voor iedereen. Als je me vertelt dat je niet een van die mensen bent, dat je alleen graag tickets sluit in een werkende bugtracker, en je droomt er niet van om je project vrij te geven aan de grote wereld, dan zal ik je niet geloven. Of ik zou een carrièreswitch voorstellen. Ik ben ervan overtuigd dat een programmeur een kunstenaar is, en het is belangrijk voor een kunstenaar om iets van zichzelf te doen, misschien gewoon "op tafel" - maar om het te doen.

Op een dag kwam er een idee voor een project in mijn hoofd. Het idee was puur onderzoek en ik was niet van plan er een soort "product" van te maken. Bovendien had ik nog nooit open source-projecten gedraaid en wilde ik heel graag proberen hoe het allemaal werkt. Wat er van kwam - onder de snee.

Helemaal aan het begin van het levenspad van het project schreef ik er al over op Habré. Toen waren het de eerste stappen, de code was rauw, maar het werkte. Ik wilde dat het project de interesse wekte van andere auteurs, aangezien ik het natuurlijk niet alleen zou hebben gedaan en het in het algemeen zou hebben opgegeven. Dit zou in principe zijn gebeurd als ik mijn eerste pull-request niet van een vreemde had gekregen. Maar eerst dingen eerst...

Waar gaat dit over?

Ik heb mijn eigen implementatie gemaakt van een stapelmachine die scripts uitvoert in de 1C: Enterprise-taal. Of, om het simpeler te zeggen, een open tolk van de 1C-taal en een open implementatie van enkele standaard 1C-klassen. Tegelijkertijd werd een duidelijk toegepast doel van het project vastgesteld - om 1C-bijnamen een scripting-automatiseringstool te geven die gemakkelijk te leren zou zijn. Het project kreeg de naam 1Script.

En dus wordt het project gepubliceerd op Habré en op de gespecialiseerde 1C-portal infostart.ru. Ik wacht op feedback. Ik kreeg de eerste reactie op de miste en lachte hartelijk. Het onderwerp op het forum heette “Tolk 1C op Habré. Laten we zwijgen?" Er zijn veel goede mensen op de mist, ik was blij :)

Toen kwamen min of meer adequate vragen, die ik ijverig beantwoordde, waarna de artikelen in de normale modus vanaf de eerste pagina's ergens naar beneden gingen en de interesse in het project zakte. Nou, het was het verwachte einde, ik was een beetje geïrriteerd, maar niet veel. Eigenlijk rekende ik niet op een bijzonder resultaat. Gebabbeld en oké. Dagen gingen voorbij, ik maakte iets af, postte zelfs een andere versie, maar niemand behalve ik had het nodig. Mijn vuur is opgedroogd. Hoewel ik niet teleurgesteld was, stopte ik met het schrijven van nieuwe code.

Tweede wind

Ongeveer twee maanden na de publicatie werd ik benaderd door Sergey Batanov (Serega, hallo! :) - een prominente kerel in de 1C-gemeenschap, die zijn hulp aanbood bij het ontwikkelen van de standaardbibliotheek. Het was de 1C-ovsky klasse "Tabel van Waarden". Natuurlijk ging ik akkoord. En toen ik de echte code zag die Sergey stuurde, was ik echt zo blij als een kind. Het gebeurt vaak op internet als iemand iets in woorden aanbiedt, maar vaak komt het niet ter zake. En hier is de echte live code die werkt, die volledig adequaat is, die in het project kan worden ingevoegd!

Tegelijkertijd is de taak vrij groot, ik zou te lui zijn om het zelf te doen. En hier - een tastbare, echt nuttige, meetbare bijdrage aan het totale project door regels code! Kortom, ik zal niet oneerlijk zijn als ik zeg dat het Sergey was die ervoor zorgde dat het project niet door mij werd opgegeven. Het is een geweldige inspiratie om hulp te krijgen van een vreemde. Zo maar, omdat hij geïnteresseerd was in wat je begon.

Geleidelijk begon ik feedback te krijgen van mensen die de engine hadden uitgeprobeerd en vroegen "waar is deze functie?", "Maar hoe moet ik dit doen?" Ik moest al deze vragen beantwoorden, zeggend dat dit een prototype is, en deze functies met spoed zelf toevoegen. Maar het enthousiasme ging van de schaal: "Mensen zijn geïnteresseerd en proberen te solliciteren", dus nieuwe functies werden vrij snel toegevoegd. Aanvankelijk had de standaardbibliotheek niet eens functies om met bestanden te werken.

Verder

Na enige tijd schreef Alexander Kuntashov me een vraag over de integratie van 1Script en het Snegopat-project (www.snegopat.ru). Wie weet niet - dit is zo'n verscherper voor 1C. Hiermee kunt u scriptplug-ins maken voor de 1C Configurator en er is een hele gemeenschap van auteurs van dergelijke plug-ins.
Deze plug-ins zijn geschreven in JavaScript en vereisten daarom kwalificaties die verder gingen dan de standaard 1C-programmeur. Hierdoor is uiteindelijk ook de ontwikkeling van het plug-in-ecosysteem vertraagd. Het aantal mensen dat de Configurator wil verbeteren is ongeveer gelijk aan het totale aantal 1C-bijnamen, maar de noodzaak om JavaScript te leren schrikt de auteurs van potentiële meesterwerken af.

Nogmaals, ik was dolblij met de vraag naar mijn geesteskind, smeekte de auteur om de distributiekit van Snegopat en schudde het stof van mijn kennis van C ++. Er was veel meer stof dan kennis, maar de creatieve jeuk deed zijn werk en ik stortte me in MSDN.

Ongeveer een maand later werd het in de 1C-configurator mogelijk om plug-ins rechtstreeks in de 1C-taal te schrijven zonder over te schakelen naar het JavaScript-editorvenster. Tegelijkertijd werden de eerste kritieke bugs van de engine opgelost en werd de interne architectuur aanzienlijk herzien.
Ik kreeg een bedwelmend plezier van het communiceren met C++, COM, ATL en al deze dingen, na vele jaren exclusief met 1C te hebben gewerkt. Nou ja, en ook van het feit dat hij iets nuttigs, tastbaars deed voor de 1C-nick gemeenschap.

De eerste ervaring met gevechtsgebruik

Rond dezelfde tijd (ik weet het niet meer precies) kwam het project onder de aandacht van Alexei Lustin () (Lech, hallo jij ook!) - een van de 1C-bijnamen van een bekend en gerespecteerd persoon. Dit viel samen met mijn zoektocht naar een nieuwe baan. Ik was op zoek naar interessante bedrijven op de markt, en Alexey was op zoek naar specialisten voor het Continuos Integration / Continuos Delivery project voor 1C nicknames. Toen zag Lesha mijn project (en bijnaam) al op Habré, en ik wist al dat een bepaald team van geavanceerde 1C-bijnamen interessante niet-standaard dingen op het netwerk deed.

Op dat moment wist de community al dingen als unit-testen, 1C-code opslaan in git, BDD + komkommer voor 1C, enzovoort. Alexei leek mij de meest toegankelijke van deze gasten en ik schreef hem een ​​brief met de vraag of hij een interessante baan had. Dus, samen met mijn project, kwam ik in een vrolijk gezelschap van nerds die zich tegen die tijd hadden verzameld in het bedrijf waar Alexey werkte.

Op dat moment had de engine al de minimale set aan mogelijkheden die nodig zijn voor het script, en het kon (naar mijn idee) in principe worden gebruikt als script voor het samenstellen en implementeren van 1C-databases.

Waarom hiervoor zelfs een nieuwe motor gebruiken?

Eigenlijk zijn er een miljoen scripttalen, het is niet duidelijk waarom er nog een nodig is, en zelfs een onbekende - zal de lezer van Habr vragen - en hij zal niet helemaal gelijk hebben. Strategisch gezien was het toekomstige product bedoeld voor 1C-bijnamen en zou het van ontwikkelaar tot ontwikkelaar moeten leven, ongeacht personeelswisselingen in het bedrijf. Er is een objectief probleem in de 1C-nick-gemeenschap: er zijn veel geweldige specialisten onder hen, maar om de een of andere reden wil de gemiddelde 1C-nick geen andere taal leren nadat hij 1C goed onder de knie heeft. Ik weet niet wat de reden is voor dit fenomeen, waarschijnlijk omdat 1C regels (ironie)? Mensen komen naar 1C met kennis van Java, C/C++, microcontrollers, Delphi of niets, maar ze blijven vaak in 1C en aarzelen om terug te keren naar hun oorspronkelijke ecosystemen.
Ik voorzie nu een golf van woede, maar luister alsjeblieft tot het einde naar de stelling. Er zijn echter uitzonderingen op elke regel, maar bij het plannen van een systeem dat meerdere generaties ontwikkelaars moet overleven (geen biologische, maar menselijke generaties natuurlijk), dan zul je hoogstwaarschijnlijk een specialist vinden die het kan ontwikkelen als het in 1C is geschreven . Als het een python is (of vul je favoriete taal in), dan zul je een pythonist moeten inhuren die 1C heel goed kent. En na zijn overstap naar grote bazen zul je op zoek moeten naar een ander van hetzelfde, met competenties op het gebied van 1C. En als het meteen een 1C-taal is, dan hoef je alleen maar een 1C-bijnaam te vinden die 1C goed kent en dat is voldoende.
Met andere woorden, het systeem zal vasthoudender zijn en door meer specialisten kunnen worden ontwikkeld als het is geschreven in een voor iedereen bekende taal.

Zo werd de reikwijdte van 1Script duidelijk: dit zijn DevOps en soortgelijke taken ten behoeve van 1C-projecten.

Eerste hobbels en goede ontwikkeling

Het eerste min of meer grote script dat ik schreef (daarvoor waren er teksten van niet meer dan honderd regels) zorgde ervoor dat de engine crashte. Met een bepaalde combinatie van parameters en oproepketens werd de besturing overgebracht naar een onbekende plaats in de code en crashte de applicatie. Ik moest de implementatie van de call-stack en de afhandeling van uitzonderingen bijna volledig herschrijven. Het was een uitdaging in de stijl van “Oh je bent zo! Nou, ik zal je repareren!" De vechtzekering maakte het mogelijk om de benodigde modules in één dag te herschrijven en bovendien een aantal bugs te identificeren. De code begon stabiel te lopen. Ik heb een nieuwe release uitgebracht. Gaandeweg, aangezien ik nu bezig was met Continuous Integration, kwam ik tot het besef dat het project ook een buildserver en release-automatisering nodig had. Daarnaast sloot hij zich aan bij het project, dat onder de 1C-bijnamen bekend staat als coryphaeus en goeroe van 1C-testen. Hij maakte een toolkit voor het testen van de engine op basis van zijn xUnitFor1C-framework. Dus kreeg ik acceptatietesten van gedrag, ook geschreven in de 1C-taal. Ik pakte TeamCity op mijn thuisserver en zette nachtelijke builds op met testruns. Onderweg werd ik met enthousiasme geladen - het project leeft voort en krijgt nieuwe medewerkers. Het was enorm inspirerend.

Sinds ongeveer drie of vier maanden heeft de engine class-bibliotheek eindelijk alles wat nodig is voor de meeste scripttaken: netwerkfuncties, werken met archieven, XML, enzovoort zijn verschenen. Ons CI-project voor 1C is succesvol gelanceerd.

Rond dezelfde tijd begonnen, nogmaals, nieuwe geïnteresseerde gebruikers naar het project te komen. Ze vroegen om features, vonden bugs, eisten nieuwe releases.
De stroom van functies, de toewijzing van bibliotheekcode, gekoppeld aan de behoefte aan een eenvoudig releaseschema, leidden me naar zoiets interessants als het groeiprobleem. Maar over haar, even later.

In november 2014 was ik uitgenodigd om te spreken op de prestigieuze 1C Infostart Event conferentie in St. Petersburg. Natuurlijk stemde ik ermee in en ik nam 1Script als onderwerp van de toespraak. Het onderwerp werd goedgekeurd, wat voor mij in de eerste plaats betekende dat het project enigszins populair was (d.w.z. luisteraars zullen waarschijnlijk komen, omdat ze er tenminste iets over hebben gehoord), en ten tweede hoopte ik bijdragers aan te trekken, aangezien er bijna geen tijd voor de ontwikkeling van de motor.
Speciaal voor de conferentie heb ik zelfs een speciale leuke CGI-modus gemaakt, waarin scripts kunnen worden uitgevoerd onder de controle van een HTTP-server en HTTP-output kunnen genereren. Sites in de 1C-taal zijn niet langer de nachtmerrie van een hoster, maar een harde realiteit (grapje).
De toespraak op Infostart kan worden beschouwd als de eerste publieke aankondiging waarbij 1Script zich niet langer schaamde om een ​​product te worden genoemd, een tool die in staat is om specifieke problemen op te lossen. Het was niet langer een experiment, maar een gevechtsproduct. Hoewel nog steeds in beta-status.

Groeiprobleem of valkuilen bij projectondersteuning

Het bleek dat de aanwezigheid op uw afdeling van een gevraagd project, zelfs een klein project, zo'n aanzienlijke last van overheadkosten met zich meebrengt. Om te beginnen is het een featurestream. Wensen komen veel vaker voor dan toezeggingen die die wensen uitvoeren. Het is verplicht om strikt rekening te houden met de versies waarin bepaalde fouten zijn gecorrigeerd. Het is vereist om gebruikers op de een of andere manier op de hoogte te stellen dat een bug is opgelost sinds versie X of een nieuwe functie is verschenen. De groei van functionaliteit vereist documentatie en documentatie heeft de neiging verouderd te raken.
Welnu, het grappige is dat de technische infrastructuur van de eigenlijke "ondersteuning" vereist is. We hadden een website nodig, een documentatiegenerator, een build/deploy-server, enzovoort, enzovoort... Er waren financiële investeringen in de infrastructuur nodig - minimale, maar toch investeringen.
Toen ik aan een onderzoeksproject begon, kon ik me niet eens voorstellen dat er zoveel organisatorische en technische problemen zouden zijn waarmee ik te maken zou krijgen naarmate het project groeide. De overgang naar de git-flow techniek heeft hierbij veel geholpen, het werd makkelijker om het zelf uit te zoeken en met gebruikers te communiceren over versies en branches.

Crowdfunding-ervaring (vreselijk woord)

Begin dit jaar probeerde ik een experiment uit te voeren - ik organiseerde een collecte van donaties voor infrastructuur - een domeinnaam en hosting. Ik vroeg me af hoeveel het project zou kunnen betalen voor zijn eigen bestaan. Het resultaat was dat mensen die ik niet kende inderdaad elk ongeveer 100-500 roebel stuurden. wat genoeg was om te betalen voor een domeinnaam in de .io-zone. Daarna werd de campagne stopgezet en stopte de geldstroom. Het werd niet volledig terugverdiend, hoewel enige financiële steun werd ontvangen.
Het belangrijkste is dat het proefschrift over de effectiviteit van het donatiemodel als zodanig in de natuur is getest. Conclusie - in mijn geval kan donatie nauwelijks effectief worden genoemd, hoewel het niet nul was.

Bibliotheek met handige scripts

In anderhalf jaar coderen in 1Script zijn er bibliotheekblokken ontstaan ​​die je zelf kunt gebruiken en aan anderen kunt aanbevelen. Op een natuurlijke manier heb ik een aantal ontwikkelingen verzameld die geschikt waren voor hergebruik.
Dit leidde ertoe dat de mogelijkheid om "pakketten" van derden te verbinden, ook geschreven in 1Script, aan de engine werd toegevoegd. Het resultaat was een ander project genaamd oscript-library. (https://github.com/EvilBeaver/oscript-library) Deze bibliotheek vereiste natuurlijk ook infrastructuur, documentatie, updates voor eindgebruikers en meer. Maar de stroom van bijdragen van 1C-bijnamen is aanzienlijk gegroeid. Pakketten worden immers ontwikkeld in een al bekende taal waardoor u direct kunt profiteren, bestaande ontwikkelingen kunt overdragen, etc. De gemeenschap van "1C-scriptschrijvers" begon te groeien, wat enorm werd vergemakkelijkt door het tweede rapport op het Infostart-evenement in 2015.

Hoe ziet het eruit

Import gebruikt een speciale preprocessor-richtlijn #Gebruik (#Gebruik) Het zit niet in het originele 1C-platform, maar om het importeren van bibliotheken te vergemakkelijken, moesten we afstappen van de canonieke syntaxis en een oplossing lenen van andere ecosystemen.
#Use json // classReaderJSON wordt gedeclareerd in de bibliotheek en is beschikbaar dankzij de richtlijn #UseReaderObject = NewReaderJSON(); // sommige code volgt // ...
Een specifieke oplossing werd al ontwikkeld door een team van auteurs, toepassingsscenario's, valkuilen werden uitgedacht, Google Docs werd gebruikt als brainstormtool.

pakket manager

Om pakketten te beheren, werd een eenvoudige pakketbeheerder op de knie geschreven, genaamd OPM (OneScript Package Manager). Het is ook geschreven in 1Script en is een console-gebaseerd hulpprogramma voor pakketbeheer. Op dit moment heroverwegen we de pakketinfrastructuur en werken we aan een productieklare versie van opm.

Project vandaag

Tegenwoordig is 1Script een stabiele, met succes gebruikt in tientallen bedrijven automatiseringstool voor 1C-bijnamen. Daarnaast is OneScript al een soort merk, deze naam is bekend in de community, de tool wordt actief gebruikt, geschreven, vragen gesteld, besproken en, wat vooral leuk is, afgerond.
Bovendien is een bibliotheek met herbruikbare codepakketten een bijna integraal onderdeel van het project. Het is klein, maar dekt een aanzienlijk deel van de taken die dagelijks worden opgelost door een typische 1C-bijnaam.
Dit is niet langer zomaar een "1C-tolk". De community heeft een ecosysteem van handige en populaire tools gecreëerd.
Voor mij was het een unieke ervaring, ik kreeg woorden (en daden) van steun van tientallen mensen die ik niet kende (en nu al ken). Een programma dat ik alleen begon om het "uit te proberen" is uitgegroeid tot een werkend project dat wordt gebruikt in echte gevechtsmissies. Bovendien is er een enorme ervaring opgedaan in het beheren van zo'n open-sourceproject - ondersteuning, onderhoud, infrastructuur, enz ...
En het allerbelangrijkste: je krijgt het plezier om iets te doen wat je nodig hebt.

Wat we hierna gaan doen

Het actieve gebruik van de pakketbibliotheek bracht een aantal tekortkomingen en ongemakken aan het licht. We zijn van plan aanpassingen te doen aan de pakketinfrastructuur en de functionaliteit van de pakketbeheerder uit te breiden. We zijn ook van plan om de set bibliotheken uit te breiden, zo werken we momenteel aan een wrapper voor de Docker API. We beheren docker-containers met behulp van 1C-scripts en ontwikkelingen over dit onderwerp zullen waarschijnlijk ook worden gepubliceerd wanneer ze te binnen schieten. Dit zal resulteren in een vereenvoudigde DSL voor containermanipulatie vanuit 1script.

technische samenvatting

• Programmeertaal - C#, .NET v4.0/Mono 3.1x
• Ontwikkelomgeving - VS 2013-2015
• De naam van de interpreter is oscript.exe (uitvoeren voor uitvoering - oscript )
• De extensie van het scriptbestand is .os
• De bestandsextensie van het pakket is .ospx
• Codeprestaties - in de meeste metingen tot 4 keer sneller dan het originele 1C-platform. In ieder geval niet langzamer dan zij.
• Engine-repository - github.com/EvilBeaver/OneScript
• Bibliotheekrepository - github.com/oscript-library

Ik schrijf de website van het project niet, ten eerste, zodat het niet als PR klinkt, en ten tweede kan het gewoon niet tegen het habra-effect. Als je een eigen project hebt dat je graag aan het licht zou willen brengen, laat me je dan een paar tips geven op basis van persoonlijke ervaring.

• Durven! Als je je project op tafel houdt en er niemand over vertelt, dan zal niemand er iets van weten. Begin met een artikel over Habr. Eén artikel is niet genoeg. Vermeld uw project in forums die zijn gewijd aan het onderwerp van uw project, geef voorbeelden van succesvolle toepassing.
• Wees voorbereid op het feit dat er veel suggesties van mensen zijn, en veel minder echte commits. De aanpak in de stijl van "Het is open-source, je hebt het nodig, je doet het", zal helaas niet werken.
• Denk vooruit om het 'groeiprobleem' op te lossen. De groei is meestal explosief en het is vrij moeilijk om met een sterk toegenomen takenpakket om te gaan.

Tags toevoegen

achtergrond

Tijdens de implementatie van één project werd het noodzakelijk om javascript (hierna JS genoemd) code uit te voeren onder de besturing van het HTML Document Field-object, met het resultaat verkregen in 1C. De voorbeelden in de gevonden artikelen leken niet erg handig in gebruik (puur persoonlijke mening). Er werd besloten om te proberen een andere, eenvoudigere oplossing te vinden, er werd niet meer dan 1 dag uitgetrokken voor het zoeken.

DIV.setAttribute("onclick", "alert("Coördinaten");");

Voer het script uit

DIV.klik();

TA-DAH. alles werkt

Procedure ExecuteScript(TextScript) DIV = Elements.doc.Document.getElementById("TEST"); DIV.setAttribute("onclick", TextScript); DIV.klik(); EindeProcedure

Update vanaf 08/02/2016

Een andere manier om JS aan te roepen werd voorgesteld in de opmerkingen (bedankt), als je de mogelijkheid hebt om de HTML-code van het document te wijzigen, dan kun je er een functie in schrijven en het dan aanroepen. de JS-code eraan doorgeven.

en dan in 1C:

Elements.DocumentHTMLField1.Document.parentWindow.exec("alert("OK")");

Een JS-resultaat retourneren in 1C

Om het resultaat van het script over te brengen naar 1C van het FieldHTMLDocument-object, gebruiken we een gebeurtenis. Laten we een OnClick-gebeurtenis binden aan het HTMLDocument-veld dat 3 parameters als invoer ontvangt:

1. Het element waarin de gebeurtenis plaatsvond (het veld van het HTMLDocument zelf)
2. gebeurtenis object
3. Teken van de implementatie van het standaardgedrag

Om een ​​gebeurtenis bij klikken te activeren, moet u de volgende js-code uitvoeren:

Varevt = document.createEventObject(); // maak een leeg gebeurtenisobject evt.propertyName = "function1"; // Ik stel voor om de naam van het resultaat in de propertyName prop te plaatsen (zoiets als een type, of de naam van de functie waarvan de gegevens zijn ontvangen) evt.data = "156"; //we zullen de resultaatgegevens doorgeven aan de data prop document.body.fireEvent("onclick", evt); // voer de gebeurtenis uit op clickHtmlDocumentField

Na het uitvoeren van deze js-code in de procedure, wanneer op de tweede parameter wordt geklikt, komt het gebeurtenisobject dat we hebben gemaakt. Wat vrij gemakkelijk te hanteren is.

Voorbeeld van antwoordparsering.

&OnClient // haal de naam en het resultaat van de gebeurtenis op Procedure DocOnClick(Element, EventData, StandardProcessing) OperationName = EventData.Event.propertyName; OperationData = EventData.Event.data; If OperationName = "" Dan //niet onze gebeurtenis Return; Stop als; If OperationName = "Function1" Then // procesresultaat ElseIf OperationName = "function2" Then // procesresultaat //...... EndIf; EindeProcedure

Deze methode maakt het gebruik van wachthandlers overbodig en biedt een handige gebeurtenis-ID. Door de identifier weten we precies welke gegevens we hebben ontvangen en hoe we deze moeten ontleden.

Aanvullingen vanaf 26-03-2016

En ook op deze plaats deden zich misverstanden voor (de fout wordt alleen op het platform gereproduceerd 8.3.5.1570, maar om deze situaties in de toekomst te voorkomen, zal ik een oplossing geven) De reden zelf - toen het formulier opnieuw werd gestart met het HTML-veld van het document op het moment van de procedure-aanroep, bij het klikken op het HTML-veld, bleef de platformaanroep hangen en bracht het hele COM-object naar beneden (er is een uitzondering opgetreden (html-bestand): niet-gedefinieerde fout). De oplossing was om de standaarduitvoering van de klikgebeurtenis uit te schakelen en de gebeurtenisborrelmodus uit te schakelen. Hoe u dit doet, zie hieronder.

// schakel gebeurtenisborrelen uit

Evt.cancelBubble = waar;

// standaardgedrag uitschakelen

Evt.returnValue = onwaar;

Als resultaat krijgen we een functie om gegevens van JS naar 1s over te dragen.

Functie return1c(name,data)( var evt = document.createEventObject(); evt.propertyName = naam; evt.data = data; evt.cancelBubble = true; evt.returnValue = false; document.fireEvent("onclick",evt ););

Conclusie.

Door deze methoden te combineren, kunt u vrij eenvoudig de js-code uitvoeren die u nodig hebt en gegevens in 1C ontvangen voor verdere verwerking.

Implementatie voorbeeld in

Operator : "Hallo! Mijn naam is Maria, het bedrijf "Windows-alles-op-de-wereld.""

Cliënt : "Ik heb niets nodig"

Operator : "Maar we hebben de beste voorwaarden en..."

Cliënt (onderbreekt):"Maria, tot ziens!"

Operator (praten):"We zijn sinds 2003 actief in de markt en sindsdien..."

Cliënt (Hang de telefoon op):...

Maria draait het volgende nummer.

Iedereen kent het vervelende verhaal. Na zo'n dialoog zal de klant een negatieve nasmaak hebben en OknaVsemNaSvete verloor domweg het kostbare contact. Hoewel de operator Maria aan het einde van de maand een salaris ontvangt, dus in deze situatie is niet iedereen een verliezer.

Het meest beledigende in deze situatie is dat Maria het echt heeft geprobeerd, ze denkt oprecht dat "ze gewoon geen klanten nodig hebben - ze nemen het niet" en in het algemeen "maar hoe kan ik ervoor zorgen dat hij niet ophangt?". Het feit dat iemand KPI beschouwt, Mary naar de gloeilamp - ZP zal hoe dan ook worden gegeven. Aan het einde van de maand zal het hoofd Aleksey 1001 records van het gesprek van zijn operators bestuderen (het duurt minstens 2-3 dagen per maand), zijn afdelingen uitschelden - hij zal als reactie de excuses herstellen dat "nogmaals, de oproep basis was niet het doelwit ...". Alexei zucht bedroefd en deelt de salarissen uit aan iedereen. De volgende maand begint.

Het team heeft zich vriendschappelijk ontwikkeld, er is veel werk verzet, maar zo kan het niet doorgaan. (Met)

Wat is in dit geval erg (maar opgelost met weinig bloed):

De aanpak van operators op het werk

1. Ze bellen automatisch. Maar zonder een duidelijk doel is het moeilijk om een ​​goede dialoog op te bouwen;
2. Ze weten niet of tevergeefs te reageren op het bezwaar van de cliënt;
3. Ze hangen op zodra ze aan het succes van het gesprek beginnen te twijfelen;
4. Ik weet zeker dat hij een salaris zal ontvangen voor het proces - daarom doet hij alles langzaam, met een pauze om te rusten, zonder de nodige motivatie;
5. Iedereen slacht de bestaande regels voor het bellen van klanten af ​​en klaagt over de complexiteit en de hoeveelheid instructies;

leiderspositie

Al deze problemen worden opgelost in het subsysteem "Rangschik een oproep!"

(het kan worden "ingebed" in uw 1C, u kunt het afzonderlijk gebruiken).

"Maak een oproep!" kan:

• Scripts opstellen - spraakmodules voor operators
• Scriptbeschikbaarheid toewijzen aan verschillende groepen en branches
• Verzamel statistieken over het gebruik van scriptblokken, het behalen van doelen en mislukkingen, meet conversie
• Download de oproepbasis uit Excel of gebruik de nummers van klanten die eerder zijn gebeld
• Statistiekenbord weergeven voor operators
• Maak bestellingen, claims tijdens de passage van het script, vul eventuele objecten van uw database in.
• Beperk "klik" willekeurig tot scriptstatements
• Werken met sip-telefonie
• Werken met e-mail
• Zet e-mails, siteverzoeken om in leads en klantbehoeften door ze naar het systeem te uploaden
• Klanten, leads en deals beheren

"Maak een oproep!" stelt u in staat om een ​​gesloten cyclus van interacties met de klant op te bouwen.

De fasen van dergelijk werk worden naar uw smaak aangepast. Bijvoorbeeld als volgt:

Optie nummer 1

1. Het systeem heeft een nieuwe potentiële klant ontvangen
2. De operator belde volgens het algoritme, verduidelijkte de noodzaak van de service
3. Het doelcontact is overgedragen aan de verkoopafdeling
4. De manager bouwt een relatie op met de klant
5. Manager sluit een deal

Optie nummer 2

Of zo:

1. De telefoniste ontvangt een inkomende oproep
2. Bij het maken van een oproep wordt een scenario gelanceerd voor het bepalen van de behoeften van de klant, het gewenste bedrijf wordt bepaald
3. Tijdens het werk stelt de operator een klantorder op, specificeert de leveringsdatum
4. De bestelling wordt overgedragen aan de leveringsafdeling voor montage

Optie nummer 3

Nou ja, of een andere optie:

1. Er is een nieuwe aanvraag gedaan op de site, de site verwijst de brief door naar de database op deze applicatie
2. De basis ontleedt de brief, "haalt" de gegevens van de tegenpartij, de berichttekst eruit, creëert een behoefte en een taak
3. Een gratis telefoniste pakt de taak op, belt de klant, lost het probleem op
4. Als de klant alles leuk vond, wordt ofwel een bestelling gemaakt of wordt de klant overgedragen aan managers

Optie nummer 4

Kom met een van uw opties!

Aan het einde van de maand ontvangt de manager rapporten:

1. Volgens uitgebreide statistieken van klantbehoeften - hoeveel waren er, hoeveel waren gekwalificeerd, hoeveel werden geweigerd - per status
2. Over het werk van conversatiescripts en operators
3. Volgens contacten met klanten - waar hebben ze het over gehad, hoe vaak. Hoeveel hebben er gebeld, hoeveel brieven zijn er geschreven.

Hoe het werkt

In "Stel de oproep in!" ingebouwde subsystemen (klikbaar):

Scripts

Met scripts bedoelen we enkele gerelateerde acties volgens het algoritme. Bijvoorbeeld,

1. Uitgaande oproep- om een ​​product of dienst te verkopen, uit te nodigen voor een promotie, een vragenlijst in te vullen
2. Binnenkomend telefoongesprek- om de bestelling correct te verwerken, vergeet de korting en levering niet
3. Een document invullen- standaardformulier in de vorm van een assistent

Hoe te gebruiken

• Maak gesprekspatronen voor operators in de constructor
• Volledige aanpasbaarheid - geef alle velden weer om het oproepscript in te vullen (vragenlijstgegevens, om een ​​bestelling in te voeren, enz.)
• Plaats links naar interne Knowledge Base-artikelen zodat de operator eventuele technische vragen kan beantwoorden
• Maak bestellingen tijdens het belscript, verzamel claims, stuur brieven en wijzig de status van potentiële klanten
• Geef stermanagers meer vrijheid in het belscript. Dergelijke werknemers houden niet van beperkingen, hun prestaties zijn hoger wanneer het gesprek niet 100% beperkt is - maak een gespreksscript voor dergelijke managers, dat zal worden gebruikt als een snelle vragenlijst, en de overgang tussen blokken zal vrij zijn. Je ontvangt ook statistieken voor deze sterren en ze zullen zich niet "geperst" voelen door het gespreksscript
• Controleer het werk van operators aan de hand van oproepscenario's en leg de resultaten van de controle vast in een speciaal document
• Weg met hacky-oproepen met behulp van concurrerende instellingen voor scriptuitvoering
• Stuur offertebrieven tijdens het callscript-proces, creëer klachten van ontevreden klanten tijdens het proces

Scripts zijn het belangrijkste subsysteem van "Arrange a call!". Hieronder staat iets meer over de instellingen aan de hand van een voorbeeld.

Voorbeeld

Er kan bijvoorbeeld zo'n taak zijn voor operators: "Je moet de lijst met nummers bellen, niet-gerichte contacten verwijderen en leads overdragen aan managers." Om dit te doen, zullen we een script in het systeem maken, potentiële deals van xls uploaden, operators zullen deals volgens het script doorlopen, niet-target-deals verwijderen en target-deals zullen worden overgedragen aan managers voor werk. Laten we eerst een script maken.

Een nieuw script maken

1. We maken een stroomdiagram van dit script - wat de operator zal zeggen, welke waarden hij moet kiezen en wat het systeem hem vervolgens zal bieden
2. We stellen extra scriptvelden in - op elk blok van het script moet bijvoorbeeld de volledige naam van de klant en zijn bedrijf zichtbaar zijn
3. Specificeer snelle overgangen van elk blok. In elk blok worden knoppen voor snelle overgangen weergegeven (de operator kan op elk moment worden gevraagd "Wat voor soort bedrijf bent u?" - in dit geval klikt de operator op de snelle overgang, leest de bloktekst over het bedrijf en keert terug naar het vorige blok)
4. We stellen het script in - wordt het script gelogd, is het schema zichtbaar, is het nodig om SIP te gebruiken, welke taken moeten worden uitgevoerd tijdens het script, enz.
5. We kennen er toegangsrechten aan toe - wie dit script kan zien, er een nieuwe oproep mee kan maken, enz.

In het blokschema van het script geven we aan wat de operator moet zeggen, welke antwoordmogelijkheden de klant heeft en welke velden de operator in dit stadium moet invullen.

1. De tekst van de toespraak van de operator. U kunt aanvullende details uit eerdere scriptblokken of gemeenschappelijke velden invoegen. Kan tekst opmaken
2. Tekstparameters worden hier ingesteld - de schermafbeelding laat zien dat [Naam] wordt ingevuld vanuit de bedrijfsnaam
3. We stellen vast of het doel is bereikt als deze blokkade is bereikt, in welk stadium de blokkering hoort ("contact leggen", "secretaris bereiken", etc.) en welk resultaat is bereikt als deze blokkade is bereikt

Het scriptblok kan aanvullende semantische betekenissen hebben:

• U kunt er velden op plaatsen. De operator moet bijvoorbeeld kiezen hoe de goederen bij de klant worden afgeleverd - afhaling, koerier in de stad of intercity. Totdat de operator dit veld invult, gaat het script niet verder. Welnu, in het schema kun je aangeven dat als je de intercity hebt ingevuld, je het ene blok moet tonen, als het per koerier is, dan een ander.
• De aangemaakte blokattributen kunnen ergens mee gevuld worden. In het eerste blok van het script kregen we bijvoorbeeld de naam van de regisseur te horen en in het laatste blok kunnen we deze informatie krijgen en op het formulier weergeven aan de operator
• Als je verder van het blok af beweegt, kun je een aantal acties uitvoeren. Als de klant bijvoorbeeld zei dat hij helemaal niet in ons geïnteresseerd is en het heeft geen zin om te "vechten", dan zullen we de status "Niet-gericht" instellen in de behoefte. Als we het einde van het script hebben bereikt en klaar zijn om de klant naar de volgende afdeling over te dragen, dan stellen we de bedrijfsstatus in op "Lead" in plaats van op "Nieuw". U kunt alle velden wijzigen, niet alleen de hierboven genoemde
• Voor de blokkering kunt u de antwoordopties van de klant instellen - "Ja", "Nee", "Bel later terug", "We hebben een offerte", "Niet geïnteresseerd", enz. Afhankelijk van de opties, kunt u het scriptschema vertakken
• Terwijl het scriptblok wordt uitgevoerd, kunt u enkele andere elementen maken. De klant stemde er bijvoorbeeld mee in zijn e-mailadres te geven - dan sturen we hem meteen een brief van de KP. We geven gewoon aan dat er een brief moet worden gemaakt, ingevuld volgens het sjabloon en naar het adres van de klant moet worden verzonden.

Uiteindelijk eindigen we met zoiets als dit:

De operator krijgt het scriptverwerkingsformulier in menselijke vorm te zien " assistent". Een van de circuitblokken kan er bijvoorbeeld als volgt uitzien:

1. De tekst die we aan de operator hebben geschreven
2. Details die hij nodig heeft om deze stap in te vullen
3. Reactieopties van de klant
4. Doel en taken van het script
5. Beschikbaar op elk blok overgangen naar andere blokken
6. Algemene scriptvelden
7. Logboek van geselecteerde antwoorden

Nadat het scriptschema is gemaakt, kan de operator al beginnen met bellen - op de werkplek van de operator (als het script het recht heeft om te maken), kunt u op de knop "Maken" klikken, het gewenste script selecteren en bijvoorbeeld de volgende telefoonnummer uit de xls-tabel, werk eraan:

In dit stadium kunnen operators al volgens het script werken, maar er is het ongemak van het nemen van contacten van de tafel - dit leidt tot een reeks typische fouten.

Contacten downloaden van een Excel-spreadsheet voor algemeen bellen

We uploaden niet alleen bedrijven met hun contactgegevens, maar ook 'potentiële deals' (ook wel 'Leads' genoemd) in de status 'Gekwalificeerd'. Laten we het script zo opzetten dat het de status van leads gaandeweg verandert - van "Afgewezen" in "Benoemd". We zullen dus kijken naar de trechter voor deze oproepbasis.

Laten we een instelling voor het laden van gegevens maken:

1. Het bestand waaruit we gegevens verzamelen
2. De gegevens die in de database moeten worden geladen
3. Hoe worden de gegevens geladen?

In de instellingen kunt u het invullen van eventuele details van de gemaakte objecten specificeren. We zullen een potentiële deal van het bedrijf maken in de status "Kwalificatie" en "scriptuitvoering" - een object dat klaar is voor de operator om volgens het script te werken, het project in te vullen, zodat we later de resultaten van de oproep kunnen filteren naar deze database door het:

We vullen de operator niet in zodat iedereen de gemaakte elementen kan zien en aan het werk kan nemen. Gemaakte scripts zijn beschikbaar via werkplek van de operator:

Operators drukken op de knop " Volgende" - het systeem selecteert het volgende script in volgorde en begint het te verwerken. Dus:

• Operators hebben altijd "up-to-date informatie" voor hun ogen - er zijn geen dubbele oproepen
• Klanten die na enige tijd hebben gevraagd om terug te bellen, worden gepauzeerd - dergelijke scripts worden in hetzelfde venster weergegeven met de datum van het volgende contact.
• Operators zien de statistieken van collega's die aan het bellen zijn - dit motiveert zichzelf om te werken:

Operators zien hun statistieken in meer detail:

Welnu, als de operators sluw zijn, van tevoren complexe oproepen doen of proberen zoveel mogelijk scripts te "reserveren", dan kunt u de uitgifte van scripts beperken met behulp van concurrentieregels. U kunt de volgende beperkingen instellen:

• Niet meer dan X scripts in Y minuten
• Wacht X minuten na het uitvoeren van het script
• U kunt niet meer dan X scripts in behandeling laten

In dit stadium zullen we een goed ontwikkelde leadbase hebben - niet-core leads worden gescreend en de relevante status wordt toegewezen aan de core-leads. Het werk van de operators is hier af, nu zijn de salesmanagers erbij.

Koppeling met procesmanagers.

Het hoofd van de verkoopafdeling gaat de lijst met bedrijven binnen, selecteert alleen degenen die gekwalificeerd zijn door te bellen en benoemt verantwoordelijke managers in transacties:

De manager vult de behoefte van de hem toegewezen klant in en gaat aan de slag volgens de behoefte van de klant. Alle interacties worden vastgelegd in de behoeftekaart:

Analyse van resultaten

De manager ziet zowel de statistieken van elke operator als de conversie van elk script:

Afhankelijk van de status van verwerkte behoeften, kunt u een trechter bouwen:

Kennis basis

In de kennisbank kunt u artikelen gecategoriseerd plaatsen. Voor elke categorie kunt u de toegang configureren om individuele gebruikers te bekijken en aan te maken. In de scripthandler kan een link naar een artikel worden geplaatst.

Hoe te gebruiken

• Maak materiaal over uw producten en plaats links ernaar in het gespreksscript - dan kunnen uw operators technische vragen van klanten beantwoorden
• Plaats beschrijvingen van het gebruik van het gespreksscript in artikelen en geef het aan nieuwe medewerkers ter beoordeling

CRM

Een klein systeem voor het werken met klantrelaties. Het bevat een directory van bedrijven (het bevat een link naar de tegenpartij als "Arrange a call!" in een werkende configuratie moet worden geladen), contacten van deze bedrijven en potentiële deals. Managers werken aan mogelijke transacties van tegenpartijen en posten deze volgens verschillende statussen. Er worden verkopen gemaakt voor voltooide deals en de betaling wordt gecontroleerd. Aan het einde van de maand evalueert de manager hoeveel contacten er zijn gelegd, welke beloning aan leadgenerators verschuldigd is en welke indicatoren elk van de managers heeft.

Hoe te gebruiken

• Statistieken en analyses van klanttransacties bijhouden
• Weerspiegel alle opties voor het werken met klanten
• Upload nieuwe leads om te bellen
• Omgaan met "vergeten" en "verloren" klanten
• Beheer de prestaties van services

Elk bedrijf kan unieke details bevatten per type activiteit:

Voor elk bedrijf (en potentiële deal) wordt de geschiedenis van interacties weergegeven:

Alle aankomende interacties worden weergegeven in de "Feed", elke manager heeft er op elk moment snel toegang toe. De feed toont ook opmerkingen die naar u zijn verzonden - een logistiek medewerker laat bijvoorbeeld een opmerking "Wanneer we bezorgen" achter in het verzoek van een klant, en de persoon die verantwoordelijk is voor de levering ziet dit in zijn feed.

De manager kan het werk van zijn ondergeschikten beoordelen aan de hand van het aantal contacten met klanten. Hoe vaak wie belde, schreef brieven, communiceerde in de messenger, met wat voor soort leads werd gecommuniceerd.

E-mailclient

Het subsysteem zorgt niet alleen voor het verzenden en ontvangen van e-mail. Er bestaat zoiets als een mailfilter, het helpt om te bepalen wat er met een bepaalde brief moet gebeuren. U heeft bijvoorbeeld een feedbackformulier op uw site, zodra de gebruiker dit invult, wordt er een e-mail met de tekst van het bezwaar naar uw e-mailadres gestuurd. Filter in "Rangschik een oproep!" kan op deze manier worden geconfigureerd - "als de brief van het adres kwam" [e-mail beveiligd], dan moet je de volledige naam, klantbehoefte uit de tekst van de brief halen en op basis van deze gegevens een nieuwe potentiële deal maken. "Zo kun je de regel specificeren dat de brief onder het filter valt en de filteracties hiervoor brief.

Hiervoor dienen ze:

• Details van de brief - extra velden van de brief, bijvoorbeeld "Naam", "Afleveradres", "Telefoon", "Berichttekst"
• De details van de brief invullen - de regels waarmee het systeem informatie uit de tekst van de brief in de details "krijgt"
• Filteracties - welke nieuwe e-mailobjecten moeten worden gemaakt en hoe deze in te vullen

Hoe te gebruiken:

• Stel automatische verzameling van applicaties van de site in en toewijzing van oproepmanagers volgens het gespreksscenario voor deze potentiële klanten
• Zet productverzoeken (ze komen bijvoorbeeld binnen in een specifieke e-mail) om in een "Klantverzoek" document, volg het document in de juiste richting
• Beheer het werk van managers met klanten per e-mail rechtstreeks vanuit de database

Document boekhouding

Stelt u in staat om documenten in het systeem te herstellen op basis van hun type, en de toegangsrechten ervoor te beperken. U kunt bijvoorbeeld het documenttype "Kwaliteitsclaim" maken en er alleen toegang toe geven aan de afdeling "QC". In dit document vindt u een aantal nieuwe details, zoals "Claim Text", "Date of Appeal", Resultaat" enz. Of u kunt "Sollicitaties" van klanten verzamelen, bestanden aan hen toevoegen en ze doorgeven statussen ("Niet gestart", "In uitvoering", "Berekend", "Overeengekomen", "Geweigerd").

Hoe te gebruiken

• In de instellingen van e-mailfilters kunt u rechtstreeks vanuit de brieven van de klant aanvragen en aanvragen voor producten maken
• In combinatie met gespreksscenario's kunt u tijdens het gespreksscenario direct documenten genereren (een klant is bijvoorbeeld ontevreden over de kwaliteit van de dienstverlening - we creëren een "claim", die vervolgens wordt verwerkt door de afdeling QCD)

Het ziet er zo uit:

1. Documentstatussen
2. Documenttype dat de aanwezigheid van details in het document bepaalt
3. Aanvullende documentdetails

Een virtuele machine die scripts uitvoert in 1C:Enterprise.

Met andere woorden, dit is de mogelijkheid om programma's in 1C te schrijven zonder het 1C:Enterprise-platform te gebruiken.

En dit stelt ons in staat om uiteindelijk kant-en-klare stukjes code geschreven in de configurator te nemen en deze met minimale aanpassingen over te zetten naar een OneScript-programma.

En hoewel dit volgens de ontwikkelaars niet het hoofddoel van het project is, zie ik wel interesse om vanuit een OneScript-programma verbinding te maken met de 1C-database via een externe verbinding en wat nuttige code uit te voeren.

U vraagt ​​- waarom is dit zelfs nodig? Waarom schrijf je niet dezelfde code tijdens de verwerking en voer je deze op de standaard manier door 1s?

Maar we hebben het over automatisering en er zijn fundamentele problemen:

• er is geen manier om te garanderen dat de basis zal starten en de code van een externe verwerking daarin zal uitvoeren (wie dit in de praktijk is tegengekomen, weet dat er te veel mis kan gaan, te beginnen met het feit dat de verwerking simpelweg niet de uitvoering bereikt vanwege naar een modaal venster)
• er is geen gemakkelijke manier om dergelijke verwerking programmatisch te genereren, maar we hebben dit misschien nodig als het gaat om het uitvoeren van nuttige code over een groep basen
• er is geen gemakkelijke manier om de uitvoering van deze verwerking te loggen

Al deze problemen worden opgelost door OneScript.

Waarom deze scripts in de updater schrijven en uitvoeren?

Omdat de updater een aantal moeilijke dingen op zich neemt om het schrijven van dergelijke scripts te vereenvoudigen in termen van interactie met databases.

Namelijk.

Lijst met grondslagen voor verwerking

Rechts in de updater kiezen we voor hoeveel databases we nodig hebben om het script uit te voeren dat we hebben geschreven:

Basisparameters doorgeven

Bij het uitvoeren van het script geeft de updater zelf de nodige parameters door met informatie over de huidige database:

We kunnen al deze parameters in ons script gebruiken, waardoor het universeel is voor uitvoering op een willekeurig aantal geselecteerde bases.

We kunnen voorbeelden van dergelijke scripts vinden in de lijst met updater-sjablonen:

Database pre-archivering

Indien nodig zorgt de updater ervoor dat er een reservekopie wordt gemaakt voordat het script wordt uitgevoerd:

Deze back-up zal consistent zijn met het algemene archiveringssysteem, dat wil zeggen, het kan ook worden "afgestemd" in de geavanceerde instellingen van de updater. Een dergelijke kopie zal altijd worden aangeduid met "vóór gevaarlijke operatie".

Vergrendelen, ontgrendelen basis

Indien nodig zal de updater een volledige databasevergrendeling uitvoeren voordat uw script wordt uitgevoerd en ontgrendeld na:

En dit is een van de belangrijkste "functies" van de updater - de correcte uitvoering van het blokkeren van de serverdatabase in het algemeen is immers een nogal niet-triviale taak.

Het is noodzakelijk om de huidige gebruikersverbindingen, administratieve verbindingen, achtergrondtaken te "oplossen". En dit alles door rechtstreekse communicatie met het 1c cluster.

Rapporten opslaan

De updater slaat de uitvoeringsgeschiedenis van dergelijke scripts op in de rapportmanager.

Zoals in algemene termen:

Dus in detail:

E-mail notificatie

Als u e-mailmeldingen hebt geconfigureerd (allemaal of alleen bij fouten)...

Dan krijg je informatie over het uitvoeren van scripts (inclusief gedetailleerde rapporten) op dezelfde manier als informatie over het uitvoeren van andere bewerkingen van de updater:

Voer een script uit volgens een schema

Cloudbewaking

Bij het opslaan van het script hebben we ook de mogelijkheid om zijn werk in de cloud te volgen - naar mijn mening een absoluut geweldige kans. Dat gaat over cloudmonitoring.

Uitvoering van scripts met meerdere threads

Hoe u het script voor meerdere databases parallel kunt laten lopen, wordt in detail beschreven.

Wat is nog meer handig om te leren voordat u scripts gaat schrijven?

Nou ja, natuurlijk, de 1C-taal zelf. Waar zonder hem...

Allereerst is er deze 1C-taalgids met voorbeelden:.

Het is ook de moeite waard om de verschillen tussen OneScript en de standaard 1C-taal te bespreken. Dat zijn er maar weinig (link).

Hoe kom ik aan mijn eigen scripts?

Ter inspiratie raad ik je aan om eerst de scripts uit de updater-templates te ontleden en te begrijpen. Dit zal je veel opleveren.

En als je een idee nodig hebt voor het schrijven van een script dat nuttig zal zijn voor honderden andere gebruikers, dan vraag ik je - schrijf me erover op een voor jou geschikte manier. Ik heb enorm veel ideeën, maar er is niet genoeg tijd en kansen.

Om dit te doen, ben ik een speciaal project begonnen op github, waar ik nuttige scripts van updater-gebruikers verzamel, zodat zoveel mogelijk mensen ze in hun werk kunnen gebruiken.

Zou je me je script willen sturen? Ik vraag je om .

Eerlijk, Vladimir Milkin(docent en ontwikkelaar).