1.2 Anvendelighet av teknologier for klient-server-interaksjonsoppgaver.

2. Rask start. Hvor skal jeg begynne?

Punkt nr. 0. Først av alt må du velge (bestemme deg) for integreringsteknologien og forstå "essensen" - det vil si hvordan det vil fungere.
Du må med andre ord svare på to spørsmål:

• Hvilken 1C-database (eller annet program) vil fungere som klient, og hvilken som server;

• Hvilken klient-server-interaksjonsteknologi er best egnet for deg og vil bli brukt.

Punkt nr. 1.
Så "essensen" av klient-server-interaksjon er forstått. Interaksjonsteknologi er bestemt. Nå må du lage en "prøveplass" der utviklingen vil finne sted.

I denne artikkelen vil to teknologier bli diskutert ved hjelp av eksempler:

Arbeide med WEB-tjenestemekanismen.

Eksempler på arbeid fra 1C 8 og PHP vil bli vurdert;

Arbeide med http-forespørselsmekanismen (REST Web Services).

Eksempler på arbeid fra 1C 8 og PHP vil også bli vurdert;
I oppgaver knyttet til WEB-utvikling er det tradisjonelt akseptert:

• Opprett en "testplass" for utvikling og feilsøking på programmererens lokale WEB-server (localhost);
• Etter at utviklingen er fullført, må resultatene overføres til "combat" WEB-serveren.

I praksis (spesielt når du begynner å "bli kjent" med teknologien til WEB-tjenester), når du oppretter en "testplass", så vel som når du overfører et prosjekt til en "kamp"-server, oppstår det mye "rake".

Så for ikke å "kaste bort" mye tid på å "slosse" med innstillingene IIS(Internet Information Server) / mestring av serveren apache, og sette opp rettigheter Windows-tilgang, jeg anbefaler følgende:

• (1) Lag "Polygon" på din lokale arbeidsmaskin. Operativsystem - Windows 7 (profesjonelt eller maksimum). Alt arbeid skal gjøres under regnskap administrator.
• (2) Distribuer 1C 8-databasen i klient-server-modus (MS SQL server, jeg anbefaler 2008 R2). Bruk av 1C 8 i klient-server-modus vil eliminere behovet for å utføre ekstra arbeid. innstillinger for tilgangsrettigheter til 1C-databasen fra WEB-serveren.
• (3) Installer IIS, hvis den mangler. I Windows kan du "installere" det regelmessig

Avmerkingsboksene for installasjonsalternativene for IIS-komponenter kan settes som standard.
De viktige tingene du må ta hensyn til er følgende alternativer (ISAPI-utvidelser - dette er nødvendig for at såpeforbindelser skal fungere i WEB-tjenester, og CGI - dette kreves for at PHP skal fungere)

Etter at installasjonen er fullført IIS La oss sørge for at det fungerer. For dette, i adressefeltet Nettleser skriv inn:

(4) Publisere (koble til) en 1C-database på en WEB-server.

Og så, WEB-server IIS installert og fungerer. La oss publisere vår 1C-database og sjekke at tilgang til den nå er mulig gjennom WEB-klienten også.

Det anbefales å publisere 1C-databasen på en WEB-server som sørger for drift i administrert applikasjonsmodus (tynnklient).

Å publisere en 1C-database gjøres slik:
I konfiguratormodus må du kalle elementet "Publiser på en webserver"

b) Spesifiser publikasjonsparametere:

Det vil si i en katalog (mappe) wwwroot din hans IIS du må opprette en egen mappe (katalog) for publisering av 1C-databasen.

wwwroot-katalogen opprettes automatisk når IIS er installert
La oss lage og velge en slik mappe (wsBase10), spesifisere navnet for publisering (vi vil også kalle det wsBase10).

Hvis du plutselig mottar en melding som svar,

så ikke vær redd.

1C-publiseringsmekanismen er veldig lunefull. Prøv å klikke "Publiser" igjen.

Og hvis du som et resultat mottar en melding,

det betyr at alt fungerte.

Det er veldig viktig å forstå at når du publiserer en 1C-database og dens WEB-tjenester på en "combat"-server (for eksempel Windows 2008 R2), oppstår det ofte feil hvis du bestemmer deg for å bruke en webserver IIS.

Råd: ikke installer på en "combat"-server IIS! Installere apache.

Dette vil beskytte deg mot mange systemfeil. Og publisering (republisering - med endringer i konfigurasjonen) vil skje for apache problemfritt, uten å måtte tukle med vrd-filer og innstillinger IIS.

I denne artikkelen vil jeg ikke vurdere installasjonsprosessen og apache-innstillinger. Det finnes andre kilder om dette emnet.

Imidlertid for samarbeid apache med 1C-databasen (og webtjenester) er det flere svært viktige krav du må kjenne til (bring dette til systemadministratoren din).

1. Ved installasjon apache Sørg for å aktivere støtte for ISAPI-utvidelser.

2. Aktiver cgi-bin-støtte hvis du skal jobbe med PHP;

3. Du må angi en spesiell "bruker" i 1C-databasen...

Denne brukeren må ha autentisering operativsystem. Og du må spesifisere brukeren under hvis navn det er lansert apache.

... Vi er ferdige med apache og la oss gå tilbake til vår "Polygon" igjen.

Her ser vi - 1C starter. WEB-serveren sammen med 1C fungerer.
4. Installer PHP-tjenesten for WINDOWS.

Du trenger det hvis du som en del av oppgaven din må utvikle klient (websider for tilgang til 1C) eller server (scenarioer for behandling av http-forespørsler fra 1C) i PHP.

5 La oss legge til wsClient10-katalogen til IIS, der PHP-skriptene våre vil kjøre.

PHP-skript vi vil bruke:

• Å skape klientdelen ved utvikling av 1C WEB-tjenester;
• For utvikling av serverdelen, ved utvikling av REST webtjenester (http-forespørsler).

