1.2 Použitelnost technologií pro úlohy interakce klient-server.

2. Rychlý start. kde začít?

Bod č. 0. Nejprve si musíte vybrat (rozhodnout) integrační technologii a porozumět „podstatě“ – tedy tomu, jak bude fungovat.
Jinými slovy, musíte odpovědět na dvě otázky:

• Která databáze 1C (nebo jiný program) bude fungovat jako klient a která jako server;

• Která technologie interakce klient-server je pro vás nejvhodnější a bude použita.

Bod č. 1.
Je tedy pochopena „podstata“ interakce klient-server. Byla stanovena technologie interakce. Nyní musíte vytvořit „zkušební pole“, kde bude probíhat vývoj.

V tomto článku budou na příkladech popsány dvě technologie:

Práce s mechanismem WEB služeb.

Budou zváženy příklady práce z 1C 8 a PHP;

Práce s mechanismem požadavku http (webové služby REST).

Budou také zváženy příklady práce z 1C 8 a PHP;
V úkolech souvisejících s vývojem WEB se tradičně přijímá:

• Vytvořte „testovací prostor“ pro vývoj a ladění na programátorově lokálním WEB serveru (localhost);
• Po dokončení vývoje musí být výsledky přeneseny na „bojový“ WEB server.

V praxi (zejména když se začínáte „seznamovat“ s technologií WEB služeb), při vytváření „zkušebního terénu“, stejně jako při přenosu projektu na „bojový“ server, vzniká spousta „hrabání“.

Abychom „neztráceli“ spoustu času „bojováním“ s nastavením IIS(Internet Information Server) / mastering serveru apache a nastavení práv Windows přístup, doporučuji následující:

• (1) Vytvořte "Polygon" na vašem místním pracovním počítači. Operační systém - Windows 7 (profesionální nebo maximální). Veškerá práce musí být provedena pod účet správce.
• (2) Nasaďte databázi 1C 8 v režimu klient-server (MS SQL server, doporučuji 2008 R2). Použití 1C 8 v režimu klient-server eliminuje potřebu provádět další práci. nastavení přístupových práv k databázi 1C z WEB serveru.
• (3) Nainstalujte IIS, pokud chybí. Ve Windows jej můžete pravidelně „přeinstalovat“.

Zaškrtávací políčka pro možnosti instalace součástí IIS lze nastavit ve výchozím nastavení.
Důležité věci, kterým musíte věnovat pozornost, jsou následující možnosti (rozšíření ISAPI – to je nezbytné pro fungování mydlových připojení ve WEBových službách a CGI – to je nutné pro fungování PHP)

Po dokončení instalace IIS Přesvědčte se, že to funguje. Za tímto účelem v adresní řádek Webový prohlížeč zadejte:

(4) Publikování (připojení) databáze 1C na WEB server.

A tak WEB server IIS nainstalováno a funkční. Zveřejněme naši databázi 1C a zkontrolujme, že přístup k ní je nyní možný i přes WEB klienta.

Je vhodné publikovat na WEB serveru databázi 1C, která zajišťuje provoz v režimu řízené aplikace (tenký klient).

Publikování databáze 1C se provádí takto:
V režimu konfigurátoru je třeba zavolat položku "Publikovat na webovém serveru"

b) Zadejte parametry publikace:

Tedy v adresáři (složce) wwwroot tvůj jeho IIS musíte vytvořit samostatnou složku (adresář) pro publikování vaší databáze 1C.

adresář wwwroot bude vytvořen automaticky při instalaci služby IIS
Vytvořme a vybereme takovou složku (wsBase10), uvedeme název pro publikaci (budeme ji také nazývat wsBase10).

Pokud náhle obdržíte zprávu jako odpověď,

pak se neboj.

Mechanismus publikování 1C je velmi rozmarný. Zkuste znovu kliknout na „Publikovat“.

A pokud v důsledku toho obdržíte zprávu,

to znamená, že vše fungovalo.

Je velmi důležité pochopit, že při publikování databáze 1C a jejích webových služeb na „bojovém“ serveru (například Windows 2008 R2) často dochází k chybám, pokud se rozhodnete použít webový server. IIS.

Rada: neinstalujte na "bojový" server IIS! Nainstalujte apache.

To vás ochrání před mnoha systémovými chybami. A zveřejnění (znovupublikování - se změnami v konfiguraci) proběhne za apache plynule, bez nutnosti pohrávat si se soubory a nastaveními vrd IIS.

V tomto článku nebudu zvažovat proces instalace a nastavení apache. Na toto téma existují i ​​jiné zdroje.

Nicméně ke spolupráci apache s databází 1C (a webovými službami) existuje několik velmi důležitých požadavků, které musíte znát (předložte je správci systému).

1. Při instalaci apache Nezapomeňte povolit podporu pro rozšíření ISAPI.

2. Povolte podporu cgi-bin, pokud budete pracovat s PHP;

3. Budete muset zadat speciálního „uživatele“ do databáze 1C...

Tento uživatel musí mít ověření operační systém. A musíte určit uživatele, pod jehož jménem se spouští apache.

... S apache jsme skončili a vraťme se znovu k našemu "Polygonu".

Tady vidíme - 1C začíná. WEB server spolu s 1C funguje.
4. Nainstalujte službu PHP pro WINDOWS.

Budete jej potřebovat, pokud v rámci svého úkolu potřebujete vyvinout klienta (webové stránky pro přístup k 1C) nebo server (scénáře pro zpracování http požadavků z 1C) v PHP.

5 Do IIS přidáme adresář wsClient10, ve kterém poběží naše PHP skripty.

PHP skripty, které budeme používat:

• Vytvořit klientskou část při vývoji WEB služeb 1C;
• Pro vývoj serverové části, při vývoji webových služeb REST (http požadavky).

