1.2 Tillämpning av teknologier för klient-server-interaktionsuppgifter.

2. Snabb start. Var ska man starta?

Punkt nr 0. Först och främst måste du välja (bestämma) om integrationstekniken och förstå "essensen" - det vill säga hur det kommer att fungera.
Du måste med andra ord svara på två frågor:

• Vilken 1C-databas (eller annat program) kommer att fungera som klient och vilken som server;

• Vilken klient-server-interaktionsteknik som passar dig bäst och kommer att användas.

Punkt nr 1.
Så, "essensen" av klient-server-interaktion förstås. Interaktionsteknik har fastställts. Nu behöver du skapa en "testplats" där utveckling kommer att ske.

I den här artikeln kommer två tekniker att diskuteras med hjälp av exempel:

Arbeta med mekanismen för WEB-tjänster.

Exempel på arbete från 1C 8 och PHP kommer att beaktas;

Arbeta med http-förfrågningsmekanismen (REST-webbtjänster).

Exempel på arbete från 1C 8 och PHP kommer också att beaktas;
I uppgifter relaterade till WEB-utveckling är det traditionellt accepterat:

• Skapa en "testplats" för utveckling och felsökning på programmerarens lokala WEB-server (localhost);
• Efter att utvecklingen är klar måste resultaten överföras till "combat" WEB-servern.

I praktiken (särskilt när du börjar "bekanta dig med" tekniken för WEB-tjänster), när du skapar en "testplats", såväl som när du överför ett projekt till en "kamp"-server, uppstår mycket "rake".

Så, för att inte "slösa" mycket tid på att "kämpa" med inställningarna IIS(Internet Information Server) / behärska servern apache och ställa in rättigheter Windows-åtkomst, jag rekommenderar följande:

• (1) Skapa "Polygon" på din lokala arbetsmaskin. Operativsystem - Windows 7 (professionellt eller maximalt). Allt arbete ska utföras under konto administratör.
• (2) Distribuera 1C 8-databasen i klient-serverläge (MS SQL-server, jag rekommenderar 2008 R2). Användning av 1C 8 i klient-serverläge kommer att eliminera behovet av att utföra ytterligare arbete. inställningar för åtkomsträttigheter till 1C-databasen från WEB-servern.
• (3) Installera IIS, om det saknas. I Windows kan du "installera om" det regelbundet

Kryssrutorna för installationsalternativen för IIS-komponenter kan ställas in som standard.
De väsentliga sakerna du behöver vara uppmärksam på är följande alternativ (ISAPI-tillägg - detta behövs för att tvålanslutningar ska fungera i WEB-tjänster och CGI - detta krävs för att PHP ska fungera)

När installationen är klar IIS Låt oss se till att det fungerar. För detta, i adressfält Webbläsare ange:

(4) Publicera (ansluta) en 1C-databas på en WEB-server.

Och så, WEB-server IIS installerad och fungerar. Låt oss publicera vår 1C-databas och kontrollera att åtkomst till den nu också är möjlig via WEB-klienten.

Det är tillrådligt att publicera 1C-databasen på en WEB-server som tillhandahåller drift i ett hanterat applikationsläge (tunn klient).

Att publicera en 1C-databas görs så här:
I konfiguratorläget måste du anropa objektet "Publicera på en webbserver"

b) Ange publikationsparametrar:

Det vill säga i en katalog (mapp) wwwroot du är hans IIS du måste skapa en separat mapp (katalog) för publicering av din 1C-databas.

wwwrootkatalogen skapas automatiskt när IIS installeras
Låt oss skapa och välja en sådan mapp (wsBase10), ange namnet för publicering (vi kallar det också wsBase10).

Om du plötsligt får ett meddelande som svar,

var då inte rädd.

1C-publiceringsmekanismen är väldigt nyckfull. Försök att klicka på "Publicera" igen.

Och om du som ett resultat får ett meddelande,

det betyder att allt fungerade.

Det är mycket viktigt att förstå att när du publicerar en 1C-databas och dess WEB-tjänster på en "combat"-server (till exempel Windows 2008 R2), uppstår ofta fel om du bestämmer dig för att använda en webbserver IIS.

Råd: installera inte på en "combat"-server IIS! Installera apache.

Detta kommer att skydda dig från många systemfel. Och publicering (återpublicering - med ändringar i konfigurationen) kommer att ske för apache smidigt, utan att behöva mixtra med vrd-filer och inställningar IIS.

I den här artikeln kommer jag inte att överväga installationsprocessen och apache-inställningar. Det finns andra källor om detta ämne.

Dock för samarbete apache med 1C-databasen (och webbtjänster) finns det flera mycket viktiga krav som du behöver känna till (kom med detta till din systemadministratör).

1. Vid installation apache Se till att aktivera stöd för ISAPI-tillägg.

2. Aktivera cgi-bin-stöd om du kommer att arbeta med PHP;

3. Du måste ange en speciell "användare" i 1C-databasen...

Denna användare måste ha autentisering operativ system. Och du måste ange användaren under vars namn det lanseras apache.

... Vi är klara med apache och låt oss återvända till vår "Polygon" igen.

Här ser vi - 1C börjar. WEB-servern tillsammans med 1C fungerar.
4. Installera PHP-tjänsten för WINDOWS.

Du kommer att behöva det om du som en del av din uppgift behöver utveckla klient (webbsidor för åtkomst till 1C) eller server (scenarier för bearbetning av http-förfrågningar från 1C) i PHP.

5 Låt oss lägga till wsClient10-katalogen till IIS, där våra PHP-skript kommer att köras.

PHP-skript vi kommer att använda:

• Att skapa klientdelen vid utveckling av 1C WEB-tjänster;
• För utveckling av serverdelen, vid utveckling av REST webbtjänster (http-förfrågningar).

6. Låt oss installera programmet Notepap++. Denna kompakta och bekvämt program Jag rekommenderar att du använder den för att redigera PHP-skript.

