1c anslut till befintlig com-anslutning. Tre valar att arbeta med COM-objekt

Ett av alternativen för att utbyta data mellan 1C-databaser är ett utbyte via en COM-anslutning.

Med en COM-anslutning kan du ansluta från en 1C-databas till en annan och läsa eller skriva data. Du kan använda den här metoden både i klient-servervarianter av databaser och i fildatabaser. I den här artikeln kommer vi att analysera exempel på sådana föreningar. Exemplen använder plattform 8.2.

Du kan skapa två typer av COM-objekt för 1C-applikationen. Detta V82.Ansökan Och V82.COMConnector. I fall att V82.Ansökan en nästan fullfjädrad kopia av 1C-applikationen lanseras. vid användning V82.COMConnector en liten serverdel startas.
Arbetshastigheten i det här fallet är högre, men vissa funktioner kanske inte är tillgängliga. I synnerhet att arbeta med formulär och med vanliga moduler för vilka egenskapen att arbeta med externa anslutningar inte är inställd. Du bör främst använda V82.COMConnector och endast vid bristande funktionalitet V82.Ansökan. Skillnaden i hastighet kan vara särskilt märkbar på stora databaser.

Så låt oss börja

1. Låt oss skapa ett COM-objekt
   • För V82.Ansökan Connection = New COMObject("V82.Application" ) ;
   • För V82.COMConnector Connection = New COMObject("V82.COMConnector" ) ;
2. Låt oss skapa en anslutningssträng
   • för serverversionen av databasen ConnectionString = "Srvr = " "Servernamn" ";Ref = " "Basnamn" ;
   • för filversionen av databasen ConnectionString = "File = " "PathKBase" "; Usr = Användarnamn; Pwd = Lösenord";
3. Gör en anslutning till databasen Anslutningsförsök = Anslutning. Connect(ConnectionString) ; Exception Message = New MessageToUser; Meddelande. Text = + DescriptionErrors() ; Meddelande. Att rapportera() ; EndTry ;
4. Koppla från basen Anslutning = Odefinierad;

   För objekt V82.Ansökan det är obligatoriskt att koppla från anslutningen, annars förblir en ofullständig session hängande, som sedan måste raderas manuellt. I fall att V82.COMConnector anslutningen avslutas automatiskt i slutet av proceduren som anslutningen gjordes i. Och det finns ett litet ögonblick till.

   För den användare under vilken anslutningen görs måste kryssrutan "Be om bekräftelse när programmet stänger" i dess inställningar vara avaktiverad.

Och låt oss nu lägga ihop all kod

Connection = New COMObject("V82.Application" ) ; //Anslutning = New COMObject("V82.COMConnector"); ConnectionString = "Srvr = ""Server1C"";Ref = ""MyBase""; Usr = Peter; Pwd = 123" ; //ConnectionString = "File = ""С:\MyBase""; Usr = Peter; Pwd = 123"; Anslutningsförsök = Anslutning. Connect(ConnectionString) ; Exception Message = New MessageToUser; Meddelande. Text = "Kunde inte ansluta till databasen"+ DescriptionError() ; Meddelande. Att rapportera() ; EndTry ; Anslutning = Odefinierad;

För anslutningstyp V82.Ansökan metod tillämpas på COM-objektet som ursprungligen skapades, och för V82.COMConnector metoden tillämpas på anslutningen. vidare arbete med begäran går standardmedel 1C. i koden ser det ut så här:

Begäran = Anslutning. NewObject("Begäran" ; // För V82.COMConnector Begäran = Anslutning. NewObject("Begäran" ; // För V82.Ansökan Begäran. Text = "VÄLJ | Organisationers positioner. Kod, | Organisationers positioner Namn| FRÅN | Katalog. Positions of Organisations AS Positions of Organisations "; Resultat = Begäran. Kör () ; Prov = Resultat. Välj() ; Medan urvalet. Next() Cycle EndCycle ;

För version 1C:Enterprise 8.3 förblir allt oförändrat, förutom att när du skapar COMO-objekt måste du använda "V83.COMConnector" eller V83.Ansökan.

Nyckelord: COM, anslutning, extern, OLE, Automation, Connect, ComConnector, Srvr

När du använder 1C:Enterprise 8.0 COM-anslutningar för att komma åt data, finns det följande fördelar jämfört med att använda Automation-servern:

1. Mer snabb installation anslutningar, eftersom ingen skapelse krävs separat process operativ system, och alla åtgärder utförs inom anropsprocessen;


2. Snabbare åtkomst till egenskaperna och metoderna för 1C:Enterprise-objekt, eftersom organisationen av överklagandet inte kräver organisation av kommunikation mellan processer;
3. Mindre förbrukning av operativsystemresurser.

I allmänhet liknar det att arbeta med 1C:Enterprise 8.0 via en COM-anslutning som att arbeta med 1C:Enterprise i serverläget Automation. De viktigaste skillnaderna är följande:

1. I fallet med en Automation-server startas en fullfjädrad 1C:Enterprise 8.0-applikation, och i fallet med en COM-anslutning startas en relativt liten COM-server under process.


2. När du arbetar via COM-anslutning är inte tillgängliga funktionalitet på ett eller annat sätt relaterat till organisationen av användargränssnittet 1C: Enterprise 8.0;
3. På arbete COM-anslutningar 1C:Enterprise 8.0 konfigurationsprogrammodulen används inte. Dess roll när du arbetar med en COM-anslutning spelas av den externa anslutningsmodulen.

1.1 Hur man upprättar en COM-anslutning

För att organisera åtkomst till 1C:Enterprise 8.0-data via en COM-anslutning, utförs följande sekvens av åtgärder:

1. ett COM-objekt skapas med identifieraren V8.COMConnector , med hjälp av vilken anslutningen upprättas;


2. Connect-metoden för det tidigare skapade V8.COMConnector-objektet anropas. Connect-metoden returnerar en länk till COM-anslutningsobjektet med infobasen 1C:Enterprise 8.0;
3. genom det mottagna COM-anslutningsobjektet görs åtkomst till de tillåtna metoderna, egenskaperna och objekten för den infobas med vilken anslutningen upprättas.

Viktig! På grund av bristen på ett användargränssnitt i en COM-anslutning kan inte alla objekt, såväl som egenskaper och metoder, användas i en COM-anslutning.

1C:Enterprise-objekt tillgängliga utifrån via COM-anslutning:

1. Exporterade variabler och Outer Link Module Procedurer/funktioner


2. Exporterade variabler och procedurer/funktioner gemensamma moduler
3. Inkludera och exkludera hela moduler genom att ställa in egenskaper för delad modul


4. Inkludera och exkludera fragment av vanliga moduler som använder förprocessorn
5. Global kontext 1C:Enterprise 8.0, med undantag för objekt som är strikt associerade med klientapplikationen (TextDocument, SpreadsheetDocument, ...)

1.2 Extern anslutningsmodul

Som redan nämnts utförs applikationsmodulens uppgifter vid arbete genom en COM-anslutning av den yttre anslutningsmodulen. Den här modulen kan ha händelsehanterarprocedurer AtStartSystemWork() och AtShutdownSystem(), som kan innehålla åtgärder som ska utföras under initiering respektive avslutning av anslutningen.

Procedurer, funktioner och globala variabler definierade i en yttre kopplingsmodul med nyckelord Export blir, som i fallet med en applikationsmodul, en del av det globala sammanhanget.

1.3 Allmänna moduler

Egenskaperna "Client", "Server" och "ExternalConnection" har införts för vanliga moduler. De är avsedda att i konfigurationen definiera användningen av moduler i klient-serverversionen och i COM-anslutningsläget.

1.4 "V8.COMConnector"-objekt

Den enda uppgiften som löses av V8.COMConnector COM-objektet är att upprätta en COM-anslutning med infobasen 1C:Enterprise 8.0. Med en enda instans av V8.COMConnector-objektet kan ett obegränsat antal anslutningar upprättas. V8.COMConnector-objektet har en enda Connect-metod som används för att upprätta en COM-anslutning med 1C:Enterprise 8.0-infobasen.

<СтрокаСоединенияИБ>

IB-anslutningssträngen är en kedja av fragment av formen Parameter=Value. Fragment separeras från varandra med ";". Om värdet innehåller blanksteg, då måste det stå inom dubbla citattecken (").

Vanliga parametrar:

usr - användarnamn;
pwd - lösenord.

Följande parameter är definierad för filvarianten:

Fil - infobaskatalog.

För klient-serverversionen definieras följande parametrar:

Srvr - 1C: Enterprise servernamn;
Ref - namnet på infobasen på servern.

Connect-metoden upprättar en COM-anslutning med infobasen 1C:Enterprise 8.0 och returnerar en referens till COM-anslutningsobjektet.

// Ett kopplingsobjekt skapas
V8 = New COMObject("V8.COMConnector");
// skapa ett COM-anslutningsobjekt
Connection = V8.Connect("File=""c:\InfoBases\Trade""; Usr =""Director"";")

1.5 "COM-anslutning"-objekt

COM-anslutning till 1C:Enterprise infobase tillhandahåller full tillgång till dess globala sammanhang (se "Exekutionskontext mjukvarumodul"). Därför kan en COM-anslutning ha som sina metoder: systemkonstanter, värden på objekt specificerade i konfiguratorn, nås med hjälp av chefer (till exempel konstanter, uppräkningar, kataloger, dokument, dokumentloggar, rapporter, bearbetning, planer för typer av egenskaper, plankonton, beräkningstypsplaner, register), samt variabler som deklareras i den yttre anslutningsmodulen med nyckelordet Export.

Dessutom har COM-anslutningen ytterligare en NewObject-metod som kan användas för att skapa värden av specifika typer.

ts = Anslutning. NewObject("ValueTable");

Strängmetod Låter dig få strängrepresentationer av 1C:Enterprise-värden.

View = Connection.String(Data.UniqueIdentifier());

1.6. Funktioner för att arbeta med COM-anslutning

I Automation och på en COM-anslutning har TRUE och FALSE värdena -1 (minus ett) respektive 0.

Det är möjligt att organisera en pool av COM-anslutningar. Samtidigt skapas flera COM-anslutningsobjekt på värdservern 1C:Enterprise i ADVANCE, och det tar ännu kortare tid att upprätta en anslutning, eftersom det inte finns något behov av att skapa nytt objekt.

Ett nytt Query Builder-objekt har implementerats, designat för att generera frågetexter baserat på de angivna inställningarna. Detta objekt stöder rapportbyggarfunktioner förutom att mata ut en rapport till kalkylarksdokument och andra uppgifter relaterade till användargränssnitt. Detta objekt kan användas på 1C:Enterprise-servern och i en COM-anslutning.

Användningen av COM-objekt är tillgänglig när det inbyggda språket körs på 1C:Enterprise-servern.

COM-fel översätts till 1C:Enterprise-undantag.

Om konfigurationen försöker skapa ett ogiltigt objekt, till exempel ett kalkylarksdokument, i en yttre anslutningsmodul, i en gemensam modul eller i en objektmodul, får COM-anslutningen inte upprättas eller avslutas med ett undantag.

Hej Khabravchans!

I den här artikeln vill jag prata om hur integration med 1C-plattformen etableras i min organisation. Det som fick mig att göra detta var den nästan fullständiga frånvaron av teknisk information om detta tema. När du läser olika artiklar och rapporter om ämnet att länka 1C med vilket informationssystem som helst, blir du övertygad om och om igen att de alla är marknadsföring, demonstrations till sin natur och aldrig tekniska, vilket återspeglar problemet och kärnan i dess lösning.

Jag varnar dig för att metoden inte på något sätt gör anspråk på att vara universell. Eftersom det finns många 1C-konfigurationer själva, och informationssystem, språk och plattformar - ännu mer, antalet möjliga kombinationer är enormt. Mitt mål är att visa en möjlig lösning.

Som ett språk som kommer att integreras med 1C valde jag Python. Den är mycket väl lämpad för processautomatisering. Detta underlättas av den minimalistiska syntaxen (koden skrivs mycket snabbt), det rika standardbiblioteket (mindre behov av tredjepartsmoduler), plattformsoberoende - med hög sannolikhet kommer koden som skrivits i Linix OS att fungera framgångsrikt i Windows.

Till att börja med kommer jag att redogöra för de uppgifter som vi kommer att arbeta med. Organisationen - ett strömförsörjningsföretag i Fjärran Östern-regionen - betjänar cirka 400 tusen abonnenter, basen är 1C på en självskriven konfiguration. För varje abonnent lagras hans betalningar, periodiseringar, förbrukade tjänster och beräkningsscheman, mätanordningar, avläsningar och många andra data.

Väl i organisationen fanns det ett program skrivet i Delphi och med MSSQL / Firebird som databas. Under dessa härliga tider var det möjligt att ansluta till databasen med vilket språk som helst och utföra många åtgärder - välj gäldenärsabonnenter, efterbetalda mottagna, registrera instrumentavläsningar. Inte överraskande har samlingen av skript som automatiserar rutinen ständigt växt. Programmerare kan utföra vilken åtgärd som helst utan att öppna själva programmet.

Tyvärr, med övergången till 1C, avslutades freebie - det var inte längre möjligt att ansluta till databasen direkt. I allmänhet är själva 1C-plattformen odelbar och är dåligt integrerad med andra system. Det är, som man säger, en sak för sig. När du laddar data till 1C, bör man komma ihåg att det inte kommer att vara så lätt att extrahera dem därifrån. Men med tanke på att organisationen var skyldig att implementera betalningssystem och Personligt område, en lösning måste hittas.

De viktigaste uppgifterna som jag stod inför var förmågan att snabbt få data om en specifik personligt konto- Fullständigt namn, adress, mätanordningar, instrumentavläsningar, betalningar, avgifter. Plus, bildandet av dokument - en handling av försoning, betalningskvitto. Så det finns ingen möjlighet till en direkt anslutning till databasen - alla som tittade igenom 1C-databasen på SQL-servern såg att det var svårt att lista ut det i massan av tabeller som aaa1, aaa2. Och att bygga frågor med sådana namn på tabeller och fält är helt enkelt orealistiskt. Dessutom är många 1C-tabeller (särskilt de viktigaste, såsom snittet av de sista, balanser och varv) virtuella och är utspridda över olika fysiska tabeller och samlas i flera kopplingar. Denna metod är inte lämplig.

1C-plattformen ger möjlighet att ansluta till den via en COM-anslutning. Som många Windows-program, under installationen av 1C, registreras två COM-objekt i systemet - Automation Server och COM Connector. Du kan arbeta med båda objekten med hjälp av ett språk som stöder COM-teknik.

Automation Server-objektet är en 1C-applikation som nästan inte skiljer sig från en vanlig klientapplikation. Skillnaden är att det dessutom finns möjlighet till programmatisk styrning av applikationsinstansen. När man arbetar med COM Connector-objektet lanseras en lättviktsversion av 1C-applikationen, där formulär inte är tillgängliga, samt funktioner och metoder relaterade till gränssnittet och visuella effekter. Själva applikationen startar i läget "Extern anslutning". Initialisering av globala variabler (till exempel definiera nuvarande användaren och dess inställningar) måste utföras i den externa 1C-anslutningsmodulen. Om i yttre anslutningsläge en funktion anropas i koden som inte är tillgänglig i detta läge, kommer ett undantag att kastas (som kommer att skickas till vårt python-skript). Anrop till osäkra funktioner bör ramas in med formkonstruktioner

#If NOT OuterConnection Then Warning("Hej!"); #EndIf

Eftersom att arbeta med COM-objekt endast är en Windows-teknik är det inte förvånande att det inte ingår i den vanliga Python-distributionen. Du måste installera ett tillägg - en uppsättning moduler som tillhandahåller all nödvändig funktionalitet för programmering under Windows i Python. Det kan laddas ner som ett redan monterat exe-installationsprogram. Själva tillägget ger åtkomst till registret, tjänster, ODBC, COM-objekt och så vidare. Alternativt kan du omedelbart installera ActiveState Python-distributionen, där Win32-tillägget kommer ur lådan.

Under en tid experimenterade jag med COM-anslutning i utvecklingen av webbapplikationer, i synnerhet ett personligt konto. Följande nackdelar har identifierats:

COM-anslutningen är långsam. Låg prestanda är ett välkänt minus med COM-teknik.
- Processen att upprätta en anslutning med 1C, beroende på konfigurationen, kan ta från 1 till 8 sekunder (i mitt fall - 6 sekunder). Naturligtvis kommer att upprätta en anslutning för varje begäran göra att varje sida laddas på 8 sekunder.
– Eftersom python-webbapplikationer fungerar som oberoende servrar kan föregående punkt kompenseras genom att lagra anslutningen i någon global variabel och återställa den vid ett fel. Hur man upprätthåller en anslutning i PHP har jag ärligt talat inte tänkt på ännu.
- Förlorad plattformsoberoende webbapplikation.

Baserat på punkterna som anges ovan beslutades det att ändra interaktionsprincipen, dela upp den i 2 delar - den första plattformsberoende (Windows), ladda 1C-data till vilket lämpligt format som helst, och den andra, plattformsoberoende, som kan arbeta med data utan att misstänka något om 1C i princip.

Åtgärdsstrategin är följande: python-skriptet ansluter till 1C, utför de nödvändiga frågorna och laddar upp data till SQLite-databasen. Du kan ansluta till denna databas från Python, PHP, Java. De flesta av våra projekt är i python, och eftersom jag inte tål att skriva råa SQL-frågor för hand, görs allt arbete med SQLite-databasen genom SQLAlchemy ORM. Det var bara nödvändigt att beskriva databasdatastrukturen i en deklarativ stil:

Från sqlalchemy.ext.declarative import declarative_base från sqlalchemy import Column, Integer, Numeric, DateTime, Unicode, Boolean, LargeBinary, ForeignKey Base = declarative_base() class Abonent(Base): __tablename__ = "abonents_primary"(nyckel = "abonents_primary" True) konto = Kolumn(Unicode(32), index=True) kod = Kolumn(Unicode(32)) adress = Kolumn(Unicode(512)) fio = Kolumn(Unicode(256)) källa = Kolumn(Unicode(16) ) psu = Kolumn(Unicode(256)) tso = Kolumn(Unicode(256)) np = Kolumn(Unicode(256)) street = Kolumn(Unicode(256)) house = Kolumn(Heltal) lägenhet = Kolumn(Heltal) mro = Kolumn(Unicode(256)) klass Betalning(Bas): __tabellnamn__ = "betalningar" # och så vidare...

Nu räcker det att importera den här modulen till vilket pythonprojekt som helst, och du kan arbeta med datan.

Jag förutser din fråga - "varför SQLite"? Den främsta anledningen är att databasen endast behövs för läsning, så vi bör inte oroa oss för problem med att skriva till SQLite. För det andra är formatet för denna DBMS bekvämt - det är bekvämare att se det (det finns många gratis verktyg, inklusive en supertillägg för FireFox). För det tredje krävdes det i vissa fall att få tillgång till abonnenter från de maskiner på vilka det inte finns någon anslutning till MySQL-servern. I det här fallet räcker det med att kopiera SQLite-databasfilen, och på den här maskinen har du tillgång till all information.

Lossning sker en gång om dagen på natten. Inmatning av data i 1C kan automatiseras på samma sätt. Till exempel är det nödvändigt att registrera avläsningar som lämnas av prenumeranter på webbplatsen för personliga konton. I det här fallet ansluter vi igen till 1C och skapar och genomför dokumentet "Act of Taking Testimonies". Jag kommer att tillhandahålla koden nedan.

Att arbeta med COM-objekt i Python är lite ovanligt. För det första går kodens "pytonicitet" förlorad - reglerna för att namnge variabler och funktioner i 1C, för att uttrycka det milt, motsvarar inte Pythons Zen. För det andra vet alla att 1C-objekt ofta kallas kyrilliska tecken, vilket kommer att orsaka problem vid utveckling i Python ... men de är lösbara. Jag föreslår att du tar en titt på koden:

Importera pythoncom import win32com.client V82_CONN_STRING = "Srvr=v8_server;Ref=v8_db;Usr=användarnamn;Pwd=megapass;" pythoncom.CoInitialize() V82 = win32com.client.Dispatch("V82.COMConnector").Connect(V82_CONN_STRING)

Som du kan se av koden är klienten initierad för att arbeta med 1C. COM-objektet definieras av namnet "V82.COMConnector". Observera att detta namn är giltigt för V8.2-plattformen, om du har version 8.1 kommer namnet att vara "V81.COMConnector".

På den initierade klienten anropar vi metoden Connect() och skickar den till anslutningssträngen. Strängen består av servernamn, databas, användare och lösenord. Det resulterande V82-objektet lagrar anslutningen till 1C-applikationen. Den har inte en Disconnect()-metod eller något liknande. För att koppla från basen räcker det att ta bort objektet från minnet med del ()-funktionen eller tilldela variabeln till Ingen.

Med ett objekt kan du komma åt alla fält och metoder i 1C globala sammanhang, arbeta med universella objekt som TabularDocument, TableValues, etc. Det är viktigt att notera att när du arbetar genom en COM-anslutning, fungerar 1C i läget "Extern anslutning". Den innehåller inga funktioner för interaktivt arbete, såsom popup-dialoger, meddelanden och, viktigast av allt, formulär. Jag är säker på att du kommer att förbanna konfigurationsutvecklarna mer än en gång, som drar slutsatserna mest viktig funktionalitet till proceduren Button1Press() i dokumentformulärmodulen.

Låt oss prata om en så viktig sak som kyrilliska attribut. Trots att 1C är en tvåspråkig miljö och det finns en engelsk motsvarighet för varje rysk metod, måste du förr eller senare vända dig till det kyrilliska attributet. Om på PHP-språk eller VBSCript kommer det inte att orsaka några problem,

Set Con = CreateObject("v81.COMConnector") Set v8 =Connect("Anslutningssträng") Set AccountsManager = v8.Documents.Accounts.... Set AccountsRecord= AccountsManager.CreateItem() AccountsRecord.Account = ... .... AccountsWrite.Write()

Då kraschar pythonkoden helt enkelt med ett syntaxfel. Vad ska man göra? Redigera konfiguration? Nej, använd bara metoderna getattr och setattr. Genom att skicka ett COM-objekt och ett kyrilliskt attributnamn till dessa funktioner kan du få och ställa in värden enligt:

#coding=cp1251 catalog = getattr(V82.Catalogs, "PersonalAccounts")

Följande är viktigt: attributnamn, såväl som funktions- och metodparametrar, måste skickas i cp1251-kodningen. Därför, för att undvika kodningsförvirring i förväg, är det vettigt att deklarera det i början av filen: #coding=cp1251. Efter det kan du skicka strängar utan att oroa dig för deras kodning. Men! Alla strängar som tas emot från 1C (resultat av funktionsanrop, förfrågningar) kommer att kodas i UTF-8.

Ett exempel på en kod som exekverar en fråga i 1C-miljön, itererar över resultatet och sparar databasen i SQLite:

#coding=cp1251 q = """ VÄLJ PersonalAccounts.Code AS-kod, PersonalAccounts.Building.Location.Name + ", " + PersonalAccounts.ShortAddress AS-adress, PersonalAccounts.Subscriber.Name AS fio, PersonalAccounts.Division.Name AS psu, EXPRESS(KarakteristikPersonalAccountsSliceLast.Value AS Directory.Territorial NetworkOrganisations).Namn AS tso, PersonalAccounts.Building.Settlement.Name AS np, PersonalAccounts.Building.Street.Name AS gata, PersonalAccounts.Building.House AS hus, Personer.Rum.Rum. AS flat , Personal Accounts.Division.Parent.Description AS mro FROM Directory.PersonalAccounts AS PersonalAccounts LEFT JOIN Dataregister.CharacteristicsPersonalAccounts.SliceLast(,CharacteristicsType = VALUE(Directory.Characteristics.TerritorialNetworksOrganisation)ASsonLcounts. .NewObject("Fråga ", q) selection = query.Execute().Choose() CONN = db.connect() CONN.query(models.Abonent).delete() medan selection.Next(): abonent = models.Abonent() abonent. account = selection.code.strip() abonent.code = selection.code abonent.fio = selection.fio abonent.address = selection.address abonent.psu = selection.psu abonent.tso = urval. tso abonent.source = u" ASRN" abonent.np = selection.np abonent.street = selection.street abonent.house = selection.house abonent.flat = selection.flat abonent.mro = selection.mro CONN.add(abonent) CONN.commit()

Här är CONN anslutningssessionen med SQLite-databasen. Ett frågeobjekt skapas, dess text fylls i. Som nämnts ovan måste texten för begäran vara i cp1251, för vilken kodningen först deklareras. Efter att frågan har körts raderas alla prenumeranter i databasen för att inte lägga till dubbletter, sedan läggs de till i en cykel och den sista commit följer.

När jag arbetade med förfrågningar upptäckte jag följande regler.

När du väljer fält, ge dem latinska namn, det kommer att vara mycket bekvämare att komma åt dem genom en väljare (punkt), istället för getattr().
- Välj endast primitiva datatyper: strängar, siffror, datum och booleaner. Välj aldrig länkar till ett objekt (dokument, katalog)! I detta sammanhang behöver du absolut inga referenser och är till och med skadlig, eftersom all åtkomst till referensens attribut eller metod kommer att resultera i en begäran via en COM-anslutning. Om du kommer åt länkattributen i en loop kommer det att gå extremt långsamt.
- Om du väljer ett datumfält kommer det att returneras som ett PyTime-objekt. Detta är en speciell datatyp för att skicka datum/tid på en COM-anslutning. Det är inte lika bekvämt att arbeta med det som med den vanliga datetime. Om du skickar detta objekt till int() kommer en tidsstämpel att returneras, från vilken du sedan kan hämta datetime med metoden fromtimestamp().

Låt oss nu titta på hur utskrivna dokument bildas. Faktum är att konsumenten behöver ges möjlighet att ladda ner förberedda dokument, till exempel ett betalningskvitto eller en avstämningshandling. Dessa dokument genereras i 1C i enlighet med de fastställda kraven, deras implementering i Python kommer att ta mycket tid. Därför är det bättre att generera dokument i 1C och spara dem i excel-format.

Så, avstämningshandlingsdokumentet genereras av en speciell extern bearbetning. För dem som inte är bekanta med 1C-terminologi: bearbetning är ett autonomt program som har sin egen modul, formulär, mallar, designade för att köras i 1C-miljön. Det är nödvändigt att initiera bearbetningen, fylla i dess uppgifter och anropa en funktion som kommer att returnera oss ett kalkylarksdokument avsett för visning i 1C. Detta dokument måste sparas i Excel-format och kopieras till servern eller skrivas till databasen.

Länk = getattr(V82.Catalogs, "SystemReports").FindByDescription("Elens Verification Act") nav_url = V82.GetURL(länk, "Rapport") namn = V82.ExternalReports.Connect(nav_url) ExternalReport = V82.Creports.Creport (namn) setattr(ExternalReport, "PersonalAccount", referens) table_doc = ExternalReport.GetDoc() sökväg = V82.GetTempFileName("xls") table_doc.Write(sökväg, V82 .SpreadsheetDocumentFileType.XLS) rapport = reports.Report() .account = referens.Code.strip() report.type = u"act" report.document = open(path, "rb").read() CONN.add(report)

Ovanstående utdrag gör följande. Bearbetningen som utgör dokumentet är kopplad. Bearbetning kan byggas in i konfigurationen, lagras på disk eller i en 1C-databas (i någon sorts katalog). Eftersom bearbetningen ändras ofta, för att inte uppdatera konfigurationen varje gång, lagras den mest frekventa bearbetningen i katalogen "ReportsSystem", i attributet för typen "värdelagring" med namnet Rapport. Bearbetningen kan initieras genom att ladda ner den från databasen till disken och ladda den, eller genom metoden GetURL() där du måste skicka en länk till katalogelementet och attributnamnet. Vi tilldelar attributvärden till det resulterande bearbetningsobjektet, anropar den exporterade GetDoc()-funktionen och får ett kalkylarksdokument som sparas i en temporär Excel-fil. Innehållet i denna fil skrivs till SQLite-databasen.

Det sista som återstår att överväga är den programmatiska inmatningen av data i 1C. Låt oss anta att det krävs att ange indikationer från abonnenter. För att göra detta räcker det att skapa och genomföra dokumentet "Bevisupptagning":

#coding=cp1251 acts = getattr(V82.Documents, "Act of Taking Testimonies") act = acts.CreateDocument() setattr(act, "Indication", 1024.23) setattr(act, "Subscriber", "Ivanov") # Fyllning i andra detaljer. ...act.Write()
Nu är datainmatningen automatiserad.

Så jag har beskrivit en metod som är baserad på programmatisk uppladdning och nedladdning av data med hjälp av en COM-anslutning. Denna metod har varit framgångsrik i min organisation i nästan ett år. Basen, bildad av 1C, betjänar 3 betalningssystem, internetinsamling (betalning med kort via internet), samt ett personligt konto. Dessutom är olika skript kopplade till databasen för att automatisera rutinen.

Trots bristerna i metoden (låg hastighet på COM-anslutningen) fungerar den i allmänhet stabilt. Vi har data i en plattformsoberoende form (SQLite) som kan arbetas med från vilket språk som helst. Och huvuddelen av koden är skriven i Python, vilket innebär att många verktyg och tekniker finns tillgängliga som du inte ens kan drömma om i 1C.

Detta är en av möjliga sätt interaktion med 1C. Jag är säker på att det inte är nytt och förmodligen redan har testats och optimerats av någon. Jag försökte dock beskriva så många detaljer om processen som möjligt för att rädda dig från de fallgropar som jag själv trampade på.

Jag önskar er alla lycka till, och kom ihåg att 1C inte är så läskigt som det är målat!

) Det är rätt

Samtidigt har jag sett mer än en gång när publikationer helt enkelt "tar fart" som inte drar ens 10 poäng.
Varför hände det här? Förmodligen för att någon uppenbarligen gillade dem.

Jag pratar om detta och säger att det skulle vara trevligt att inte läsa artikeln efter betyg för att förstå hur mycket du behöver den, eller att utvärdera den inte så primitivt +/-. När det gäller vad jag gillade skulle jag rätta till så här: hon gjorde så mycket poäng på grund av att stjärnorna bildades på ett sådant sätt och många människor samlades på sidan och många gillade det, du förstår själv att detta är en fråga av slumpen. så fort artikeln lämnar startsida då kan den redan hittas bara på begäran, och så röstar alla som går förbi. Och för att stödja på huvudsidan, så vitt jag förstår, tillåter de bara ständiga kommentarer = marknadsföring av artikeln.
Det är för detta som de lägger butiker på genomfartsgatorna - trots allt är det ofta inte produktens kvalitet och relevans som spelar roll, utan platsens öppenhet, folk som går köper ofta vad de kommer att slänga ut nästa dag, bara för processens skull. Detta är en välkänd sjukdom - shopomania. Eller att helt enkelt öka flödet ökar sannolikheten för rätt köpare.

Och för- och nackdelarna ... är bara något slags "tack" för den tid och det arbete som lagts ner

De där. Räknas ett minus som "tack" också? Så jag ville veta din inställning till om det är nödvändigt att uttrycka det i sådana fall, och hur intressant tycker andra? Om man ska uttrycka det när artikeln är skadlig/dålig eller när den helt enkelt är värdelös/tom för dig.
Enligt min åsikt ser artikeln bara ut som en ökning av betyget, eftersom:
1. Problemet med typer som jag gav ignorerades i allmänhet av författaren, även om han inte var för lat för att skriva en massa kommentarer.
2. Det finns en tydlig felaktighet i artikeln: det sägs att det är det enda sättet

V82 = New COMobject("V82.ComConnector"); Kod = ContractorCOM.Code;

men jag gör det lugnt med hjälp av bearbetning så här:

Notify(Base.Directories.Counterparties.FindBy Name("LLC").Code);

och allt är bra! Och jag väljer anslutningen V82.ComConnector
Det är på något sätt konstigt att författaren inte alls bryr sig om att hans artikel innehåller sådana problem som påtalats, men han reagerar inte på något sätt.
3. Men det finns fortfarande ett problem när felet "Klass finns inte" dyker upp
4. Men det finns ett problem när 8.2 är installerat, och sedan 8.1 är installerat - försök byta via OLE / COM med en typisk UT-BP-växel!
5. Kan du ange huvudbehandlingen på webbplatsen som gör att du kan ansluta universellt via OLE / COM så att nybörjare inte slösar tid, du skriver för dem! Förresten, av någon anledning, prunkar hennes bild med dig, varför skulle ?. Och som ett resultat, 2 ord på meriter och 6 mer bakom kulisserna.

I allmänhet kastar jag inte lera på dig, utan pekar ut specifika luckor, men det finns ingen reaktion. Om detta är upplevelsen du delar, så är den på något sätt felaktig och ofullständig.
Jag menar, om författaren hade en önskan att samla alla fel, då kunde han åtminstone lyssna på någon annans erfarenhet och inte snärja på kommentarerna. Det uppstår genast en situation när den som läser det vet mer än författaren, de säger till honom (ibland felaktigt), och han slår också emot. Som ett resultat finns all information inte i artikeln, utan i kommentarerna! Rolig! Det händer ofta, men samtidigt behöver du inte vila på det du ville bäst - jag visar hur det är bättre, och andra visar det! Inkludera detta i artikeln och det kommer att vara värt besväret, inte alla är intresserade av att läsa denna skärmytsling.

Ett sätt att överföra data från en 1C-konfiguration till en annan är en mjukvaruanslutning med COM. Många företag använder flera olika baser mellan vilka det måste finnas vissa samband och beroenden. Om det inte bara är nödvändigt att överföra data, utan också att utföra viss databehandling, kommer en COM-anslutning att vara den optimala mekanismen. Möjligheten att analysera data från en annan 1C-databas är användbar för alla utvecklare.

Vi ansluter via COM till 1C-databasen

För att implementera en COM-anslutning i 1C används en speciell mekanism som kallas COMConnector. Detta objekt installeras tillsammans med plattformen och används för att länka infobaser. Det bör noteras att för version 8.2 och 8.3 används objekt med olika namn - "V82.COMConnector" respektive "V83.COMConnector".

Kom ihåg att en licens förbrukas under COM-anslutningens varaktighet till databasen - du ska inte ryckas med att göra flera anslutningar samtidigt. Detta är särskilt viktigt för organisationer som har ett begränsat antal licenser. Detta problem kan lösas med rutinuppgifter som exekveras när det inte finns några aktiva användaranslutningar till infobasen.

För att kunna ansluta till en annan databas och begära nödvändig information måste du känna till följande data:

1. Vilken typ är det - fil eller klient-server;
2. Var ligger den;
3. Under vilket namn och lösenord kan du ange det;
4. Vilken data är du intresserad av.

Från de första tre punkterna, för att implementera en COM-anslutning, måste du bilda en parametersträng. Beroende på typ av IB kommer det att skilja sig åt utseende. Med hjälp av den mottagna strängen skapas en anslutning med vilken du kan samla in data från en annan databas för analys och bearbetning med valfri metod.

ConnectionParametersFileIB = "Fil=""Path_to_base""; Usr=""Användarnamn"";Pwd=""Lösenord"""; ConnectionParametersClientServerIB = "Srvr=""Server_Name""; Ref=""Base_Name""; Usr=""User_Name""; Pwd=""Lösenord""";

Anslutningsfunktionen är enkel och bör inte väcka frågor om alla parametrar är korrekta. För att påskynda felsökning och analys möjliga fel det är bättre att omsluta anslutningen i en försökskonstruktion. Funktionen returnerar ett värde av typen "COM-objekt", som du måste arbeta med för att få nödvändiga data.

&AtServer Funktion ConnectToBase() export ConnectionParametersIB = "File=""E:\base 1c\ERP""; Usr=""Administratör"";Pwd=""1"""; V83COMCon= Nytt COMObject("V83.COMConnector"); Försök att returnera V83COMCon.Connect(ConnectionParametersIB); Undantagsrapport(ErrorDescription()); Returnera odefinierat; Slut på försök; EndFunctions

Genom en COM-anslutning kan du inte bara välja data, utan även lägga till den i databasen du ansluter till. Kom ihåg att vi kan överföra 4 primitiva datatyper genom ett COM-objekt. Andra typer måste specificeras med hjälp av sökfunktionerna inbyggda i plattformen. Observera att globala plattformsfunktioner även anropas via en COM-anslutning.

Vi tar emot data från 1C-databasen

Efter att du har mottagit önskat objekt måste du läsa data från en annan databas. För att göra detta applicerar vi en begäran via en COM-anslutning i 1C 8.3 med det mottagna värdet av typen "COM-objekt" från funktionen. Det är viktigt att först ansluta till databasen och sedan köra begäran. Exekvering sker genom metoden NewObject med indikation av typen av objekt i strängform - "Request" som parameter.

&OnServer Procedur TestCOMOnServer() Connection = ConnectToBase(); Om TypeValue(Connection) Type("Odefinierad") Då QueryBPO = Connection.NewObject("Query"); Query BPZO.Text = "VÄLJ de första 15 | Användarkatalog. Namn AS Namn | FRÅN | Användarkatalog AS Användarkatalog"; Selection = QueryBPO.Run().select(); While Sample.next() loop Report(Selection.Number); EndCycle; EndIf; Slut på procedur >

För att till exempel få information om användare av en viss avdelning kommer vi att ställa ett villkor i förfrågan genom parametrar. En parameter kommer att vara av en enkel typ - en sträng och avdelningen - en länk till elementet i katalogen "Enterprise Structure". Frågeresultatet är en tabell med uppräknade fält av den typ de finns i databasen till vilken COM-anslutningen har skett. Om du behöver konvertera dem till andra typer, använd standardplattformsfunktionerna:

• Linje();
• Siffra();
• Datum för().

RequestBPO = Connection.NewObject("Request"); QueryBPO.Text = "VÄLJ de första 15 | Användarkatalog.Namn AS Namn |FRÅN | Katalog.Användare AS Användarkatalog I WHERE | Användarkatalog.Department = &ÖnskadAvdelning | Och Användarkatalog.Namn som ""%"" + &Önskat Namn+ ""%" "" ; BPZO Request.SetParameter("Önskad avdelning", Connection.Directories.Enterprise Structure.FindByCode("00-000023")); RequestBPO.SetParameter("RequiredName","Ekaterina"); Selection = QueryBPO.Run().select(); While Selection.next() loop Report(Selection.Name); EndCycle;

Om du behöver överföra en array till databasen för val med flera parametrar, till exempel divisioner, används också kommandot NewObject. På samma sätt kan du skicka en lista eller tabell med värden, fylla dem med element från en annan databas genom anslutningen. Alla befintliga metoder för objekt och mekanismer på plattformen är tillgängliga för dig att söka.

RequestBPO = Connection.NewObject.("Request"); QueryBPO.Text = "VÄLJ första 15 | Användarkatalog.Namn AS Namn | FROM | Katalog.Användare AS Användarkatalog I WHERE | Användarkatalog. Avdelning i (&Önskad avdelning) | Och Användarkatalog. Namn som ""%"" + &Önskat namn+ "" %" ""; Subdivisions Array = Connection.NewObject("Array"); Departments array.Add(Connection.Catalogs.EnterpriseStructure.FindByCode("00-000023")); Departments array.Add(Connection.Catalogs.EnterpriseStructure.FindByCode("00-000038")); Departments array.Add(Connection.Catalogs.EnterpriseStructure.FindByCode("00-000046")); BPZO Request.SetParameter("Önskad underavdelning", Array of Subdivisions); RequestBPO.SetParameter("RequiredName","Ekaterina"); Selection = QueryBPO.Run().select(); While Selection.next() loop Report(Selection.Name); EndCycle;

Vid överföring av dokument eller delar av kataloger uppstår alltid frågan om att kontrollera överföringen av ett specifikt objekt. Med COM-anslutningar kan du lösa sådana problem genom en unik identifierare. Du måste hitta ett objekt i den pluggbara databasen med identifieraren från den aktuella IB med hjälp av "GetLink"-funktionen, med identifieraren som en sträng. Om det inte finns en kan du skapa den med en COM-anslutning.

StrIdent = String(Directories.Users.FindByCode("00-0000313").UniqueIdentifier()); Om INTE ValueFilled(Connection.Catalogs.Users.GetReference(Connection.NewObject("UniqueIdentifier", StrIdent))) då NewUser = Connection.Catalogs.Users.CreateItem(); NewUser.Name = Directories.Users.FindByCode("00-0000313").Name; NewUser.Individual = Directories.Users.FindByCode("00-0000313").Individual; NewUser.Write(); EndIf;

Dessutom har COM-anslutningen rätt att använda procedurer och funktioner från vanliga 1C-moduler med egenskapen "Extern anslutning" aktiverad. Utöver detta villkor måste den anropade funktionen eller proceduren vara en exportfunktion och inte inkludera interaktiva åtgärder som utförs på servern. Annars kommer du att se ett felmeddelande om den ogiltiga åtgärden.

Förening..; VariableFromFunction = Anslutning...; funktionsanrop>gemensamt modulnamn>proceduranrop>gemensamt modulnamn>

Möjligheterna till extern anslutning till en annan databas i 1C är ganska omfattande och kan tillåta dig att utföra många uppgifter. Det är viktigt att kunna utvärdera verktygslådan och välja rätt optimal lösning. I de flesta fall visas denna färdighet endast med erfarenhet eller genom att studera exempel på erfarna yrkesverksammas arbete.