6. Nainstalujme program Notepap++. Tento kompaktní a pohodlný program Doporučuji jej používat pro úpravu PHP skriptů.

Po instalaci programu Notepad++ okamžitě zkontrolujeme, zda pro nás PHP funguje. Vytvořme si k tomu jednoduchý skript hello.php. Umístíme jej do adresáře wsClient a spustíme skript z prohlížeče:

Vše OK. PHP funguje. Testovací místo je kompletně připraveno.

3. Vytvoření WEB služby, žádosti o mýdlo, XDTO a JSON. Příklady 1C a PHP. V této fázi byste měli mít „Polygon“ připravený a můžete začít vyvíjet WEB služby.

- Kde začít studovat tuto technologii? Samozřejmě s klasickým problémem jako „Ahoj slovo“!

1. Úkol vytvořit nejjednodušší Webová služba. Podívejme se na příklady v 1C a PHP.

1.1. Přidáme do databáze (wsBase10) webovou službu "_Calculations by Tariffs"

Nastavíme název souboru publikace na "calcOrder10.1cws". Musí být také specifikován jmenný prostor URI. V zásadě můžete zadat jakýkoli název.

1.2. Přidejme operaci „getHello“ v rámci webové služby „_Calculations by Tariffs“.

Podstata operace bude nejjednodušší – vzít tři parametry (řetězce, čísla) jako vstup (od klienta) a vrátit mu (ve výsledku) sjednocující řetězec zpět. Typ návratové hodnoty bude primitivní - řetězec.

Zaškrtávací políčko „V transakci“ nezaškrtneme, protože operace nezmění data v samotné databázi 1C.

Pokud by naše operace změnila data v databázi 1C, pak by zaškrtnutí tohoto políčka dávalo smysl.
Název metody (funkce), která zpracuje příchozí data (a vrátí výsledek), bude „getHello“.

1.3. Přidejme vstupní parametry pro operaci „getHello“.

Směr přenosu je "vstup". To znamená, že jsou přenášeny z klienta na server.

1.4. Pojďme napsat handler pro operaci „getHello“ v modulu webové služby
///////////////////

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

////////

1.5. V tomto okamžiku jsou práce na vytvoření jednoduché WEB služby dokončeny. A nyní je potřeba zveřejnit WEBovou službu "_Výpočty podle tarifů".

Před zveřejněním webové služby na testovacím webu odebereme všechny uživatele ze seznamu našich uživatelů informační základna. To znamená, že seznam uživatelů bude „prázdný“.

- Proč to dělat?

Na testovacím místě se k WEBovým službám bude moci připojit pouze vývojář, a proto nemá smysl poskytovat autentizaci uživatele při připojení k WEBové službě.

To znamená, že si záměrně zjednodušíme práci s WEB službami na testovacím webu.

Při navazování spojení nebudeme muset zadávat přihlašovací jméno a heslo.
Ale na „bojovém“ serveru samozřejmě budete muset poskytnout ověření.
Chcete-li to provést (jak bylo řečeno dříve), budete muset samostatně vytvořit uživatele v „bojové“ databázi, jejímž jménem bude spuštěn samotný WEB server. A poté, při navazování spojení s WEB službou (soap connection), budete také muset zadat přihlašovací jméno a heslo tohoto uživatele.

1.6. A tak zveřejníme WEBovou službu:

Všimněte si, že nemusíme zaškrtávat políčko „Použít ověření operačního systému na webovém serveru“. To je Protože tento režim poskytováno pouze pro WEB server IIS a na „bojovém“ serveru to bude fungovat Apache.

1.7. Vytvoříme klientskou část a otestujeme provoz WEB serveru.

A) Nejprve zavolejte klientovi z 1C.

Udělejme to jednoduše. V jakékoli jiné databázi 1C, kterou máte, vytvoříme externí zpracování. Při tomto zpracování se připojíme k WEBové službě, použijeme operaci „getHello“, předáme tam parametry a obdržíme odpověď ze serveru.
Kód pro "1C" bude něco takového:

/////

&OnClient
Postup Provést dotaz 10 (příkaz)
// Vložte obsah handleru.
LineResult = SERVER_ExecuteWSQuery10();
Warning(StringResult);
Konec procedury
&OnServerBez kontextu
Funkce SERVER_RunWSRequest10()
// Autentizaci na testovacím místě neprovedeme!
Uživatelské jméno = nedefinováno;
Heslo = nedefinováno;
http://localhost/wsBase10/ws/calcOrder10.1cws?wsdl ",UserName,Password);
Proxy.User = Uživatelské jméno;
Proxy.Password = Nedefinováno;
strResult = Proxy.getHello("Ivanov",100.35,20);
return strResult;
EndFunction ///////////////////////////////////////////////////////////////////////////////////////

Pojďme otestovat fungování funkce SERVER_ExecuteWSRequest10().

OK. Funguje!
b) Nyní provedeme klientské volání webové služby z PHP.
Kód skriptu PHP bude vypadat nějak takto:

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

error_reporting(E_ERROR); // 1. Zakažte nepotřebné zprávy
// 2. Zakázat ukládání do mezipaměti pro SOAP. Pokud se tak nestane,