Efter att ha installerat Notepad++ kontrollerar vi omedelbart att PHP fungerar för oss. Låt oss skapa ett enkelt hello.php-skript för detta. Låt oss placera det i wsClient-katalogen och köra skriptet från webbläsaren:

Allt ok. PHP fungerar. Testplatsen är helt klar.

3. Skapande av en WEB-tjänst, tvålförfrågningar, XDTO och JSON. Exempel 1C och PHP. I detta skede bör du ha "Polygon" redo och du kan börja utveckla WEB-tjänster.

– Var ska man börja studera den här tekniken? Naturligtvis med ett klassiskt problem som "Hej ord"!

1. Uppgiften att skapa det enklaste Webb-service. Låt oss titta på exempel i 1C och PHP.

1.1. Låt oss lägga till webbtjänsten "_Calculations by Tariffs" i ​​databasen (wsBase10)

Låt oss ställa in publiceringsfilens namn till "calcOrder10.1cws". URI-namnområdet måste också anges. I princip kan du ange vilket namn som helst.

1.2. Låt oss lägga till operationen "getHello" i webbtjänsten "_Calculations by Tariffs".

Essensen av operationen kommer att vara den enklaste - ta tre parametrar (strängar, siffror) som indata (från klienten) och returnera en förenande sträng tillbaka till honom (som ett resultat). Returvärdetypen kommer att vara primitiv - sträng.

Vi kommer inte att markera kryssrutan "I transaktion", eftersom operationen inte kommer att ändra data i själva 1C-databasen.

Om vår operation ändrade data i 1C-databasen skulle det vara meningsfullt att markera den här rutan.
Namnet på metoden (funktionen) som kommer att behandla inkommande data (och returnera resultatet) kommer att vara "getHello".

1.3. Låt oss lägga till inkommande parametrar för "getHello"-operationen.

Sändningsriktningen är "ingång". Det vill säga att de överförs från klienten till servern.

1.4. Låt oss skriva en hanterare för "getHello"-operationen i webbtjänstmodulen
///////////////////

Funktion getHello(strParametr, floatParametr, integerParametr)
return strParametr+string(floatParametr+integerParametr)
EndFunction

////////

1.5. Vid det här laget är arbetet med att skapa en enkel WEB-tjänst avslutat. Och nu måste du publicera WEB-tjänsten "_Calculations by Tariffs".

Innan vi publicerar en webbtjänst på testsidan kommer vi att ta bort alla användare från listan över användare av vår informationsbas. Det vill säga, vi kommer att göra listan över användare "tom".

- Varför göra det här?

På testplatsen kommer endast utvecklaren att kunna ansluta till WEB-tjänster, och därför är det ingen idé att tillhandahålla användarautentisering när man ansluter till WEB-tjänsten.

Det vill säga att vi medvetet kommer att förenkla vårt arbete med WEB-tjänster på testplatsen.

Vi behöver inte ange inloggning och lösenord när vi upprättar en anslutning.
Men på en "combat"-server måste du naturligtvis tillhandahålla autentisering.
För att göra detta (som nämndes tidigare), måste du separat skapa en användare i "combat"-databasen, på vars vägnar själva WEB-servern kommer att startas. Och sedan, när du upprättar en anslutning till WEB-tjänsten (tvålanslutning), måste du också ange användarens inloggning och lösenord.

1.6. Och så, låt oss publicera WEB-tjänsten:

Observera att vi inte behöver markera kryssrutan "Använd operativsystemautentisering på webbservern". Det beror på att detta läge tillhandahålls endast för WEB-server IIS, och på "combat"-servern kommer det att fungera Apache.

1.7. Låt oss skapa en klientdel och testa hur WEB-servern fungerar.

A) Låt oss först ringa ett kundsamtal från 1C.

Låt oss göra det helt enkelt. I någon annan 1C-databas som du har kommer vi att skapa extern bearbetning. I denna bearbetning kommer vi att ansluta till WEB-tjänsten, använda "getHello"-operationen, skicka parametrarna dit och få ett svar från servern.
Koden för "1C" blir ungefär så här:

/////

&OnClient
Procedur Execute Query10 (Command)
// Infoga innehållet i hanteraren.
LineResult = SERVER_ExecuteWSQuery10();
Varning(StringResult);
Slut på procedur
&PåServerUtan sammanhang
Funktion SERVER_RunWSRequest10()
// Vi kommer inte att utföra autentisering på testplatsen!
Användarnamn = odefinierat;
Lösenord = odefinierat;
http://localhost/wsBase10/ws/calcOrder10.1cws?wsdl ",Användarnamn,Lösenord);
Proxy.User = Användarnamn;
Proxy.Password = Odefinierat;
strResult = Proxy.getHello("Ivanov",100.35,20);
return strResult;
EndFunction ///////////////////////////////////////////////////////////////////////////////////////

Låt oss testa hur funktionen SERVER_ExecuteWSRequest10() fungerar.

OK. Arbetar!
b) Låt oss nu ringa klienten till webbtjänsten från PHP.
PHP-skriptkoden blir ungefär så här:

/
//////////////////////////////////////////////////////////////////////////////////

error_reporting(E_ERROR); // 1. Inaktivera onödiga meddelanden
// 2. Inaktivera cachning för SOAP. Om detta inte görs,