6. La oss installere Notepap++-programmet. Denne kompakte og praktisk program Jeg anbefaler å bruke den til å redigere PHP-skript.

Etter å ha installert Notepad++, sjekker vi umiddelbart at PHP fungerer for oss. La oss lage et enkelt hello.php-skript for dette. La oss plassere den i wsClient-katalogen og kjøre skriptet fra nettleseren:

Alt ok. PHP fungerer. Teststedet er helt klart.

3. Opprettelse av en WEB-tjeneste, såpeforespørsler, XDTO og JSON. Eksempler 1C og PHP. På dette stadiet bør du ha "Polygon" klar og du kan begynne å utvikle WEB-tjenester.

– Hvor skal man begynne å studere denne teknologien? Selvfølgelig, med et klassisk problem som "Hei ord"!

1. Oppgaven med å lage den enkleste Nettjeneste. La oss se på eksempler i 1C og PHP.

1.1. La oss legge til databasen (wsBase10) nettjenesten "_Calculations by Tariffs"

La oss sette publikasjonsfilnavnet til "calcOrder10.1cws". URI-navneområdet må også spesifiseres. I prinsippet kan du angi hvilket som helst navn.

1.2. La oss legge til "getHello"-operasjonen i nettjenesten "_Calculations by Tariffs".

Essensen av operasjonen vil være den enkleste - ta tre parametere (strenger, tall) som input (fra klienten) og returner en samlende streng tilbake til ham (som et resultat). Returverditypen vil være primitiv - streng.

Vi vil ikke merke av for "I transaksjon", siden operasjonen ikke vil endre dataene i selve 1C-databasen.

Hvis operasjonen vår endret data i 1C-databasen, ville det være fornuftig å merke av i denne boksen.
Navnet på metoden (funksjonen) som skal behandle innkommende data (og returnere resultatet) vil være "getHello".

1.3. La oss legge til innkommende parametere for "getHello"-operasjonen.

Sendingsretningen er "input". Det vil si at de overføres fra klienten til serveren.

1.4. La oss skrive en behandler for "getHello"-operasjonen i webtjenestemodulen
///////////////////

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

////////

1.5. På dette tidspunktet er arbeidet med å lage en enkel WEB-tjeneste fullført. Og nå må du publisere WEB-tjenesten "_Calculations by Tariffs".

Før vi publiserer en webtjeneste på testsiden, vil vi fjerne alle brukere fra listen over brukere til vår informasjonsgrunnlag. Det vil si at vi vil gjøre listen over brukere "tom".

- Hvorfor gjøre dette?

På teststedet er det kun utvikleren som vil kunne koble seg til WEB-tjenester, og derfor er det ingen vits i å gi brukerautentisering ved tilkobling til WEB-tjenesten.

Det vil si at vi bevisst vil forenkle vårt arbeid med WEB-tjenester på teststedet.

Vi trenger ikke å spesifisere pålogging og passord når vi oppretter en tilkobling.
Men på en "kamp"-server må du selvfølgelig gi autentisering.
For å gjøre dette (som tidligere nevnt), må du separat opprette en bruker i "kamp"-databasen, på hvis vegne selve WEB-serveren vil bli lansert. Og så, når du oppretter en forbindelse med WEB-tjenesten (såpeforbindelse), må du også spesifisere pålogging og passord til denne brukeren.

1.6. Og så, la oss publisere WEB-tjenesten:

Merk at vi ikke trenger å merke av for "Bruk operativsystemautentisering på webserveren". Det er fordi denne modusen gitt kun for WEB-server IIS, og på "combat"-serveren vil det fungere Apache.

1.7. La oss lage en klientdel og teste driften av WEB-serveren.

EN) Først, la oss ringe klienten fra 1C.

La oss gjøre det enkelt. I en hvilken som helst annen 1C-database du har, vil vi opprette ekstern behandling. I denne behandlingen vil vi koble til WEB-tjenesten, bruke "getHello"-operasjonen, sende parametrene der og motta et svar fra serveren.
Koden for "1C" vil være omtrent slik:

/////

&På klient
Prosedyre Utfør spørring10 (kommando)
// Sett inn innholdet i behandleren.
LineResult = SERVER_ExecuteWSQuery10();
Advarsel(StringResult);
Slutt på prosedyre
&PåServerUten kontekst
Funksjon SERVER_RunWSRequest10()
// Vi vil ikke utføre autentisering på teststedet!
Brukernavn = udefinert;
Passord = udefinert;
http://localhost/wsBase10/ws/calcOrder10.1cws?wsdl ",Brukernavn,Passord);
Proxy.User = Brukernavn;
Proxy.Password = Udefinert;
strResult = Proxy.getHello("Ivanov",100.35,20);
return strResult;
EndFunction ///////////////////////////////////////////////////////////////////////////////////////

La oss teste driften av SERVER_ExecuteWSRequest10()-funksjonen.

OK. Virker!
b) La oss nå foreta et klientanrop til webtjenesten fra PHP.
PHP-skriptkoden vil være omtrent slik:

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

error_reporting(E_ERROR); // 1. Deaktiver unødvendige meldinger
// 2. Deaktiver caching for SOAP. Hvis dette ikke gjøres,