// 3. Vytvořte mýdlové spojení
$client = new SoapClient("http://localhost/wsBase10/ws/calcOrder10.1cws?wsdl ",
pole(
"login" => null, //přihlášení, nebudeme provádět autentizaci
"password" => null, //heslo
"stopa" => pravda,
"features" => SOAP_USE_XSI_ARRAY_TYPE,
//"komprese" =>
);
// 4. Vyplnění pole předávaných parametrů
$params["strParametr"] = "test_Soap10:";
$params["floatParametr"] = 10,34;
$params["integerParametr"] = 12;
// 5. Proveďte operaci getHello
$result = $klient->getHello($params);
// 6. Zobrazte výsledek na obrazovce
var_dump($vysledek);
?>

////
///

Zavoláme skript z prohlížeče a zkontrolujeme jeho fungování:

Vše je v pořádku, volání 1C z WEB stránky funguje!

Pojďme si shrnout některé výsledky:
Problém jednoduché webové služby byl vyřešen. A nyní můžete začít vytvářet složitější webové služby.

A komplikace bude v tom, že (dosud) jsme operovali pouze s primitivními datovými typy. Samozřejmě budeme muset vysílat/přijímat i objektové (agregované) datové typy.

2. Úkol vytvoření WEB služby pomocí balíčků XDTO.

Stejně jako předtím se podívejme na příklady v 1C a PHP.

Položme si následující úkol: WEBová služba by nám měla vrátit nikoli řetězec, ale objektová data – „tabulku hodnot“ (přesněji to bude pole objektů!).

Aby bylo možné popsat různé datové struktury (které budou vyžadovány při příjmu/přenosu na WEB server), poskytuje platforma 1C:8 mechanismus pro balíčky XDTO.

Tito. Nejprve popíšeme všechny datové typy, které potřebujeme, a poté označíme:

• S jakými balíčky XDTO může naše WEB služba pracovat (můžete zadat buď jeden nebo seznam balíčků);
• Pro každý parametr operace a výsledek, který vrací, můžete určit, o jaký typ dat (z balíčku XDTO) se bude jednat.

Vytvořme operaci GetTzTariffs_0, která vrátí data typu tzTariffs.

Obrázek ukazuje, že tzTariffs zahrnuje neomezený počet el objektů. Ve skutečnosti je tzTariffs tabulka objektů typu el.

- Jak to vidět?

• Pokud je parametr "maximum" uveden jako "-1", pak počet těchto objektů není omezen (tabulka s neomezeným počtem řádků);
• Pokud nepotřebujeme tabulku, ale potřebujeme pouze strukturu (jeden řádek), pak by maximální a minimální hodnoty měly být zadány rovné „1“.
• Objekt el je zase struktura, která obsahuje atribut typu objektu (eTariff) a atribut primitivního typu (cPrice, komentář).

Když se posunete v hierarchii dolů, můžete vidět, že typ tarifu je struktura (maximální a minimální množství = 1), jejíž jeden z detailů zahrnuje typ kindOfTariff.

Celkový: Balíček XDTO umožňuje jasně popsat hierarchii datových typů, které budou dále používány při interakci s WEB službou.

Tip: Pro webovou službu je lepší použít jeden balíček XDTO, abyste se vyhnuli složitosti a chybám v návrhu.
Pojďme dál... Po:

• Balíček XTDO byl vytvořen;
• Všechny datové typy jsou popsány;
• U WEB služby je použití tohoto balíčku uvedeno;
• Pro parametry a výsledky operací jsou vybrány vhodné typy (z balíčku XDTO)

V našem příkladu by operace GetTzTariffs_0 měla vrátit pole řetězců obsahujících objekty Tariffs.

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

Funkce GetTzTariffs_0()
// Vložte obsah handleru.
Return GetTZTariffs_0();
EndFunction

Funkce GetTZTariffs_0()


// Vyplnění technických specifikací
// 1. řádek

kindOfTariff.active = false;


tarif.druh = druhTarif;

elementTZ.eTarif = tarif;
elementTZ.cCena = 100;

//
// 2. řádek
kindOfTariff = FactoryXDTO.Create(kindOfTariffType);

tarif = FactoryXDTO.Create(tariffType);
tarif.begdate = CurrentDate();
tarif.druh = druhTarif;
elementTZ = FactoryXDTO.Create(elementTZType);
elementTZ.eTarif = tarif;
elementTZ.cCena = 200;
// Přidání 2. řádku do tabulky
tzTariffs.el.Add(elementTZ);
Návrat tzTarifů;
EndFunction

//////////
Dále uvedeme příklad volání operace "GetTzTariffs_0" ze strany klienta, z 1C.

&OnClient
Postup Provést Query20 (příkaz)
// Vložte obsah handleru.
Upozornění(SERVER_ExecuteWSQuery20());
Konec procedury
&OnServerBez kontextu
Funkce SERVER_ExecuteWSRequest20()
Definice = new WSDefinitions("http://localhost/wsBase10/ws/calcOrder10.1cws?wsdl ");
Proxy = new WSProxy(Definice,"www.URI.com","_Calculations By Tariffs","_Calculations By TariffsSoap");
XDTResult = Proxy.GetTzTariffs_0();
// Přistupme k řádku s indexem nula, pak k atributu eTariff, pak k druhu vnořeného atributu a potom k názvu vnořeného atributu.
EndFunction

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
Podobné volání z PHP a zpracování výsledků XDTO by vypadalo takto:
////////////////////////////////////////////////////////////////////////////////////

// funkce webových služeb nebudou fungovat správně.
ini_set("soap.wsdl_cache_enabled", "0");
$client = new SoapClient("http://localhost/wsBase10/ws/calcOrder10.1cws?wsdl ");
$result = $klient->GetTzTariffs_0();
$mResult = $vysledek->vratit->el;
// mResult - pole objektů. Projdeme prvky pole a zobrazíme výsledky na obrazovce
pro ($i=0; $i {
echo"
";
$eTariff = iconv("utf-8","cp1251",$mResult[$i]->eTarif->fullName);
var_dump($eTarif);
$cPrice = $mResult[$i]->cPrice;
var_dump($cPrice);
$cComment = $mResult[$i]->cComment;
var_dump($cComment);
echo"
";
}
?>

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

Nyní Pojďme si úkol ještě více zkomplikovat. Přeneseme stejný objektový datový typ z klienta do WEB služby (jako parametr). Ať je to tzKind.
Za tímto účelem nejprve popíšeme tento typ v balíčku dataTariffs a poté přidáme operaci GetTzTariffs_1.

Označme typ parametru tzKind.

Příklad toho, jak webová služba pracuje s příchozím parametrem XDTO:
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

Funkce GetTZTariffs_1(tzKind)
tzTariffsType = FactoryXDTO.Type(" ", "tzTariffs");
tzTariffs = FactoryXDTO.Create(tzTariffsType);
elementTZType = FactoryXDTO.Type(" ", "elementTZ");
tarifType = FactoryXDTO.Type(" ", "tarif");
kindOfTariffType = FactoryXDTO.Type(" ", "kindOfTariff");
// Vyplnění technických specifikací
// 1. řádek
kindOfTariff = FactoryXDTO.Create(kindOfTariffType);
kindOfTariff.name = "Doprava";
kindOfTariff.active = false;
tarif = FactoryXDTO.Create(tariffType);
tarif.fullName = "Tarif 1";
tarif.begdate = CurrentDate();
tarif.druh = druhTarif;
elementTZ = FactoryXDTO.Create(elementTZType);
elementTZ.eTarif = tarif;
elementTZ.cCena = 100;
elementTZ.comment = "Popis tarifu 1";
// Přidejte 1. řádek do tabulky
tzTariffs.el.Add(elementTZ);
// 2. řádek
kindOfTariff = FactoryXDTO.Create(kindOfTariffType);
kindOfTariff.name = "Dodávka";
kindOfTariff.active = true;
tarif = FactoryXDTO.Create(tariffType);
tarif.fullName = "Tarif 2";
tarif.begdate = CurrentDate();
tarif.druh = druhTarif;
elementTZ = FactoryXDTO.Create(elementTZType);
elementTZ.eTarif = tarif;
elementTZ.cCena = 200;
elementTZ.comment = "Popis tarifu 2";
// Přidejte 3. řádek do tabulky (vyplňte jej příchozími daty)
tzTariffs.el.Add(elementTZ);
// 3. řádek
kindOfTariff = FactoryXDTO.Create(kindOfTariffType);
kindOfTariff.name = tzKind.el.eKind.name;
kindOfTariff.active = tzKind.el.eKind.active;
tarif = FactoryXDTO.Create(tariffType);
tarif.fullName = "Tarif 3";
tarif.begdate = CurrentDate();
tarif.druh = druhTarif;
elementTZ = FactoryXDTO.Create(elementTZType);
elementTZ.eTarif = tarif;
elementTZ.cCena = 300;
elementTZ.comment = "Popis tarifu 3";
// Přidání 3. řádku do tabulky
tzTariffs.el.Add(elementTZ);
Návrat tzTarifů;
EndFunction

//////////////////////////////////////////////////////////////////////////////////
Ze strany klienta 1C budeme muset připravit data typu tzKind a přenést je do WEB služby.

Zde je příklad takového volání:
/////////////////////////////////////////////////////////////////////////////////

&OnClient
Postup Provést Query30 (příkaz)
// Vložte obsah handleru.
Upozornění(SERVER_ExecuteWSQuery30());
Konec procedury
&OnServerBez kontextu
Funkce SERVER_ExecuteWSRequest30()
Definice = new WSDefinitions("http://localhost/wsBase10/ws/calcOrder10.1cws?wsdl ");
Proxy = new WSProxy(Definice,"www.URI.com","_Calculations By Tariffs","_Calculations By TariffsSoap");
// Vytvoří tabulku parametrů předávaných WS
tzKindType = Proxy.FactoryXDTO.Type(" ", "tzKind");
tzKind = Proxy.FactoryXDTO.Create(tzKindType);
kindOfTariffType = Proxy.FactoryXDTO.Type(" ", "kindOfTariff");
kindOfTariff = Proxy.XDTO Factory.Create(kindOfTariffType);
kindOfTariff.name = "Typ zkušebního tarifu";
kindOfTariff.active = false;
elementKindType = Proxy.FactoryXDTO.Type(" ", "elementKind");
elementKind = Proxy.XDTO Factory.Create(elementKindType);
elementKind.eKind = kindOfTariff;
elementKind.qty = 10;
// Přidání řádku do tabulky
tzKind.el.Add(elementKind);
XDTOResult = Proxy.GetTzTzriffs_1(tzKind);
ExampleResult_Name typu tarifu = XDTOResult.el.eTarif.kind.name;
Return ExampleResult_Name of Tariff Type;
EndFunction

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
Rád bych upozornil na design: Proxy.FactoryXDTO.Type("...

To znamená, že při vytváření objektu balíčku XDTO na klientovi musíme přistupovat nikoli k naší vlastní továrně XDTO!, ale prostřednictvím proxy. Tedy do továrny serverů XDTO.

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
Nyní je čas položit si otázku:existuje nějaká alternativa k XDTO objektům ?

Je možné s továrnou XDTO vůbec „nekomunikovat“, vysílat/přijímat z WEB služby nějak jinak.. (zejména pokud klient není 1C, ale např. WEB stránka, aplikace na Android, iOS , atd.).

Odpověď je- Ano můžeš!
Jako typy parametrů můžete například použít řetězec. A do něj „zabalit“ (serializovat) datové struktury.

Tato technologie v programování WEB byla dlouho vyvinuta a nazývá se JSON.
Velkou pomocí je také to, že v PHP se balení/extrahování jakékoli struktury/řetězce pole provádí v jednom kroku!
Příklad v PHP sbalení objektů v JSON/extrahování, vysílání/přijímání do WEB služby:

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

// serializujte pole mDelivery do řetězce a umístěte jej do parametru delivery
// * Nejprve si popišme strukturu doručení
doručení třídy (
var $id;
var $kontrolováno;
var $hodnota;
}
// Naplňte strukturu nějakými daty
$sDelivery = nová dodávka;
$sDelivery->id = "000000005";
$sDelivery->checked = TRUE;
$sDelivery->value = 0;
// Přidejte jej do pole objektů mDelivery
$mDelivery = $sDelivery;
// Převede pole mDelivery na řetězec JSON a výsledek umístí do parametru doručení
$params["delivery"] = json_encode($mDelivery);
// Volání operace ExitCalcOrder na WEBové službě a předání jí parametr (string - delivery);
$vysledek = $klient->ExitCalcOrder($params);
// Získejte výsledek operace ExitCalcOrder do proměnné jsCalcResult (řetězec)
$jsCalcResult = $výsledek->návrat;
// Proveďte zpětnou transformaci: z řetězce jsCalcResult na objekt (pole objektů, typ shoda) arrCalcResult
$arrCalcResult = json_decode($jsCalcResult);
// Zobrazení informací o objektu arrCalcResult na obrazovce
var_dump($arrCalcResult);

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

Ale jak provádět převody JSON v 1C?
Platforma 1C 8 nepodporuje standard JSON, ale to není problém.
Zpracování konverze/extrakce JSON existuje, je dostupné a funguje skvěle
// Copyright © 2010-2012 Alexander Pereverzev
// 1C:JSON . JavaScript Object Notation analyzátor a serializátor.

Jednoduše tedy vložte toto zpracování do své konfigurace a můžete snadno provádět dopředné a zpětné převody JSON:
Příklad serializace 1C objekt na řetězec JSON:

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

CargoData = nová struktura;
CargoData.Insert("code",CargoCode);
CargoData.Insert("číslo",CargoNumber);
CargoData.Insert("plán", QuantityPlan);
CargoData.Insert("character",CargoCharacter);
CargoData.Insert("balení", Balení);
CargoData.Insert("poškození",Poškození obalu);
CargoData.Insert("volume",Volume);
CargoData.Insert("hmotnost",Hmotnost);
CargoData.Insert("stav",Stav);
jsResult = JSON.WriteJSON(LoadData); //Výsledek převede na JSON
return jsResult;

Příklad extraktu objekt v 1C z řetězce JSON:
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

// 1. Obnovte objekty z JSON
JSON = Process.JSON.Create();
mdelivery = JSON.ReadJSON(doručení);
// výsledkem je, že mdelivery je pole. Element pole - zápas.
// To je například mdelivery.["id"] bude obsahovat "000000005"

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
Na závěr uvedu příklad volání webové služby 1C z PHP, přijímající vrácenou strukturu JSON její zpětné transformace do objektů PHP.

Věnujme pozornost proměnám iconv("cp1251","utf-8","
a iconv("utf-8","cp1251", což bude vyžadováno (při interakci s PHP - 1 C) pro převod řetězců azbuky z kódování cp 1251 na utf -8 a zpět.

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

error_reporting(E_ERROR); // Zakázat zprávy
// Zakázat ukládání do mezipaměti pro SOAP. Pokud se tak nestane,
// funkce webových služeb nebudou fungovat správně.
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["kód"]);
$params["param2"] = iconv("cp1251","utf-8",$_GET["číslo"]);
$vysledek = $klient->executeQuery($params);
$jsResult = $vysledek->vratit;
$dataFreight = json_decode($jsResult);
$statusFreight = $dataFreight->codeNm;
$numberFreight = iconv("utf-8","cp1251",$dataFreight->nameRus);
?>

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

Pravděpodobný scénář je: vzdálený uživatel z některého z jeho programů (například z WEBu, mobilní aplikace atd.) zavolá na vaši WEB službu a... neobdrží výsledky.. Nebo je obdrží, ale něco není v pořádku.

Otázka: - Jak se o takových chybách dozvědět a odladit WEB službu?
Pro sledování chyb (a shromažďování příchozích parametrů „co vedlo webovou službu k chybě“) doporučuji používat protokol.

Tito. v místě, kde se mohou vyskytnout logické chyby, programově uložit informace o příchozích parametrech do registračního logu (LogRecord)

Pokud „zápasíte“ s „runtime chybami“, můžete je zachytit (pokus je výjimkou) a „bod po bodu“ zaznamenat celou situaci.

Výsledkem je, že pomocí protokolu budete moci vidět informace o chybách, reprodukovat parametry výskytu a „porazit“ jej v interaktivním režimu v debuggeru.

Pojďme si to shrnout: Jsou zvažovány příklady práce s WEB službami od 1C a PHP. K přenosu objektových datových struktur mezi klientem a serverem jsme použili dvě technologie:

• (1) Balíčky XDTO
• (2) Objekty JSON.

4. Alternativa - webové služby REST (požadavky http). Příklady implementace v 1C a PHP.
V předchozí části jsme se podrobně zabývali technologií WEB služeb. V této části se budeme zabývat alternativní technologií, tzv. Webové služby REST.

Nabízí se správná otázka: - Proč?

WEB služby jsou plně funkční a umožňují řešit problémy jakékoliv složitosti.

Abychom pochopili „proč“, zformulujme základní rozdíly mezi těmito technologiemi.

Technologie WEB služeb je založena na 2 bodech:

• (1) Používá se připojení SOAP. Jinými slovy je proveden požadavek SOAP.

Definice = new WSDefinitions("http://localhost/wsBase10/ws/calcOrder10.1cws?wsdl",UserName,Password);
Proxy = new WSProxy(Definice,"www.URI.com","_Calculations By Tariffs","_Calculations By TariffsSoap");

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

V PHP je to takto:

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

$client = new SoapClient("http://localhost/wsBase10/ws/calcOrder10.1cws?wsdl ",
pole(
"login" => přihlášení, //přihlášení,
"password" => pass, //password
"stopa" => pravda,
"features" => SOAP_USE_XSI_ARRAY_TYPE,
//"komprese" => SOAP_COMPRESSION_ACCEPT | SOAP_COMPRESSION_GZIP | 5
);

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

• (2) Pro zpracování mydlového připojení v režimu serveru poskytuje platforma 1C 8 speciální webové služby metadatového objektu.

Navíc, pokud ve vašem úkolu musí „1C“ fungovat jako server, pak neexistuje žádná alternativa k technologii 1C WEB.

- Kdy je možná alternativa?

• Za prvé, když 1C vystupuje pouze jako klient;
• Za druhé, když server, se kterým potřebujete pracovat (například webová stránka nebo nějaký druh WEB aplikace), není plánováno podporovat připojení SOAP.

Velmi oblíbená možnost - http připojení.

Ve webových systémech (PHP, Android, iOS) je snazší pracovat s požadavky http než s požadavky SOAP. A pro nepříliš složité projekty je technologie http request docela vhodná.

Klasickým řešením (pomocí metody http request) je úkol integrovat databázi 1C a WEB. Například informace o sortimentu a cenách jsou přenášeny na stránku a informace o přijatých objednávkách jsou přenášeny zpět ze stránky.

Je typické, že v typických konfiguracích 1C je integrace s weby realizována pomocí požadavků http.
Pojďme se tedy podívat na technologii http požadavky Například interakce mezi 1C (klient, 1C 8) a WEB stránkou (PHP, server).

1. Navázání spojení a metody pro předávání parametrů v http požadavku
Příklad navázání připojení k serveru ze strany 1C:
/////////////////////////////////////////////////////////////////////////////

chráněný = nepravdivý;
HTTPConnect = new HTTPConnect("localhost/wsClient10/json/testHTTPQuery11.php", Protected);

////////////////////////////////////////////////////////////////////////////
Jak víte, existují dva způsoby přenosu parametrů z klienta na server prostřednictvím protokolu http:

(1) Metoda "get";

Parametry (jako je jméno a heslo) se zadávají přímo v URL volání serveru.

To znamená, že interaktivní volání skriptu (přímo z webového prohlížeče) by vypadalo takto:

V 1C:8 je pro programové volání serveru (a předávání parametrů metod Get mu) k dispozici metoda „Get“.

Příklad:
chráněný = nepravdivý;
HTTPConnect = new HTTPConnect("localhost", Secure);
HTTPConnect.Get("wsClient10/json/testHTTPQuery11.php?nameVasya&password=123",OutputFileName);

kde OutputFileName: Název souboru, do kterého jsou umístěna data vrácená ze serveru.
To znamená, že v důsledku zpracování požadavku server vrátí výsledek do 1C a poté se (automaticky) vygeneruje soubor, který obsahuje výsledek.

V souladu s tím je v „1C“ nutné (programově) přečíst tento soubor a extrahovat z něj získaný výsledek. To je vše.

(2) metoda "post";

V této volbě nejsou parametry umístěny v URL, ale jsou přenášeny samostatně, v těle http spojení.

Je jasné, že klíčové omezení metody dostat je objem a obsah přenášených dat. Tedy s pomocí dostat Lze předávat pouze znaky a délka řetězce adresy URL je omezena.

Metoda pošta Můžete přenášet data různého obsahu, vč. a libovolné soubory.
Tím pádem, pošta pro integrační úlohy je funkčnější a budeme s ním dále pracovat.

Pro příjem/přenos dat mezi 1C a WEB stránkou použijeme textové soubory.
A data ze souborů budeme „balit/extrahovat“ pomocí nám již známé technologie JSON! To nás prakticky ušetří nutnosti „parsovat“ soubor na straně 1C a na straně PHP.

Chcete-li volat server a přenášet na něj parametry pomocí metody „post“, poskytuje 1C:8 metodu: SendForProcessing

A tak si uveďme příklad, ve kterém na straně 1C jsou provedeny všechny kroky zpracování http požadavek:

Nejprve si zapišme akční plán (zvětšený):

A nyní jeho softwarová implementace v 1C:8

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

// 1. Vyplňte strukturu přenášených dat
postDataToPHP = nová struktura;
postDataToPHP.Insert("param1","ivanon");
postDataToPHP.Insert("param2","ivan");
postDataToPHP.Insert("param3","ivanovich");

// 2. Převeďte data na řetězec JSON
JSON = Process.JSON.Create();
jsPostDataToPHP = JSON.WriteJSON(postDataToPHP);

// 3. Vytvořte dočasnou odchozí zprávu (odeslanou na server pomocí metody POST)
// soubor, vložte do něj řetězec JSON.
tFile = new TextDocument;
stringData = jsPostDataToPHP;
tFile.AddLine(stringData);

// 4. Získejte název dočasného odchozího souboru. Bude obsahovat odchozí data ve formě řetězce JSON
Odchozí název_souboru = GetTemporaryFileName(.txt");
tFile.Write(Název odchozíhoSouboru,TextEncoding.UTF);

// 5. Získejte název dočasného vstupního souboru. Obdrží řetězec JSON: odpověď serveru PHP
InputFileName = GetTemporaryFileName(.txt");

// 6. Navažte spojení HTTP se serverem
chráněný = nepravdivý;
HTTPConnect = new HTTPConnect("localhost/wsClient10/json/testHTTPQuery10.php", Protected);

// 7. Proveďme HTTP požadavek. Přeneseme odchozí soubor na server (soubor obsahuje objekt JSON, tj. odchozí parametry)

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

// A my obdržíme odpověď ze serveru (příchozí soubor). Soubor obsahuje objekt //JSON (tj. data vrácená ze serveru)

// 8. Extrahujte data přijatá ze serveru z příchozího souboru
ResponseFile = nový TextDocument;
ResponseFile.Read(InputFileName,TextEncoding.UTF);
json_Data = ResponseFile.GetString(1);
mData = JSON.ReadJSON(json_Data);

// 9. Zobrazení přijatých dat pro uživatele
Report(mData["v1"]);
Report(mData["v2"]);

// 10. Smažte použité (již nepotřebné) dočasné soubory.
DeleteFiles(OutgoingFileName);
DeleteFiles(InputFileName);

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

A nakonec, příklad v PHP pro zpracování požadavku na straně serveru:

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

// 1. Získejte data řetězce z příchozího souboru
$json_filedata = file_get_contents("php://input");
// 2. Odřízněte všechny nepotřebné (přidají se 2 servisní znaky), které // narušují převod z JSON
$jsData = trim(ltrim($json_filedata));
$dlinaStr = strlen($jsData);
$_jsData = "";
$i=1;
zatímco ($i<$dlinaStr) {
pokud ($i>2) (
$_jsData = $_jsData.substr($jsData, $i, 1);
}
$i++;
}
// 3. Převod dat z JSON na objekt (strukturu)
$mData = json_decode($_jsData);
// 4. Vytvoříme další strukturu, kterou naplníme daty a // vrátíme se do 1C
třída returnData(
var $v1;
var $v2;
}
$sReturnData = new returnData;
$sReturnData->v1 = $mData->param1;
$sReturnData->v2 = $mData->param2;
// 5. Převeďte data struktury na řetězec JSON
$json_returnData = json_encode($sReturnData);
// 6. Vraťte data do 1C (výstupní data budou přesměrována do souboru, který bude vrácen do 1C)
echo $json_returnData;
?>

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

To je vše. Kompaktní a funkční!

5. Úkoly na vyžádání (projektové případy)

Na závěr uvedu ty, které jsou nyní zákazníky de facto nejžádanější a které jsou řešeny pomocí WEB služeb a http požadavků.

Název tématu je opravdu otázka, protože... Sám nevím, co to je a poprvé se s tím pokusím pracovat v rámci tohoto článku. Jediné, co mohu zaručit, je, že níže uvedený kód bude fungovat, ale moje fráze budou pouze domněnky a dohady o tom, jak tomu všemu sám rozumím. Tak pojďme...

Úvod

1. MÝDLO. Před voláním vzdálené procedury musíte toto volání popsat v souboru XML ve formátu SOAP. SOAP je jednoduše jedním z mnoha značek XML, které se používají ve webových službách. Vše, co chceme někam poslat přes HTTP, se nejprve převede do XML SOAP popisu, pak se nacpe do HTTP paketu a přes TCP/IP se pošle na jiný počítač v síti.
2. WSDL. Existuje webová služba, tzn. program, jehož metody lze volat na dálku. Norma však vyžaduje, aby byl tento program doprovázen popisem, který říká, že „ano, máte pravdu – toto je skutečně webová služba a můžete z ní volat takové a takové metody“. Tento popis je reprezentován jiným souborem XML, který má jiný formát, a to WSDL. Tito. WSDL je pouze soubor XML popisující webovou službu a nic víc.

Obecný přístup

1. Popište rozhraní naší webové služby
2. Implementujte toto rozhraní
3. Spusťte naši webovou službu
4. Napište klienta a vzdáleně zavolejte požadovanou metodu webové služby

Server

Klient

Závěr

Název tématu je opravdu otázka, protože... Sám nevím, co to je a poprvé se s tím pokusím pracovat v rámci tohoto článku. Jediné, co mohu zaručit, je, že níže uvedený kód bude fungovat, ale moje fráze budou pouze domněnky a dohady o tom, jak tomu všemu sám rozumím. Tak pojďme...

Úvod

1. MÝDLO. Před voláním vzdálené procedury musíte toto volání popsat v souboru XML ve formátu SOAP. SOAP je jednoduše jedním z mnoha značek XML, které se používají ve webových službách. Vše, co chceme někam poslat přes HTTP, se nejprve převede do XML SOAP popisu, pak se nacpe do HTTP paketu a přes TCP/IP se pošle na jiný počítač v síti.
2. WSDL. Existuje webová služba, tzn. program, jehož metody lze volat na dálku. Norma však vyžaduje, aby byl tento program doprovázen popisem, který říká, že „ano, máte pravdu – toto je skutečně webová služba a můžete z ní volat takové a takové metody“. Tento popis je reprezentován jiným souborem XML, který má jiný formát, a to WSDL. Tito. WSDL je pouze soubor XML popisující webovou službu a nic víc.

Obecný přístup

1. Popište rozhraní naší webové služby
2. Implementujte toto rozhraní
3. Spusťte naši webovou službu
4. Napište klienta a vzdáleně zavolejte požadovanou metodu webové služby

Server

Klient

Závěr

Dnes jsou WEB služby využívány téměř všude – poskytují nám informace o letech letadlem a vlakem, směnných kurzech a počasí. Není divu, že 1C má také schopnost vytvářet své vlastní WEB služby, což jí umožňuje jednat jako dodavatel i spotřebitel. Tento mechanismus je zabudován do platformy 1C:Enterprise 8.3 a vývojáři mohou dokonce do standardní konfigurace přidávat své vlastní objekty typu WEB služeb. Jejich architektura je postavena na sadě služeb, které umožňují výměnu informací s jiným softwarem.

Vytvoření webové služby 1C

Jednou z hlavních výhod 1C WEB služeb je absence nutnosti poskytovat přímý přístup k datům informační bezpečnosti. Správně nakonfigurovaná webová služba 1C umožňuje dalším aplikacím používat funkce zvenčí. V takových případech by měla funkce sama určovat právo používat data podle zadaných parametrů podle pravidel předepsaných vývojářem.

Jak vytvořit webovou službu v 1C?

Aby byla určitá funkce systému 1C dostupná externímu softwaru, je nutné provést následující algoritmus akcí:

1. Přejděte do konfigurace a přidejte objekt WEB služby do určité větve stromu;
2. Popište všechny operace, které může naše funkce provádět. Popis funkcí se provádí v modulu ve vestavěném jazyce 1C;
3. Přidejte popis parametrů funkcí webové služby. Vezměte prosím na vědomí, že datové typy jsou popsány s ohledem na existující typy mechanismu XDTO zavedené v platformě verze 8.1;
4. Publikovat vytvořenou webovou službu na serveru. Mechanismus zabudovaný do platformy 1C podporuje následující standardy:

• SSL/TLS
• WS-I BP

Příklad vytvoření jednoduché WEB služby

Abychom co nejjasněji demonstrovali fungování mechanismu WEBových služeb, vytvořte si příklad – funkcionalitu, která určuje délku zadávaného řetězce. Software předá řetězec jako parametr požadavku a funkce popsaná v 1C vrátí počet znaků. Při vytváření je třeba pamatovat na to, že zveřejněním tohoto mechanismu k němu budou mít přístup různé programy. Protože ne každý software je schopen přijímat azbuku, budeme konfigurační objekty pojmenovávat pomocí latinských znaků.

Otevřete konfigurátor, najděte ve stromu větev „WEB services“ a přidejte novou službu „wa_LengthString“. Musíte také přidat novou operaci na kartě „Operace“. Nazvěme to „CalcLengthString“, ve vlastnostech určete typ návratové hodnoty – int nebo integer a vytvořte v něm parametr „InputString“. Typ hodnoty ponecháme jako řetězec.

Nyní je potřeba zaregistrovat akci funkce CalcLengthString v modulu WEB služby. Chcete-li to provést, otevřete vlastnosti vytvořené funkce a klikněte na tlačítko ve formě lupy vpravo vedle vstupního pole „Název procedury“. 1C automaticky vytvoří funkci v našem modulu WEB služeb a otevře ji, abychom mohli popsat akci CalcLengthString. Využijme toho a napišme akci funkce – určení délky vstupního řetězce.

Tím je vlastně tvorba jednoduché WEB služby dokončena. Nyní je nutné „umístit“ tuto službu do veřejné domény, aby software třetích stran nebo jiné systémy 1C mohly tuto funkci využívat.

Abychom mohli vytvořenou webovou službu s její funkčností publikovat, potřebujeme mít na stránky přístup. Než začneme službu publikovat, musíme zkontrolovat název souboru ve vlastnostech vytvořeného modulu wa_LengthString. Měl by být jasný, jednoduchý a měl by mít příponu „1cws“.

Nyní je čas publikovat webovou službu, kterou jsme vytvořili na serveru. Tato funkce se objevila v platformě verze 8.3 a mnoho společností si již plně uvědomilo výhody této funkce. Pro zahájení publikování je třeba v konfigurátoru otevřít formulář „Administrace/Publikování na webovém serveru...“.

V okně, které se otevře, musíme nakonfigurovat webové služby 1C a vyplnit určitá pole:

• Název. Označuje složku na webovém serveru, ve které bude uložen popis naší webové služby. Dávejte pozor na velká a malá písmena, protože někdy servery rozlišují mezi velkými a malými písmeny;
• Webový server. Musíte vybrat server ze serverů nainstalovaných na vašem počítači;
• Katalog. Musíte vybrat cestu ke složce, kde jsou uložena data webového serveru pro nastavení připojení. Používají se pouze latinská písmena;
• Dva znaky booleovského typu. První se nám bude hodit, pokud potřebujeme nakonfigurovat přístup ke konfiguraci přes webového klienta. Chcete-li publikovat službu 1C, musíte zaškrtnout druhé políčko.

Zbývá pouze zkontrolovat, zda má požadovaná WEB služba zaškrtnuté políčko v prvním sloupci a kliknout na „Publikovat“.

Protože je tento mechanismus stále zcela nový, můžete se setkat s chybou jako „Při provádění operace se souborem došlo k chybě...“. V tomto případě stačí znovu kliknout na „Publikovat“. Ve většině případů to pomůže a zobrazí se zpráva oznamující, že webová služba byla publikována.

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

V reakci na takovou žádost o adresu musí prohlížeč zobrazit strukturu souboru XML. Pokud uvidíte prázdnou stránku, chybu nebo podivné znaky (problémy s kódováním), musíte znovu zkontrolovat všechny kroky. Je také dobré se ujistit, že je server správně nakonfigurován a máte k němu přístup. Po úspěšném zveřejnění budou moci webovou službu 1C používat aplikace třetích stran.

Zřeknutí se odpovědnosti a podmínky použití

Další vyloučení odpovědnosti (po mnoha případech)

Úvod

Pro ty, kteří jsou úplně „mimo mísu“: o webových službách „na dosah ruky“

Odkud jsou nohy, tzn. křídla rostou

Řekl: "Pojďme!"

Tento strom představuje „portrét“ webové služby, jak ji vidí 1Ska. To nejzajímavější je na větvi „Webové služby“: toto jména A porty webové služby (ve skutečnosti může soubor WSDL popisovat ne jednu, ale několik webových služeb, pak bude mít každá webová služba svou vlastní větev) a jsou uvedeny metody webová služba. Jedná se o samotné „provázky“, jejichž zatažením si zpřístupníte data, která webová služba poskytuje. Větev "Datový model" obsahuje popis knihoven datových typů, které webová služba používá.
Stručné shrnutí toho, jak webovou službu používat, obvykle najdete na stejném místě jako odkaz na soubor WSDL. V případě Aeroflotu je to stránka http://webservices.aeroflot.aero/flightstatus.asmx

"Teď vzlet, teď přistání..."