// 3. Upprätta en tvålkoppling
$client = new SoapClient("http://localhost/wsBase10/ws/calcOrder10.1cws?wsdl ",
array(
"login" => null, //login, vi kommer inte att utföra autentisering
"lösenord" => null, //lösenord
"spår" => sant,
"funktioner" => SOAP_USE_XSI_ARRAY_TYPE,
//"komprimering" =>
);
// 4. Fylla arrayen av godkända parametrar
$params["strParametr"] = "test_Soap10:";
$params["floatParametr"] = 10.34;
$params["integerParametr"] = 12;
// 5. Utför getHello-operationen
$result = $client->getHello($params);
// 6. Visa resultatet på skärmen
var_dump($resultat);
?>

////
///

Låt oss anropa skriptet från webbläsaren och kontrollera dess funktion:

Allt är bra, att ringa 1C från en webbsida fungerar!

Låt oss sammanfatta några resultat:
Problemet med en enkel WEB-tjänst är löst. Och nu kan du börja skapa mer komplexa WEB-tjänster.

Och komplikationen blir att vi (hittills) bara har opererat med primitiva datatyper. Naturligtvis kommer vi att behöva sända/ta emot objekt (aggregerad) datatyper också.

2. Uppgiften att skapa en WEB-tjänst med XDTO-paket.

Låt oss som tidigare titta på exempel i 1C och PHP.

Låt oss ställa följande uppgift: WEB-tjänsten bör inte returnera en sträng, utan objektdata - en "värdetabell" (mer exakt, det kommer att vara en uppsättning objekt!).

För att beskriva olika datastrukturer (som kommer att krävas vid mottagning/överföring till WEB-servern), tillhandahåller 1C:8-plattformen en mekanism för XDTO-paket.

De där. Först beskriver vi alla datatyper vi behöver, och sedan anger vi:

• Vilka XDTO-paket kan vår WEB-tjänst arbeta med (du kan ange antingen ett eller en lista med paket);
• För varje parameter för operationen och resultatet den returnerar kan du ange vilken typ av data (från XDTO-paketet) det kommer att vara.

Låt oss skapa operationen GetTzTariffs_0, som returnerar data av typen tzTariffs.

Figuren visar att tzTariffer inkluderar ett obegränsat antal el-objekt. Faktum är att tzTariffer är en tabell över objekt av typen el.

- Hur ser man det?

• Om parametern "maximal" anges som "-1", är antalet av dessa objekt inte begränsat (en tabell med ett obegränsat antal rader);
• Om vi ​​inte behöver en tabell, utan bara behöver en struktur (en rad), bör de maximala och lägsta värdena anges lika med "1".
• I sin tur är el-objektet en struktur som innehåller ett objekttypsattribut (eTariff) och ett primitivt typattribut (cPrice, kommentar).

När du rör dig nedåt i hierarkin kan du se att tarifftypen är en struktur (maximal och minsta kvantitet = 1), vars en av detaljerna inkluderar typen kindOfTariff.

Total: XDTO-paketet låter dig tydligt beskriva hierarkin av datatyper som kommer att användas vidare när du interagerar med en WEB-tjänst.

Tips: Det är bättre att använda ett XDTO-paket för en webbtjänst för att undvika komplexitet och undvika designfel.
Låt oss gå vidare... Efter:

• XTDO-paketet har skapats;
• Alla datatyper beskrivs;
• För WEB-tjänsten anges användningen av detta paket;
• För parametrar och resultat av operationer väljs lämpliga typer (från XDTO-paketet)

I vårt exempel bör operationen GetTzTariffs_0 returnera en array av strängar som innehåller Tariffs-objekt.

////////////////

Funktion GetTzTariffs_0()
// Infoga innehållet i hanteraren.
Returnera GetTZTariffs_0();
EndFunction

Funktion GetTZTariffs_0()


// Fylla i de tekniska specifikationerna
// 1:a raden

kindOfTariff.active = falskt;


tariff.kind = kindOfTariff;

elementTZ.eTariff = tariff;
elementTZ.cPrice = 100;

//
// 2:a raden
kindOfTariff = FactoryXDTO.Create(kindOfTariffType);

tariff = FactoryXDTO.Create(tariffType);
tariff.begdate = CurrentDate();
tariff.kind = kindOfTariff;
elementTZ = FactoryXDTO.Create(elementTZType);
elementTZ.eTariff = tariff;
elementTZ.cPrice = 200;
// Lägg till den andra raden i tabellen
tzTariffs.el.Add(elementTZ);
Retur tzTariffer;
EndFunction

//////////
Därefter ger vi ett exempel på att anropa operationen "GetTzTariffs_0" från klientsidan, från 1C.

&OnClient
Procedur Execute Query20 (Command)
// Infoga innehållet i hanteraren.
Varning(SERVER_ExecuteWSQuery20());
Slut på procedur
&PåServerUtan sammanhang
Funktion SERVER_ExecuteWSRequest20()
Definitioner = new WSDefinitions("http://localhost/wsBase10/ws/calcOrder10.1cws?wsdl ");
Proxy = new WSProxy(Definitions,"www.URI.com","_Calculations By Tariffs","_Calculations By TariffsSoap");
XDTResult = Proxy.GetTzTariffs_0();
// Låt oss komma åt raden vid index noll, sedan till eTariff-attributet, sedan till den kapslade attributtypen och sedan till det kapslade attributnamnet.
EndFunction

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
Ett liknande anrop från PHP och bearbetning av XDTO-resultaten skulle se ut så här:
////////////////////////////////////////////////////////////////////////////////////

// webbtjänstens funktioner kommer inte att fungera korrekt.
ini_set("soap.wsdl_cache_enabled", "0");
$client = new SoapClient("http://localhost/wsBase10/ws/calcOrder10.1cws?wsdl ");
$result = $client->GetTzTariffs_0();
$mResult = $result->return->el;
// mResult - en array av objekt. Låt oss gå igenom elementen i arrayen och visa resultaten på skärmen
för ($i=0; $i {
eka"
";
$eTariff = iconv("utf-8","cp1251",$mResult[$i]->eTariff->fullständigt namn);
var_dump($eTariff);
$cPrice = $mResult[$i]->cPrice;
var_dump($cPrice);
$cComment = $mResult[$i]->cComment;
var_dump($cComment);
eka"
";
}
?>

//////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////

Nu Låt oss komplicera uppgiften ännu mer. Låt oss överföra samma objektdatatyp från klienten till WEB-tjänsten (som en parameter). Låt det vara tzKind.
För att göra detta beskriver vi först denna typ i dataTariffs-paketet och lägger sedan till GetTzTariffs_1-operationen.

Låt oss ange typen av tzKind-parametern.

Ett exempel på hur en WEB-tjänst fungerar med en inkommande XDTO-parameter:
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

Funktion GetTZTariffs_1(tzKind)
tzTariffsType = FactoryXDTO.Type(" ", "tzTariffs");
tzTariffs = FactoryXDTO.Create(tzTariffsType);
elementTZType = FactoryXDTO.Type(" ", "elementTZ");
tariffType = FactoryXDTO.Type(" ", "tariff");
kindOfTariffType = FactoryXDTO.Type(" ", "kindOfTariff");
// Fylla i de tekniska specifikationerna
// 1:a raden
kindOfTariff = FactoryXDTO.Create(kindOfTariffType);
kindOfTariff.name = "Transport";
kindOfTariff.active = falskt;
tariff = FactoryXDTO.Create(tariffType);
tariff.fullName = "Taxa 1";
tariff.begdate = CurrentDate();
tariff.kind = kindOfTariff;
elementTZ = FactoryXDTO.Create(elementTZType);
elementTZ.eTariff = tariff;
elementTZ.cPrice = 100;
elementTZ.comment = "Beskrivning av taxa 1";
// Lägg till den första raden i tabellen
tzTariffs.el.Add(elementTZ);
// 2:a raden
kindOfTariff = FactoryXDTO.Create(kindOfTariffType);
kindOfTariff.name = "Leverans";
kindOfTariff.active = sant;
tariff = FactoryXDTO.Create(tariffType);
tariff.fullName = "Taxa 2";
tariff.begdate = CurrentDate();
tariff.kind = kindOfTariff;
elementTZ = FactoryXDTO.Create(elementTZType);
elementTZ.eTariff = tariff;
elementTZ.cPrice = 200;
elementTZ.comment = "Beskrivning av taxa 2";
// Lägg till en tredje rad i tabellen (fyll den med inkommande data)
tzTariffs.el.Add(elementTZ);
// 3:e raden
kindOfTariff = FactoryXDTO.Create(kindOfTariffType);
kindOfTariff.name = tzKind.el.eKind.name;
kindOfTariff.active = tzKind.el.eKind.active;
tariff = FactoryXDTO.Create(tariffType);
tariff.fullName = "Taxa 3";
tariff.begdate = CurrentDate();
tariff.kind = kindOfTariff;
elementTZ = FactoryXDTO.Create(elementTZType);
elementTZ.eTariff = tariff;
elementTZ.cPrice = 300;
elementTZ.comment = "Beskrivning av taxa 3";
// Lägg till en tredje rad i tabellen
tzTariffs.el.Add(elementTZ);
Retur tzTariffer;
EndFunction

//////////////////////////////////////////////////////////////////////////////////
Från 1C-klientsidan kommer vi att behöva förbereda data av typen tzKind och överföra dem till WEB-tjänsten.

Här är ett exempel på ett sådant samtal:
/////////////////////////////////////////////////////////////////////////////////

&OnClient
Procedur Kör Query30 (kommando)
// Infoga innehållet i hanteraren.
Varning(SERVER_ExecuteWSQuery30());
Slut på procedur
&PåServerUtan sammanhang
Funktion SERVER_ExecuteWSRequest30()
Definitioner = new WSDefinitions("http://localhost/wsBase10/ws/calcOrder10.1cws?wsdl ");
Proxy = new WSProxy(Definitions,"www.URI.com","_Calculations By Tariffs","_Calculations By TariffsSoap");
// Skapa en tabell med parametrar som skickas till WS
tzKindType = Proxy.FactoryXDTO.Type(" ", "tzKind");
tzKind = Proxy.FactoryXDTO.Create(tzKindType);
kindOfTariffType = Proxy.FactoryXDTO.Type(" ", "kindOfTariff");
kindOfTariff = Proxy.XDTO Factory.Create(kindOfTariffType);
kindOfTariff.name = "Testtarifftyp";
kindOfTariff.active = falskt;
elementKindType = Proxy.FactoryXDTO.Type(" ", "elementKind");
elementKind = Proxy.XDTO Factory.Create(elementKindType);
elementKind.eKind = kindOfTariff;
elementKind.qty = 10;
// Lägg till en rad i tabellen
tzKind.el.Add(elementKind);
XDTOResult = Proxy.GetTzTzriffs_1(tzKind);
ExempelResult_Name of Tariff Type = XDTOResult.el.eTariff.kind.name;
Returnera ExempelResult_Name of Tariff Type;
EndFunction

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
Jag skulle vilja fästa din uppmärksamhet på designen: Proxy.FactoryXDTO.Type("...

Det vill säga när vi skapar ett XDTO-paketobjekt på klienten måste vi inte komma åt vår egen XDTO!-fabrik utan genom en proxy. Det vill säga till XDTO-serverfabriken.

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
Nu är det dags att ställa frågan:finns det något alternativ till XDTO-objekt ?

Är det möjligt att "inte kommunicera" med XDTO-fabriken överhuvudtaget, sända/ta emot från en WEB-tjänst på något annat sätt.. (speciellt om klienten inte är 1C, utan till exempel en WEB-sida, en applikation på Android, iOS , etc.).

Svaret är- Jo det kan du!
Du kan till exempel använda sträng som parametertyper. Och "packa" (serialisera) datastrukturer i den.

Denna teknik inom WEB-programmering har länge utvecklats och kallas JSON.
Det är också en stor hjälp att i PHP, packning/extrahering av alla strukturer/arraysträngar görs i ett steg!
Ett exempel i PHP på att paketera objekt i JSON/extrahera, sända/ta emot till en WEB-tjänst:

///////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////

// serialisera mDelivery-arrayen till en sträng och placera den i leveransparametern
// * Låt oss först beskriva leveransstrukturen
klass leverans(
var $id;
var $checked;
var $värde;
}
// Fyll strukturen med lite data
$sDelivery = ny leverans;
$sDelivery->id = "000000005";
$sDelivery->checked = TRUE;
$sDelivery->value = 0;
// Lägg till den i arrayen av mDelivery-objekt
$mDelivery = $sDelivery;
// Konvertera mDelivery-arrayen till en JSON-sträng och placera resultatet i leveransparametern
$params["delivery"] = json_encode($mDelivery);
// Anropa ExitCalcOrder-operationen på WEB-tjänsten och skicka en parameter till den (sträng - leverans);
$result = $client->ExitCalcOrder($params);
// Hämta resultatet av ExitCalcOrder-operationen till variabeln jsCalcResult (sträng)
$jsCalcResult = $result->retur;
// Utför den omvända transformationen: från jsCalcResult-strängen till ett objekt (en array av objekt, typ matchning) arrCalcResult
$arrCalcResult = json_decode($jsCalcResult);
// Visa information på skärmen om objektet arrCalcResult
var_dump($arrCalcResult);

////////////////////////////////////////////////////////////////////////////////

Men hur utför man JSON-konverteringar i 1C?
1C 8-plattformen stöder inte JSON-standarden, men detta är inget problem.
JSON-konverterings-/extraktionsbehandling finns, är tillgänglig och fungerar utmärkt från
// Copyright © 2010-2012 Alexander Pereverzev
// 1C:JSON . JavaScript Object Notation parser och serializer.

Lägg därför bara in denna bearbetning i din konfiguration så kan du enkelt utföra framåt- och bakåt-JSON-konverteringar:
Serialiseringsexempel 1C-objekt till JSON-strängen:

///////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////

CargoData = ny struktur;
CargoData.Insert("kod", CargoCode);
CargoData.Insert("nummer", CargoNumber);
CargoData.Insert("plan", QuantityPlan);
CargoData.Insert("character",CargoCharacter);
CargoData.Insert("packing", Packaging);
CargoData.Insert("skada",Skada på förpackning);
CargoData.Insert("volym",Volym);
CargoData.Insert("weight",Weight);
CargoData.Insert("status",Status);
jsResult = JSON.WriteJSON(LoadData); //Konvertera resultatet till JSON
returnera jsResult;

Extrahera exempel objekt i 1C från JSON-strängen:
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

// 1. Återställ objekt från JSON
JSON = Process.JSON.Create();
mdelivery = JSON.ReadJSON(leverans);
// som ett resultat är mdelivery en array. Arrayelement - matcha.
// Det är till exempel mdelivery.["id"] kommer att innehålla "000000005"

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
Avslutningsvis kommer jag att ge ett exempel på att anropa 1C-webbtjänsten från PHP och ta emot den returnerade JSON-strukturen av dess omvända transformation till PHP-objekt.

Låt oss vara uppmärksamma på omvandlingarna iconv("cp1251","utf-8","
och iconv("utf-8","cp1251", som kommer att krävas (när man interagerar med PHP - 1 C) för att konvertera kyrilliska strängar från cp 1251-kodning till utf -8 och tillbaka.

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

error_reporting(E_ERROR); // Inaktivera meddelanden
// Inaktivera cachning för SOAP. Om detta inte görs,
// webbtjänstens funktioner kommer inte att fungera korrekt.
ini_set("soap.wsdl_cache_enabled", "0");
$client = new SoapClient("http://localhost/wsBase10/ws/wsQuery.1cws?wsdl ");
$params["fname"] = iconv("cp1251","utf-8","dataFreight");
$params["param1"] = iconv("cp1251","utf-8",$_GET["kod"]);
$params["param2"] = iconv("cp1251","utf-8",$_GET["nummer"]);
$result = $client->executeQuery($params);
$jsResult = $result->retur;
$dataFreight = json_decode($jsResult);
$statusFreight = $dataFreight->codeNm;
$numberFreight = iconv("utf-8","cp1251",$dataFreight->nameRus);
?>

///////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////

Det troliga scenariot är: en fjärranvändare från några av sina program (till exempel från en WEB-sida, mobilapplikation, etc.) ringer din WEB-tjänst och... får inga resultat.. Eller så får han det, men något är fel.

Fråga: - Hur får man reda på sådana fel och felsöker WEB-tjänsten?
Jag rekommenderar att du använder en logg för att övervaka fel (och samla in inkommande parametrar "vad som ledde webbtjänsten till ett fel").

De där. på den plats där logiska fel kan uppstå, spara programinformation om inkommande parametrar i registreringsloggen (LogRecord)

Om du "kämpar" med "runtime errors" kan du fånga upp dem (ett försök är ett undantag) och "punkt för punkt" logga hela situationen.

Som ett resultat, med hjälp av loggen, kommer du att kunna se information om fel, reproducera parametrarna för händelsen och "besegra" den i interaktivt läge, i felsökaren.

Låt oss sammanfatta: Exempel på att arbeta med WEB-tjänster från 1C och PHP beaktas. För att överföra objektdatastrukturer mellan klienten och servern använde vi två tekniker:

• (1) XDTO-paket
• (2) JSON-objekt.

4. Alternativ - REST webbtjänster (http-förfrågningar). Exempel på implementering i 1C och PHP.
I föregående avsnitt undersökte vi i detalj tekniken för WEB-tjänster. I detta avsnitt kommer vi att överväga en alternativ teknik, den så kallade. REST webbtjänster.

En rättvis fråga uppstår: - Varför?

WEB-tjänster är fullt funktionella och låter dig lösa problem av vilken komplexitet som helst.

För att förstå "varför", låt oss formulera de grundläggande skillnaderna mellan dessa teknologier.

Tekniken för WEB-tjänster är baserad på 2 punkter:

• (1) SOAP-anslutning används. Med andra ord görs en SOAP-förfrågan.

Definitioner = new WSDefinitions("http://localhost/wsBase10/ws/calcOrder10.1cws?wsdl",Användarnamn,Lösenord);
Proxy = new WSProxy(Definitions,"www.URI.com","_Calculations By Tariffs","_Calculations By TariffsSoap");

/////////////////////////////////////////////////////////////////////////////////////////

I PHP är det så här:

/////////////////////////////////////////////////////////////////////////////////////////

$client = new SoapClient("http://localhost/wsBase10/ws/calcOrder10.1cws?wsdl ",
array(
"login" => inloggning, //login,
"lösenord" => pass, //lösenord
"spår" => sant,
"funktioner" => SOAP_USE_XSI_ARRAY_TYPE,
//"komprimering" => SOAP_COMPRESSION_ACCEPT | SOAP_COMPRESSION_GZIP | 5
);

/////////////////////////////////////////////////////////////////////////////////////////

• (2) För att bearbeta en tvålkoppling i serverläge tillhandahåller 1C 8-plattformen ett speciellt metadataobjekt WEB-tjänster.

Dessutom, om "1C" i din uppgift måste fungera som en server, så finns det inget alternativ till 1C WEB-tjänstteknik.

– När är ett alternativ möjligt?

• För det första, när 1C endast agerar som kund;
• För det andra, när servern du behöver arbeta med (till exempel en webbplats eller någon form av WEB-applikation), är det inte planerat att stödja en SOAP-anslutning.

Ett mycket populärt alternativ - http-anslutning.

I webbaserade system (PHP, Android, iOS) är det lättare att arbeta med http-förfrågningar än med SOAP-förfrågningar. Och för inte särskilt komplexa projekt är http-förfrågningstekniken ganska lämplig.

Den klassiska lösningen (med http-förfrågningsmetoden) är uppgiften att integrera 1C-databasen och webbsidan. Till exempel skickas information om sortiment och priser till webbplatsen och information om accepterade beställningar skickas tillbaka från webbplatsen.

Det är typiskt att i typiska 1C-konfigurationer implementeras integration med webbplatser med hjälp av http-förfrågningar.
Så låt oss titta på tekniken http-förfrågningar Till exempel interaktion mellan 1C (klient, 1C 8) och WEB-plats (PHP, server).

1. Etablera en anslutning och metoder för att skicka parametrar i en http-förfrågan
Ett exempel på att upprätta en anslutning till servern från 1C-sidan:
/////////////////////////////////////////////////////////////////////////////

skyddad = falsk;
HTTPConnect = new HTTPConnect("localhost/wsClient10/json/testHTTPQuery11.php", skyddad);

////////////////////////////////////////////////////////////////////////////
Som du vet finns det två metoder för att överföra parametrar från klienten till servern via http-protokollet:

(1) Metod "get";

Parametrar (som namn och lösenord) anges direkt i serveranropets URL.

Det vill säga, ett interaktivt anrop till skriptet (direkt från en webbläsare) skulle se ut så här:

I 1C:8, för att programmässigt anropa servern (och skicka parametrar för Get-metoder till den), tillhandahålls "Get"-metoden.

Exempel:
skyddad = falsk;
HTTPConnect = new HTTPConnect("localhost", Säker);
HTTPConnect.Get("wsClient10/json/testHTTPQuery11.php?nameVasya&password=123",OutputFileName);

where OutputFileName: Namnet på filen som data som returneras från servern placeras i.
Det vill säga, som ett resultat av att bearbeta begäran, returnerar servern resultatet till 1C och sedan (automatiskt) genereras en fil som innehåller resultatet.

Följaktligen, efter detta, i "1C" är det nödvändigt (programmässigt) att läsa den här filen och extrahera resultatet från den. Det är allt.

(2) "post"-metod;

I det här alternativet placeras inte parametrarna i URL:en, utan överförs separat i http-anslutningens brödtext.

Det är tydligt att den viktigaste begränsningen av metoden skaffa sigär volymen och innehållet i de överförda data. Det vill säga med hjälp skaffa sig Endast tecken kan skickas och längden på URL-strängen är begränsad.

Metod posta Du kan överföra data av olika innehåll, inkl. och godtyckliga filer.
Således, posta för integrationsuppgifter är den mer funktionell och vi kommer att fortsätta arbeta med den.

För att ta emot/sända data mellan 1C och WEB-sidan kommer vi att använda textfiler.
Och vi kommer att "packa/extrahera" data från filer med JSON-tekniken som redan är bekant för oss! Detta kommer praktiskt taget att rädda oss från behovet av att "tolka" filen på 1C-sidan och på PHP-sidan.

För att anropa servern och överföra parametrar till den med "post"-metoden, tillhandahåller 1C:8 metoden: SendForProcessing

Och så, låt oss ge ett exempel där på sidan 1C alla bearbetningssteg utförs http-förfrågan:

Låt oss först skriva ner handlingsplanen (förstorad):

Och nu, dess mjukvaruimplementering i 1C:8

////////////////////

// 1. Fyll i strukturen för de överförda uppgifterna
postDataToPHP = ny struktur;
postDataToPHP.Insert("param1","ivanon");
postDataToPHP.Insert("param2","ivan");
postDataToPHP.Insert("param3","ivanovich");

// 2. Konvertera data till en JSON-sträng
JSON = Process.JSON.Create();
jsPostDataToPHP = JSON.WriteJSON(postDataToPHP);

// 3. Skapa ett tillfälligt utgående meddelande (sänds till servern med POST-metoden)
// fil, lägg en JSON-sträng i den.
tFile = nytt TextDocument;
stringData = jsPostDataToPHP;
tFile.AddLine(stringData);

// 4. Hämta namnet på den temporära utgående filen. Den kommer att innehålla utgående data i form av en JSON-sträng
OutgoingFileName = GetTemporaryFileName(.txt");
tFile.Write(OutgoingFileName,TextEncoding.UTF);

// 5. Hämta namnet på den temporära indatafilen. Den kommer att få en JSON-sträng: PHP-serversvar
InputFileName = GetTemporaryFileName(.txt");

// 6. Upprätta en HTTP-anslutning med servern
skyddad = falsk;
HTTPConnect = new HTTPConnect("localhost/wsClient10/json/testHTTPQuery10.php", skyddad);

// 7. Låt oss köra en HTTP-förfrågan. Låt oss överföra den utgående filen till servern (filen innehåller ett JSON-objekt, d.v.s. utgående parametrar)

HTTPConnect.SendForProcessing(OutgoingFileName,"/json/",IncomingFileName);

// Och vi kommer att få ett svar från servern (inkommande fil). Filen innehåller ett //JSON-objekt (dvs data som returneras från servern)

// 8. Extrahera data som tas emot från servern från den inkommande filen
ResponseFile = nytt TextDocument;
ResponseFile.Read(InputFileName,TextEncoding.UTF);
json_Data = ResponseFile.GetString(1);
mData = JSON.ReadJSON(json_Data);

// 9. Visa mottagen data för användaren
Report(mData["v1"]);
Report(mData["v2"]);

// 10. Ta bort använda (behövs inte längre) temporära filer.
DeleteFiles(OutgoingFileName);
DeleteFiles(InputFileName);

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

Och slutligen, exempel i PHP för att bearbeta en begäran på serversidan:

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

// 1. Hämta strängdata från den inkommande filen
$json_filedata = file_get_contents("php://input");
// 2. Klipp bort allt onödigt (2 tjänstecken läggs till), som // stör konverteringen från JSON
$jsData = trim(ltrim($json_filedata));
$dlinaStr = strlen($jsData);
$_jsData = "";
$i=1;
medan ($i<$dlinaStr) {
om ($i>2) (
$_jsData = $_jsData.substr($jsData, $i, 1);
}
$i++;
}
// 3. Konvertera data från JSON till ett objekt (struktur)
$mData = json_decode($_jsData);
// 4. Låt oss skapa en annan struktur, som vi fyller med data och // återgår till 1C
klass returnData(
var $v1;
var $v2;
}
$sReturnData = ny returData;
$sReturnData->v1 = $mData->param1;
$sReturnData->v2 = $mData->param2;
// 5. Konvertera strukturdata till en JSON-sträng
$json_returnData = json_encode($sReturnData);
// 6. Returnera data till 1C (utdata kommer att omdirigeras till en fil, som kommer att returneras till 1C)
echo $json_returnData;
?>

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

Det är allt. Kompakt och funktionell!

5. Efterfrågade uppgifter (projektärenden)

Avslutningsvis kommer jag att citera de som de facto nu är mest efterfrågade av kunderna, och som löses med hjälp av WEB-tjänster och http-förfrågningar.

Ämnets rubrik är verkligen en fråga, för... Jag vet inte själv vad det är och för första gången ska jag försöka arbeta med det inom ramen för denna artikel. Det enda jag kan garantera är att koden som presenteras nedan kommer att fungera, men mina fraser kommer bara att vara antaganden och gissningar om hur jag själv förstår allt detta. Låt oss gå...

Introduktion

1. TVÅL. Innan du anropar en fjärrprocedur måste du beskriva detta samtal i en XML-fil i SOAP-format. SOAP är helt enkelt en av de många XML-uppmärkningar som används i webbtjänster. Allt vi vill skicka någonstans via HTTP konverteras först till en XML SOAP-beskrivning, stoppas sedan i ett HTTP-paket och skickas till en annan dator i nätverket via TCP/IP.
2. WSDL. Det finns en webbtjänst, d.v.s. ett program vars metoder kan anropas på distans. Men standarden kräver att det här programmet åtföljs av en beskrivning som säger att "ja, du har rätt - det här är verkligen en webbtjänst och du kan anropa sådana och sådana metoder från den." Denna beskrivning representeras av en annan XML-fil, som har ett annat format, nämligen WSDL. De där. WSDL är bara en XML-fil som beskriver en webbtjänst och inget mer.

Allmän riktlinje

1. Beskriv gränssnittet för vår webbtjänst
2. Implementera detta gränssnitt
3. Starta vår webbtjänst
4. Skriv en klient och fjärranrop önskad webbtjänstmetod

Server

Klient

Slutsats

Ämnets rubrik är verkligen en fråga, för... Jag vet inte själv vad det är och för första gången ska jag försöka arbeta med det inom ramen för denna artikel. Det enda jag kan garantera är att koden som presenteras nedan kommer att fungera, men mina fraser kommer bara att vara antaganden och gissningar om hur jag själv förstår allt detta. Låt oss gå...

Introduktion

1. TVÅL. Innan du anropar en fjärrprocedur måste du beskriva detta samtal i en XML-fil i SOAP-format. SOAP är helt enkelt en av de många XML-uppmärkningar som används i webbtjänster. Allt vi vill skicka någonstans via HTTP konverteras först till en XML SOAP-beskrivning, stoppas sedan i ett HTTP-paket och skickas till en annan dator i nätverket via TCP/IP.
2. WSDL. Det finns en webbtjänst, d.v.s. ett program vars metoder kan anropas på distans. Men standarden kräver att det här programmet åtföljs av en beskrivning som säger att "ja, du har rätt - det här är verkligen en webbtjänst och du kan anropa sådana och sådana metoder från den." Denna beskrivning representeras av en annan XML-fil, som har ett annat format, nämligen WSDL. De där. WSDL är bara en XML-fil som beskriver en webbtjänst och inget mer.

Allmän riktlinje

1. Beskriv gränssnittet för vår webbtjänst
2. Implementera detta gränssnitt
3. Starta vår webbtjänst
4. Skriv en klient och fjärranrop önskad webbtjänstmetod

Server

Klient

Slutsats

Idag används WEB-tjänster nästan överallt - de ger oss information om flyg- och tågflyg, växelkurser och väder. Det är inte förvånande att 1C också har förmågan att skapa sina egna WEB-tjänster, vilket gör att det kan agera både som leverantör och konsument. Denna mekanism är inbyggd i 1C:Enterprise 8.3-plattformen och utvecklare kan till och med lägga till sina egna objekt av typen WEB-tjänster till standardkonfigurationen. Deras arkitektur bygger på en uppsättning tjänster som låter dig utbyta information med annan programvara.

Skapa en 1C-webbtjänst

En av de främsta fördelarna med 1C WEB-tjänster är frånvaron av behovet av att ge direkt tillgång till informationssäkerhetsdata. En korrekt konfigurerad 1C-webbtjänst tillåter andra applikationer att använda funktioner utifrån. I sådana fall bör funktionen själv bestämma rätten att använda data enligt de angivna parametrarna enligt de regler som föreskrivs av utvecklaren.

Hur skapar man en webbtjänst i 1C?

För att en viss funktion i 1C-systemet ska bli tillgänglig för extern programvara är det nödvändigt att utföra följande algoritm för åtgärder:

1. Gå till konfigurationen och lägg till ett WEB-tjänstobjekt i en viss gren av trädet;
2. Beskriv alla operationer som vår funktionalitet kan utföra. Funktionsbeskrivningen utförs i modulen i det inbyggda 1C-språket;
3. Lägg till en beskrivning av parametrarna för webbtjänstens funktioner. Observera att datatyperna beskrivs med hänsyn till de befintliga typerna av XDTO-mekanismen som introducerades i plattformsversion 8.1;
4. Publicera den skapade WEB-tjänsten på servern. Mekanismen som är inbyggd i 1C-plattformen stöder följande standarder:

• SSL/TLS
• WS-I BP

Ett exempel på att skapa en enkel WEB-tjänst

För att tydligast visa hur WEB-tjänstmekanismen fungerar, låt oss skapa ett exempel - en funktionalitet som bestämmer längden på den angivna strängen. Programvaran skickar en sträng som en begäran-parameter, och funktionen som beskrivs i 1C kommer att returnera antalet tecken. När du skapar måste du komma ihåg att publicering av denna mekanism gör det möjligt för olika programvaror att komma åt den. Eftersom inte alla program kan acceptera det kyrilliska alfabetet kommer vi att namnge konfigurationsobjekt med latinska tecken.

Öppna konfiguratorn, hitta grenen "WEB services" i trädet och lägg till en ny tjänst "wa_LengthString". Du måste också lägga till en ny operation på fliken "Operations". Låt oss kalla det "CalcLengthString", ange returvärdestypen i egenskaperna - int eller heltal och skapa parametern "InputString" inuti den. Vi lämnar värdetypen som sträng.

Nu måste du registrera åtgärden för CalcLengthString-funktionen i WEB-tjänstmodulen. För att göra detta, öppna egenskaperna för den skapade funktionen och klicka på knappen i form av ett förstoringsglas till höger, bredvid inmatningsfältet "Procedurnamn". 1C kommer automatiskt att skapa en funktion i vår WEB-tjänstmodul och öppna den så att vi kan beskriva CalcLengthString-åtgärden. Låt oss dra fördel av detta och skriva funktionen för funktionen - bestämma längden på inmatningssträngen.

Detta slutför faktiskt skapandet av en enkel WEB-tjänst. Nu är det nödvändigt att "sätta" den här tjänsten i det offentliga området så att programvara från tredje part eller andra 1C-system kan använda denna funktionalitet.

För att vi ska kunna publicera den skapade webbtjänsten med dess funktionalitet behöver vi ha tillgång till sajten. Innan vi börjar publicera tjänsten måste vi kontrollera filnamnet i egenskaperna för den skapade wa_LengthString-modulen. Det ska vara tydligt, enkelt och ha tillägget "1cws".

Nu är det dags att publicera WEB-tjänsten vi skapade på servern. Denna funktion dök upp i plattformsversion 8.3 och många företag har redan insett de fulla fördelarna med denna funktion. För att börja publicera måste du öppna formuläret "Administration/Publicering på en webbserver..." i konfiguratorn.

I fönstret som öppnas måste vi konfigurera 1C Web Services och fylla i vissa fält:

• Namn. Anger mappen på webbservern där beskrivningen av vår webbtjänst kommer att lagras. Var försiktig med case, eftersom ibland servrar skiljer mellan stora och små case-tecken;
• Webbserver. Du måste välja en server från de som är installerade på din dator;
• Katalog. Du måste välja sökvägen till mappen där webbserverdata för att konfigurera anslutningen lagras. Endast latinska bokstäver används;
• Två tecken av boolesk typ. Den första kommer att vara användbar för oss om vi behöver konfigurera åtkomst till konfigurationen via en webbklient. För att publicera en 1C-tjänst måste du markera den andra rutan.

Allt som återstår är att kontrollera att den önskade WEB-tjänsten har kryssrutan markerad i den första kolumnen och klicka på "Publicera".

Eftersom den här mekanismen fortfarande är ganska ny, kan du stöta på ett fel som "Ett fel inträffade när en filoperation utfördes...". I det här fallet behöver du bara klicka på "Publicera" igen. I de flesta fall kommer detta att hjälpa och du kommer att se ett meddelande som indikerar att webbtjänsten har publicerats.

<имяСервера>.ru/<ИмяУказанногоКаталогаНаСервере>/ws/<НаименованиеФайла>.1cws?wsdl

Som svar på en sådan adressbegäran måste webbläsaren visa strukturen för XML-filen. Om du ser en tom sida, ett fel eller konstiga tecken (kodningsproblem), måste du kontrollera alla steg igen. Det är också en bra idé att se till att servern är korrekt konfigurerad och att du har tillgång till den. Efter framgångsrik publicering kommer 1C WEB-tjänsten att kunna användas av tredjepartsapplikationer.

Friskrivningsklausul och användarvillkor

Ytterligare en ansvarsfriskrivning (efter många gånger)

Introduktion

För dem som är helt "utanför loopen": om webbtjänster "till hands"

Var är benen ifrån, d.v.s. vingar växer

Han sa: "Låt oss gå!"

Detta träd representerar ett "porträtt" av webbtjänsten, som 1Ska ser det. Det mest intressanta är i grenen "Webtjänster": detta namn Och hamnar webbtjänster (i själva verket kan en WSDL-fil beskriva inte en, utan flera webbtjänster, då kommer varje webbtjänst att ha sin egen filial), och listas metoder webb-service. Dessa är själva "strängarna", genom att dra i dem kan du ge dig själv tillgång till den data som webbtjänsten tillhandahåller. Grenen "Datamodell" innehåller en beskrivning av de datatypsbibliotek som används av webbtjänsten.
En kort sammanfattning av hur du använder webbtjänsten finns vanligtvis på samma ställe som länken till WSDL-filen. När det gäller Aeroflot är detta sidan http://webservices.aeroflot.aero/flightstatus.asmx

"Nu start, nu landar..."