// 3. Etabler en såpeforbindelse
$client = new SoapClient("http://localhost/wsBase10/ws/calcOrder10.1cws?wsdl",
array(
"login" => null, //login, vi vil ikke utføre autentisering
"passord" => null, //passord
"spor" => sant,
"funksjoner" => SOAP_USE_XSI_ARRAY_TYPE,
//"komprimering" =>
);
// 4. Fylle utvalget av beståtte parametere
$params["strParametr"] = "test_Soap10:";
$params["floatParametr"] = 10.34;
$params["integerParametr"] = 12;
// 5. Utfør getHello-operasjonen
$result = $client->getHello($params);
// 6. Vis resultatet på skjermen
var_dump($resultat);
?>

////
///

La oss kalle skriptet fra nettleseren og sjekke hvordan det fungerer:

Alt er bra, å ringe 1C fra en WEB-side fungerer!

La oss oppsummere noen resultater:
Problemet med en enkel WEB-tjeneste er løst. Og nå kan du begynne å lage mer komplekse WEB-tjenester.

Og komplikasjonen vil være at vi (så langt) kun har operert med primitive datatyper. Selvfølgelig må vi også overføre/motta objektdatatyper (aggregerte).

2. Oppgaven med å lage en WEB-tjeneste ved hjelp av XDTO-pakker.

Som før, la oss se på eksempler i 1C og PHP.

La oss sette oss følgende oppgave: WEB-tjenesten skal returnere oss ikke en streng, men objektdata - en "verditabell" (mer presist, det vil være en rekke objekter!).

For å beskrive ulike datastrukturer (som vil være nødvendig ved mottak/overføring til WEB-serveren), gir 1C:8-plattformen en mekanisme for XDTO-pakker.

De. Først beskriver vi alle datatypene vi trenger, og deretter angir vi:

• Hvilke XDTO-pakker kan vår WEB-tjeneste fungere med (du kan spesifisere enten en eller en liste over pakker);
• For hver parameter av operasjonen og resultatet den returnerer, kan du spesifisere hvilken type data (fra XDTO-pakken) det skal være.

La oss lage GetTzTariffs_0-operasjonen, som vil returnere data av typen tzTariffs.

Figuren viser at tzTariffer inkluderer et ubegrenset antall el-objekter. Faktisk er tzTariffer en tabell over objekter av typen el.

– Hvordan se det?

• Hvis parameteren "maksimum" er spesifisert som "-1", er antallet av disse objektene ikke begrenset (en tabell med et ubegrenset antall rader);
• Hvis vi ikke trenger en tabell, men bare trenger en struktur (en rad), bør maksimums- og minimumsverdiene spesifiseres lik "1".
• I sin tur er el-objektet en struktur som inneholder et objekttypeattributt (eTariff) og et primitivt typeattributt (cPrice, kommentar).

Når du beveger deg nedover i hierarkiet, kan du se at tarifftypen er en struktur (maksimal og minimumsmengde = 1), hvor en av detaljene inkluderer typen typeOfTariff.

Total: XDTO-pakken lar deg tydelig beskrive hierarkiet av datatyper som vil bli brukt videre når du samhandler med en WEB-tjeneste.

Tips: Det er bedre å bruke én XDTO-pakke for en webtjeneste for å unngå kompleksitet og unngå designfeil.
La oss gå videre... Etter:

• XTDO-pakken er opprettet;
• Alle datatyper er beskrevet;
• For WEB-tjenesten er bruken av denne pakken angitt;
• For parametere og resultater av operasjoner velges de riktige typene (fra XDTO-pakken)

I vårt eksempel skal GetTzTariffs_0-operasjonen returnere en rekke strenger som inneholder Tariffs-objekter.

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

Funksjon GetTzTariffs_0()
// Sett inn innholdet i behandleren.
Returner GetTZTariffs_0();
EndFunction

Funksjon GetTZTariffs_0()


// Fylle ut de tekniske spesifikasjonene
// 1. linje

kindOfTariff.active = usann;


tariff.kind = kindOfTariff;

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

//
// 2. linje
kindOfTariff = FactoryXDTO.Create(kindOfTariffType);

tariff = FactoryXDTO.Create(tariffType);
tariff.begdate = CurrentDate();
tariff.kind = kindOfTariff;
elementTZ = FactoryXDTO.Create(elementTZType);
elementTZ.eTariff = tariff;
elementTZ.cPrice = 200;
// Legg til den andre raden i tabellen
tzTariffs.el.Add(elementTZ);
Retur tzTariffer;
EndFunction

//////////
Deretter gir vi et eksempel på å kalle operasjonen "GetTzTariffs_0" fra klientsiden, fra 1C.

&På klient
Prosedyre Utfør Query20 (kommando)
// Sett inn innholdet i behandleren.
Advarsel(SERVER_ExecuteWSQuery20());
Slutt på prosedyre
&PåServerUten kontekst
Funksjon SERVER_ExecuteWSRequest20()
Definisjoner = 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();
// La oss få tilgang til linjen ved indeks null, deretter til eTariff-attributtet, deretter til nestet attributttype, deretter til nestet attributtnavn.
EndFunction

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
Et lignende anrop fra PHP og behandling av XDTO-resultatene vil være slik:
////////////////////////////////////////////////////////////////////////////////////

// webtjenestefunksjoner vil ikke fungere 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 rekke objekter. La oss gå gjennom elementene i matrisen og vise resultatene på skjermen
for ($i=0; $i {
ekko "
";
$eTariff = iconv("utf-8","cp1251",$mResult[$i]->eTariff->fullt navn);
var_dump($eTariff);
$cPrice = $mResult[$i]->cPrice;
var_dump($cPrice);
$cComment = $mResult[$i]->cComment;
var_dump($cComment);
ekko "
";
}
?>

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

Nå La oss komplisere oppgaven enda mer. La oss overføre den samme objektdatatypen fra klienten til WEB-tjenesten (som en parameter). La det være tzKind.
For å gjøre dette, beskriver vi først denne typen i dataTariffs-pakken, og legger deretter til GetTzTariffs_1-operasjonen.

La oss indikere typen tzKind-parameter.

Et eksempel på hvordan en WEB-tjeneste fungerer med en innkommende XDTO-parameter:
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

Funksjon GetTZTariffs_1(tzKind)
tzTariffsType = FactoryXDTO.Type(" ", "tzTariffer");
tzTariffs = FactoryXDTO.Create(tzTariffsType);
elementTZType = FactoryXDTO.Type(" ", "elementTZ");
tariffType = FactoryXDTO.Type(" ", "tariff");
kindOfTariffType = FactoryXDTO.Type(" ", "kindOfTariff");
// Fylle ut de tekniske spesifikasjonene
// 1. linje
kindOfTariff = FactoryXDTO.Create(kindOfTariffType);
kindOfTariff.name = "Transport";
kindOfTariff.active = usann;
tariff = FactoryXDTO.Create(tariffType);
tariff.fullName = "Tariff 1";
tariff.begdate = CurrentDate();
tariff.kind = kindOfTariff;
elementTZ = FactoryXDTO.Create(elementTZType);
elementTZ.eTariff = tariff;
elementTZ.cPrice = 100;
elementTZ.comment = "Beskrivelse av tariff 1";
// Legg til den første raden i tabellen
tzTariffs.el.Add(elementTZ);
// 2. linje
kindOfTariff = FactoryXDTO.Create(kindOfTariffType);
kindOfTariff.name = "Levering";
kindOfTariff.active = sant;
tariff = FactoryXDTO.Create(tariffType);
tariff.fullName = "Tariff 2";
tariff.begdate = CurrentDate();
tariff.kind = kindOfTariff;
elementTZ = FactoryXDTO.Create(elementTZType);
elementTZ.eTariff = tariff;
elementTZ.cPrice = 200;
elementTZ.comment = "Beskrivelse av tariff 2";
// Legg til en tredje rad i tabellen (fyll den med innkommende data)
tzTariffs.el.Add(elementTZ);
// 3. linje
kindOfTariff = FactoryXDTO.Create(kindOfTariffType);
kindOfTariff.name = tzKind.el.eKind.name;
kindOfTariff.active = tzKind.el.eKind.active;
tariff = FactoryXDTO.Create(tariffType);
tariff.fullName = "Tariff 3";
tariff.begdate = CurrentDate();
tariff.kind = kindOfTariff;
elementTZ = FactoryXDTO.Create(elementTZType);
elementTZ.eTariff = tariff;
elementTZ.cPrice = 300;
elementTZ.comment = "Beskrivelse av tariff 3";
// Legg til en tredje rad i tabellen
tzTariffs.el.Add(elementTZ);
Retur tzTariffer;
EndFunction

//////////////////////////////////////////////////////////////////////////////////
Fra 1C-klientsiden må vi klargjøre data av typen tzKind og overføre dem til WEB-tjenesten.

Her er et eksempel på en slik samtale:
/////////////////////////////////////////////////////////////////////////////////

&På klient
Prosedyre Utfør Query30 (kommando)
// Sett inn innholdet i behandleren.
Advarsel(SERVER_ExecuteWSQuery30());
Slutt på prosedyre
&PåServerUten kontekst
Funksjon SERVER_ExecuteWSRequest30()
Definisjoner = new WSDefinitions("http://localhost/wsBase10/ws/calcOrder10.1cws?wsdl ");
Proxy = new WSProxy(Definitions,"www.URI.com","_Calculations By Tariffs","_Calculations By TariffsSoap");
// Lag en tabell med parametere som sendes til WS
tzKindType = Proxy.FactoryXDTO.Type(" ", "tzKind");
tzKind = Proxy.FactoryXDTO.Create(tzKindType);
kindOfTariffType = Proxy.FactoryXDTO.Type(" ", "kindOfTariff");
kindOfTariff = Proxy.XDTO Factory.Create(kindOfTariffType);
kindOfTariff.name = "Testtarifftype";
kindOfTariff.active = usann;
elementKindType = Proxy.FactoryXDTO.Type(" ", "elementKind");
elementKind = Proxy.XDTO Factory.Create(elementKindType);
elementKind.eKind = kindOfTariff;
elementKind.qty = 10;
// Legg til en rad i tabellen
tzKind.el.Add(elementKind);
XDTOResult = Proxy.GetTzTzriffs_1(tzKind);
Eksempelresultat_navn på tarifftype = XDTOResult.el.eTariff.kind.name;
Returner EksempelResultat_Navn på tarifftype;
EndFunction

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
Jeg vil gjerne gjøre deg oppmerksom på designet: Proxy.FactoryXDTO.Type("...

Det vil si at når vi oppretter et XDTO-pakkeobjekt på klienten, må vi ikke få tilgang til vår egen XDTO!-fabrikk, men gjennom en proxy. Det vil si til XDTO-serverfabrikken.

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
Nå er det på tide å stille spørsmålet:er det noe alternativ til XDTO-objekter ?

Er det mulig å "ikke kommunisere" med XDTO-fabrikken i det hele tatt, sende/motta fra en WEB-tjeneste på annen måte.. (spesielt hvis klienten ikke er 1C, men for eksempel en WEB-side, en applikasjon på Android, iOS , etc.).

Svaret er- Ja det kan du!
Du kan for eksempel bruke streng som parametertyper. Og "pakke" (serialiser) datastrukturer inn i den.

Denne teknologien innen WEB-programmering har lenge vært utviklet og kalles JSON.
Det er også en stor hjelp at i PHP gjøres pakking/utpakking av enhver struktur/array-streng i ett trinn!
Et eksempel i PHP på å pakke objekter i JSON/pakke ut, sende/motta til en WEB-tjeneste:

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

// serialiser mDelivery-arrayen til en streng og plasser den i leveringsparameteren
// * Først, la oss beskrive leveringsstrukturen
klasse levering(
var $id;
var $sjekket;
var $verdi;
}
// Fyll strukturen med noen data
$sDelivery = ny levering;
$sDelivery->id = "000000005";
$sDelivery->checked = TRUE;
$sDelivery->verdi = 0;
// Legg det til utvalget av mDelivery-objekter
$mDelivery = $sDelivery;
// Konverter mDelivery-arrayen til en JSON-streng og plasser resultatet i leveringsparameteren
$params["delivery"] = json_encode($mDelivery);
// Ring ExitCalcOrder-operasjonen på WEB-tjenesten og send en parameter til den (streng - levering);
$result = $client->ExitCalcOrder($params);
// Få resultatet av ExitCalcOrder-operasjonen inn i jsCalcResult-variabelen (streng)
$jsCalcResult = $result->retur;
// Utfør den omvendte transformasjonen: fra jsCalcResult-strengen til et objekt (en rekke objekter, type match) arrCalcResult
$arrCalcResult = json_decode($jsCalcResult);
// Vis informasjon på skjermen om arrCalcResult-objektet
var_dump($arrCalcResult);

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

Men hvordan utfører jeg JSON-konverteringer i 1C?
1C 8-plattformen støtter ikke JSON-standarden, men dette er ikke et problem.
JSON konvertering/ekstraksjonsbehandling finnes, er tilgjengelig og fungerer utmerket fra
// Copyright © 2010-2012 Alexander Pereverzev
// 1C:JSON . JavaScript Object Notation parser og serializer.

Dermed er det bare å legge inn denne behandlingen i konfigurasjonen din, og du kan enkelt utføre forover og bakover JSON-konverteringer:
Serialisering eksempel 1C-objekt til JSON-streng:

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

CargoData = ny struktur;
CargoData.Insert("kode", CargoCode);
CargoData.Insert("nummer", CargoNumber);
CargoData.Insert("plan", QuantityPlan);
CargoData.Insert("character",CargoCharacter);
CargoData.Insert("pakking", Emballasje);
CargoData.Insert("skade",Skade på emballasje);
CargoData.Insert("volum",Volum);
CargoData.Insert("weight",Weight);
CargoData.Insert("status",Status);
jsResult = JSON.WriteJSON(LoadData); //Konverter resultatet til JSON
return jsResult;

Trekk ut eksempel objekt i 1C fra JSON-streng:
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

// 1. Gjenopprett objekter fra JSON
JSON = Process.JSON.Create();
mdelivery = JSON.ReadJSON(levering);
// som et resultat er mdelivery en matrise. Array-element - match.
// Det er for eksempel mdelivery.["id"] vil inneholde "000000005"

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
Avslutningsvis vil jeg gi et eksempel på å kalle 1C-webtjenesten fra PHP, og motta den returnerte JSON-strukturen av dens omvendte transformasjon til PHP-objekter.

La oss ta hensyn til transformasjonene iconv("cp1251","utf-8","
og iconv("utf-8","cp1251", som vil være nødvendig (når du samhandler med PHP - 1 C) for å konvertere kyrilliske strenger fra cp 1251-koding til utf -8 og tilbake.

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

error_reporting(E_ERROR); // Deaktiver meldinger
// Deaktiver caching for SOAP. Hvis dette ikke gjøres,
// webtjenestefunksjoner vil ikke fungere 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["kode"]);
$params["param2"] = iconv("cp1251","utf-8",$_GET["nummer"]);
$result = $client->executeQuery($params);
$jsResult = $result->retur;
$dataFreight = json_decode($jsResult);
$statusFreight = $dataFreight->kodeNm;
$numberFreight = iconv("utf-8","cp1251",$dataFreight->nameRus);
?>

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

Det sannsynlige scenariet er: en ekstern bruker fra noen av programmene hans (for eksempel fra en WEB-side, en mobilapplikasjon osv.) ringer WEB-tjenesten din og... mottar ikke resultater. Eller han mottar det, men noe er galt.

Spørsmål: - Hvordan finne ut om slike feil og feilsøke WEB-tjenesten?
Jeg anbefaler at du bruker en logg for å overvåke feil (og samle inn innkommende parametere "hva som førte nettjenesten til en feil").

De. på stedet der logiske feil kan oppstå, lagre informasjon om innkommende parametere programmatisk i registreringsloggen (LogRecord)

Hvis du "sliter" med "kjøretidsfeil", kan du avskjære dem (et forsøk er et unntak) og "punkt-for-punkt" logge hele situasjonen.

Som et resultat, ved å bruke loggen, vil du kunne se informasjon om feil, reprodusere parametrene for forekomsten og "bekjempe" den i interaktiv modus, i feilsøkeren.

La oss oppsummere: Eksempler på arbeid med WEB-tjenester fra 1C og PHP vurderes. For å overføre objektdatastrukturer mellom klienten og serveren brukte vi to teknologier:

• (1) XDTO-pakker
• (2) JSON-objekter.

4. Alternativ - REST webtjenester (http-forespørsler). Eksempler på implementering i 1C og PHP.
I forrige avsnitt undersøkte vi i detalj teknologien til WEB-tjenester. I denne delen vil vi vurdere en alternativ teknologi, den såkalte. REST webtjenester.

Et rettferdig spørsmål dukker opp: - Hvorfor?

WEB-tjenester er fullt funksjonelle og lar deg løse problemer av enhver kompleksitet.

For å forstå "hvorfor", la oss formulere de grunnleggende forskjellene mellom disse teknologiene.

Teknologien til WEB-tjenester er basert på 2 punkter:

• (1) SOAP-tilkobling brukes. Det blir med andre ord gjort en SOAP-forespørsel.

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

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

I PHP er det slik:

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

$client = new SoapClient("http://localhost/wsBase10/ws/calcOrder10.1cws?wsdl",
array(
"login" => pålogging, //login,
"passord" => pass, //passord
"spor" => sant,
"funksjoner" => SOAP_USE_XSI_ARRAY_TYPE,
//"komprimering" => SOAP_COMPRESSION_ACCEPT | SOAP_COMPRESSION_GZIP | 5
);

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

• (2) For å behandle en såpeforbindelse i servermodus, tilbyr 1C 8-plattformen et spesielt metadataobjekt WEB-tjenester.

Dessuten, hvis "1C" i oppgaven din må fungere som en server, er det ikke noe alternativ til 1C WEB-tjenesteteknologi.

– Når er et alternativ mulig?

• For det første, når 1C kun opptrer som klient;
• For det andre, når serveren du trenger å jobbe med (for eksempel et nettsted eller en slags WEB-applikasjon), er det ikke planlagt å støtte en SOAP-tilkobling.

Et veldig populært alternativ - http-tilkobling.

I nettbaserte systemer (PHP, Android, iOS) er det lettere å jobbe med http-forespørsler enn med SOAP-forespørsler. Og for ikke veldig komplekse prosjekter er http-forespørselsteknologien ganske egnet.

Den klassiske løsningen (ved hjelp av http request-metoden) er oppgaven med å integrere 1C-databasen og WEB-siden. For eksempel overføres informasjon om produktutvalg og priser til nettstedet, og informasjon om aksepterte bestillinger sendes tilbake fra nettstedet.

Det er typisk at i typiske 1C-konfigurasjoner implementeres integrasjon med nettsteder ved hjelp av http-forespørsler.
Så la oss se på teknologien http-forespørsler For eksempel interaksjon mellom 1C (klient, 1C 8) og WEB-side (PHP, server).

1. Etablere en forbindelse og metoder for å sende parametere i en http-forespørsel
Et eksempel på å etablere en tilkobling til serveren fra 1C-siden:
/////////////////////////////////////////////////////////////////////////////

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

////////////////////////////////////////////////////////////////////////////
Som du vet, er det to metoder for å overføre parametere fra klienten til serveren via http-protokollen:

(1) Metode "få";

Parametre (som navn og passord) spesifiseres direkte i URL-adressen til serverkallet.

Det vil si at et interaktivt kall til skriptet (direkte fra en nettleser) vil se slik ut:

I 1C:8, for programmatisk oppkalling av serveren (og overføring av parametere for Get-metoder til den), er "Get"-metoden gitt.

Eksempel:
beskyttet = falsk;
HTTPConnect = new HTTPConnect("localhost", Secure);
HTTPConnect.Get("wsClient10/json/testHTTPQuery11.php?nameVasya&password=123",OutputFileName);

where OutputFileName: Navnet på filen som dataene returnert fra serveren er plassert i.
Det vil si at som et resultat av å behandle forespørselen, returnerer serveren resultatet til 1C og deretter (automatisk) genereres en fil som inneholder resultatet.

Følgelig, etter dette, i "1C" er det nødvendig (programmatisk) å lese denne filen og trekke ut resultatet oppnådd fra den. Det er alt.

(2) "post"-metoden;

I dette alternativet plasseres ikke parameterne i URL-en, men overføres separat, i hoveddelen av http-tilkoblingen.

Det er klart at nøkkelbegrensningen av metoden få er volumet og innholdet i de overførte dataene. Altså med hjelp få Bare tegn kan sendes, og lengden på URL-strengen er begrenset.

Metode post Du kan overføre data av forskjellig innhold, inkl. og vilkårlige filer.
Dermed, post for integreringsoppgaver er den mer funksjonell og vi vil fortsette å jobbe med den.

For å motta/overføre data mellom 1C og WEB-side, vil vi bruke tekstfiler.
Og vi vil "pakke/pakke ut" data fra filer ved hjelp av JSON-teknologien som allerede er kjent for oss! Dette vil praktisk talt redde oss fra behovet for å "parse" filen på 1C-siden og på PHP-siden.

For å ringe serveren og overføre parametere til den ved å bruke "post"-metoden, gir 1C:8 metoden: SendForProcessing

Og så, la oss gi et eksempel der på siden 1C alle behandlingstrinn utføres http-forespørsel:

La oss først skrive ned handlingsplanen (forstørret):

Og nå, programvareimplementeringen i 1C:8

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

// 1. Fyll inn strukturen til de overførte dataene
postDataToPHP = ny struktur;
postDataToPHP.Insert("param1","ivanon");
postDataToPHP.Insert("param2","ivan");
postDataToPHP.Insert("param3","ivanovich");

// 2. Konverter dataene til en JSON-streng
JSON = Process.JSON.Create();
jsPostDataToPHP = JSON.WriteJSON(postDataToPHP);

// 3. Opprett en midlertidig utgående melding (overført til serveren ved hjelp av POST-metoden)
// fil, legg inn en JSON-streng i den.
tFile = nytt tekstdokument;
stringData = jsPostDataToPHP;
tFile.AddLine(stringData);

// 4. Få navnet på den midlertidige utgående filen. Den vil inneholde utgående data i form av en JSON-streng
OutgoingFileName = GetTemporaryFileName(.txt");
tFile.Write(OutgoingFileName,TextEncoding.UTF);

// 5. Få navnet på den midlertidige inndatafilen. Den vil motta en JSON-streng: PHP-serversvar
InputFileName = GetTemporaryFileName(.txt");

// 6. Etabler en HTTP-forbindelse med serveren
beskyttet = falsk;
HTTPConnect = new HTTPConnect("localhost/wsClient10/json/testHTTPQuery10.php", beskyttet);

// 7. La oss utføre en HTTP-forespørsel. La oss overføre den utgående filen til serveren (filen inneholder et JSON-objekt, dvs. utgående parametere)

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

// Og vi vil motta et svar fra serveren (innkommende fil). Filen inneholder et //JSON-objekt (dvs. data returnert fra serveren)

// 8. Trekk ut dataene mottatt fra serveren fra den innkommende filen
ResponseFile = nytt tekstdokument;
ResponseFile.Read(InputFileName,TextEncoding.UTF);
json_Data = ResponseFile.GetString(1);
mData = JSON.ReadJSON(json_Data);

// 9. Vis mottatte data for brukeren
Rapport(mData["v1"]);
Rapport(mData["v2"]);

// 10. Slett brukte (ikke lenger nødvendig) midlertidige filer.
DeleteFiles(OutgoingFileName);
DeleteFiles(InputFileName);

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

Og endelig, eksempel i PHP for å behandle en forespørsel på serversiden:

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

// 1. Hent strengdata fra den innkommende filen
$json_filedata = file_get_contents("php://input");
// 2. Kutt av alt unødvendig (2 tjenestetegn legges til), som // forstyrrer konverteringen fra JSON
$jsData = trim(ltrim($json_filedata));
$dlinaStr = strlen($jsData);
$_jsData = "";
$i=1;
mens ($i<$dlinaStr) {
if ($i>2) (
$_jsData = $_jsData.substr($jsData, $i, 1);
}
$i++;
}
// 3. Konverter data fra JSON til et objekt (struktur)
$mData = json_decode($_jsData);
// 4. La oss lage en annen struktur, som vi fyller med data og // går tilbake til 1C
klasse returnData(
var $v1;
var $v2;
}
$sReturnData = ny returData;
$sReturnData->v1 = $mData->param1;
$sReturnData->v2 = $mData->param2;
// 5. Konverter strukturdataene til en JSON-streng
$json_returnData = json_encode($sReturnData);
// 6. Returner dataene til 1C (utdataene vil bli omdirigert til en fil, som vil bli returnert til 1C)
echo $json_returnData;
?>

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

Det er alt. Kompakt og funksjonell!

5. Etterspurte oppgaver (prosjektsaker)

Avslutningsvis vil jeg sitere de som de facto nå er mest etterspurt av kunder, og som løses ved hjelp av WEB-tjenester og http-forespørsler.

Emnetittelen er egentlig et spørsmål, fordi... Selv vet jeg ikke hva det er, og for første gang vil jeg prøve å jobbe med det innenfor rammen av denne artikkelen. Det eneste jeg kan garantere er at koden presentert nedenfor vil fungere, men mine setninger vil kun være antagelser og gjetninger om hvordan jeg selv forstår alt dette. Så la oss gå...

Introduksjon

1. SÅPE. Før du kaller en ekstern prosedyre, må du beskrive denne samtalen i en XML-fil i SOAP-format. SOAP er rett og slett en av de mange XML-markeringene som brukes i webtjenester. Alt vi ønsker å sende et sted via HTTP blir først konvertert til en XML SOAP-beskrivelse, deretter stappet inn i en HTTP-pakke og sendt til en annen datamaskin på nettverket via TCP/IP.
2. WSDL. Det finnes en webtjeneste, dvs. et program hvis metoder kan kalles eksternt. Men standarden krever at dette programmet ledsages av en beskrivelse som sier at "ja, du har rett - dette er virkelig en nettjeneste, og du kan kalle slike og slike metoder fra den." Denne beskrivelsen er representert av en annen XML-fil, som har et annet format, nemlig WSDL. De. WSDL er bare en XML-fil som beskriver en webtjeneste og ingenting mer.

Generell tilnærming

1. Beskriv grensesnittet til vår webtjeneste
2. Implementer dette grensesnittet
3. Start vår nettjeneste
4. Skriv en klient og eksternt ring ønsket nettjenestemetode

Server

Klient

Konklusjon

Emnetittelen er egentlig et spørsmål, fordi... Selv vet jeg ikke hva det er, og for første gang vil jeg prøve å jobbe med det innenfor rammen av denne artikkelen. Det eneste jeg kan garantere er at koden presentert nedenfor vil fungere, men mine setninger vil kun være antagelser og gjetninger om hvordan jeg selv forstår alt dette. Så la oss gå...

Introduksjon

1. SÅPE. Før du kaller en ekstern prosedyre, må du beskrive denne samtalen i en XML-fil i SOAP-format. SOAP er rett og slett en av de mange XML-markeringene som brukes i webtjenester. Alt vi ønsker å sende et sted via HTTP blir først konvertert til en XML SOAP-beskrivelse, deretter stappet inn i en HTTP-pakke og sendt til en annen datamaskin på nettverket via TCP/IP.
2. WSDL. Det finnes en webtjeneste, dvs. et program hvis metoder kan kalles eksternt. Men standarden krever at dette programmet ledsages av en beskrivelse som sier at "ja, du har rett - dette er virkelig en nettjeneste, og du kan kalle slike og slike metoder fra den." Denne beskrivelsen er representert av en annen XML-fil, som har et annet format, nemlig WSDL. De. WSDL er bare en XML-fil som beskriver en webtjeneste og ingenting mer.

Generell tilnærming

1. Beskriv grensesnittet til vår webtjeneste
2. Implementer dette grensesnittet
3. Start vår nettjeneste
4. Skriv en klient og eksternt ring ønsket nettjenestemetode

Server

Klient

Konklusjon

I dag brukes WEB-tjenester nesten overalt - de gir oss informasjon om fly- og togflyvninger, valutakurser og vær. Det er ikke overraskende at 1C også har muligheten til å lage sine egne WEB-tjenester, slik at den kan fungere som både leverandør og forbruker. Denne mekanismen er innebygd i 1C:Enterprise 8.3-plattformen og utviklere kan til og med legge til sine egne objekter av typen WEB-tjenester til standardkonfigurasjonen. Arkitekturen deres er bygget på et sett med tjenester som lar deg utveksle informasjon med annen programvare.

Opprette en 1C webtjeneste

En av hovedfordelene med 1C WEB-tjenester er fraværet av behovet for å gi direkte tilgang til informasjonssikkerhetsdata. En riktig konfigurert 1C-webtjeneste lar andre applikasjoner bruke funksjoner fra utsiden. I slike tilfeller bør funksjonen selv bestemme retten til å bruke data i henhold til de spesifiserte parametrene i henhold til reglene foreskrevet av utvikleren.

Hvordan lage en webtjeneste i 1C?

For at en viss funksjon av 1C-systemet skal bli tilgjengelig for ekstern programvare, er det nødvendig å utføre følgende handlingsalgoritme:

1. Gå til konfigurasjonen og legg til et WEB-tjenesteobjekt i en bestemt gren av treet;
2. Beskriv alle operasjonene som funksjonaliteten vår kan utføre. Beskrivelsen av funksjoner utføres i modulen i det innebygde 1C-språket;
3. Legg til en beskrivelse av parametrene til webtjenestefunksjonene. Vær oppmerksom på at datatypene er beskrevet under hensyntagen til de eksisterende typene av XDTO-mekanismen introdusert i plattformversjon 8.1;
4. Publiser den opprettede WEB-tjenesten på serveren. Mekanismen innebygd i 1C-plattformen støtter følgende standarder:

• SSL/TLS
• WS-I BP

Et eksempel på å lage en enkel WEB-tjeneste

For å tydeligst demonstrere driften av WEB-tjenestemekanismen, la oss lage et eksempel - en funksjonalitet som bestemmer lengden på den angitte strengen. Programvaren vil sende en streng som en forespørselsparameter, og funksjonen beskrevet i 1C vil returnere antall tegn. Når du oppretter, må du huske at publisering av denne mekanismen vil gjøre det mulig for ulike programvarer å få tilgang til den. Siden ikke hver programvare er i stand til å akseptere det kyrilliske alfabetet, vil vi navngi konfigurasjonsobjekter med latinske tegn.

Åpne konfiguratoren, finn "WEB services"-grenen i treet og legg til en ny tjeneste "wa_LengthString". Du må også legge til en ny operasjon på fanen "Operasjoner". La oss kalle det "CalcLengthString", spesifiser returverditypen i egenskapene - int eller heltall og lag "InputString" -parameteren i den. Vi lar verditypen være streng.

Nå må du registrere handlingen til CalcLengthString-funksjonen i WEB-tjenestemodulen. For å gjøre dette, åpne egenskapene til den opprettede funksjonen og klikk på knappen i form av et forstørrelsesglass til høyre, ved siden av inntastingsfeltet "Prosedyrenavn". 1C vil automatisk opprette en funksjon i vår WEB-tjenestemodul og åpne den slik at vi kan beskrive CalcLengthString-handlingen. La oss dra nytte av dette og skrive handlingen til funksjonen - bestemme lengden på inndatastrengen.

Faktisk fullfører dette etableringen av en enkel WEB-tjeneste. Nå er det nødvendig å "sette" denne tjenesten i det offentlige domene slik at tredjepartsprogramvare eller andre 1C-systemer kan bruke denne funksjonaliteten.

For at vi skal kunne publisere den opprettede webtjenesten med dens funksjonalitet, må vi ha tilgang til siden. Før vi begynner å publisere tjenesten, må vi sjekke filnavnet i egenskapene til den opprettede wa_LengthString-modulen. Den skal være oversiktlig, enkel og ha utvidelsen "1cws".

Nå er det på tide å publisere WEB-tjenesten vi opprettet på serveren. Denne funksjonen dukket opp i plattformversjon 8.3 og mange selskaper har allerede innsett de fulle fordelene med denne funksjonaliteten. For å begynne å publisere, må du åpne skjemaet "Administrasjon/Publisering på en webserver..." i konfiguratoren.

I vinduet som åpnes, må vi konfigurere 1C Web-tjenester og fylle ut visse felt:

• Navn. Angir mappen på webserveren der beskrivelsen av vår webtjeneste skal lagres. Vær forsiktig med saker, siden servere noen ganger skiller mellom store og små kasustegn;
• Internett server. Du må velge en server fra de som er installert på datamaskinen din;
• Katalog. Du må velge banen til mappen der webserverdataene for å sette opp tilkoblingen er lagret. Kun latinske bokstaver brukes;
• To tegn av boolsk type. Den første vil være nyttig for oss hvis vi trenger å konfigurere tilgang til konfigurasjonen via en nettklient. For å publisere en 1C-tjeneste, må du merke av i den andre boksen.

Alt som gjenstår er å sjekke at ønsket WEB-tjeneste har merket av i den første kolonnen og klikk på "Publiser".

Siden denne mekanismen fortsatt er ganske ny, kan du støte på en feil som "Det oppstod en feil under utførelse av en filoperasjon...". I dette tilfellet trenger du bare å klikke på "Publiser" igjen. I de fleste tilfeller vil dette hjelpe, og du vil se en melding som indikerer at nettjenesten er publisert.

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

Som svar på en slik adresseforespørsel må nettleseren vise strukturen til XML-filen. Hvis du ser en tom side, en feil eller merkelige tegn (kodingsproblemer), må du sjekke alle trinnene på nytt. Det er også en god idé å sørge for at serveren er riktig konfigurert og at du har tilgang til den. Etter vellykket publisering vil 1C WEB-tjenesten kunne brukes av tredjepartsapplikasjoner.

Ansvarsfraskrivelse og vilkår for bruk

Nok en ansvarsfraskrivelse (etter mange ganger)

Introduksjon

For de som er helt «ute av løkken»: om nettjenester «til fingerspissene»

Hvor er beina fra, dvs. vinger vokser

Han sa: "La oss gå!"

Dette treet representerer et "portrett" av nettjenesten, slik 1Ska ser det. Det mest interessante er i grenen "Webtjenester": dette navn Og havner webtjenester (faktisk kan en WSDL-fil beskrive ikke én, men flere webtjenester, da vil hver webtjeneste ha sin egen gren), og er oppført metoder nettjeneste. Dette er selve "strengene", ved å trekke som du kan gi deg selv tilgang til dataene som nettjenesten gir. Grenen "Datamodell" inneholder en beskrivelse av datatypebibliotekene som brukes av nettjenesten.
En kort oppsummering av hvordan du bruker nettjenesten finner du vanligvis på samme sted som lenken til WSDL-filen. Når det gjelder Aeroflot, er dette siden http://webservices.aeroflot.aero/flightstatus.asmx

"Nå start, nå landing..."