Միացում 1s 8.3-ին com-ի միջոցով: COM-օբյեկտների հետ աշխատելու երեք կետեր: COM կապով աշխատելն ավելի հեշտ է, քան դուք կարող եք մտածել: COM-ի միջոցով օբյեկտ ստանալը ID-ով
1C կոնֆիգուրացիայից մյուսը տվյալների փոխանցման եղանակներից մեկը COM-ի միջոցով ծրագրային կապն է: Շատ ընկերություններ օգտագործում են մի քանի տարբեր հիմքեր, որոնց միջև պետք է լինեն որոշակի կապեր և կախվածություններ։ Եթե անհրաժեշտ է ոչ միայն տվյալների փոխանցում, այլև որոշակի տվյալների մշակում, ապա COM կապը կլինի օպտիմալ մեխանիզմը: Մեկ այլ 1C տվյալների բազայից տվյալները վերլուծելու ունակությունը օգտակար է ցանկացած մշակողի համար:
Մենք միանում ենք COM-ի միջոցով 1C տվյալների բազային
1C-ում COM միացումն իրականացնելու համար օգտագործվում է հատուկ մեխանիզմ, որը կոչվում է COMConnector: Այս օբյեկտը տեղադրված է հարթակի հետ և օգտագործվում է հաղորդակցության համար տեղեկատվական բազաները. Նշենք, որ 8.2 և 8.3 տարբերակների համար օգտագործվում են տարբեր անվանումների օբյեկտներ՝ համապատասխանաբար «V82.COMConnector» և «V83.COMConnector»:
Հիշեք, որ լիցենզիան ծախսվում է տվյալների բազայի հետ COM կապի տևողության համար. դուք չպետք է տարվեք միաժամանակ մի քանի կապեր կատարելով: Սա հատկապես կարևոր է այն կազմակերպությունների համար, որոնք ունեն սահմանափակ թվով լիցենզիաներ: Այս խնդիրը կարող է լուծվել պլանավորված առաջադրանքների օգնությամբ, որոնք կատարվում են ինֆոբազի հետ օգտատերերի ակտիվ կապերի բացակայության ժամանակ:
Որպեսզի կարողանաք միանալ մեկ այլ տվյալների շտեմարանին և խնդրել անհրաժեշտ տեղեկատվությունդուք պետք է իմանաք հետևյալ տվյալները.
- Ինչ տեսակ է դա՝ ֆայլ կամ հաճախորդ-սերվեր;
- Որտեղ է այն գտնվում;
- Ինչ անունով և գաղտնաբառով կարող եք մուտքագրել այն;
- Ի՞նչ տվյալներ են ձեզ հետաքրքրում։
Առաջին երեք կետերից COM կապն իրականացնելու համար անհրաժեշտ է ձևավորել պարամետրային տող: Կախված IB-ի տեսակից, այն կտարբերվի տեսքը. Օգտագործելով ստացված տողը, միացում է կատարվում, որի հետ կարելի է տվյալներ հավաքել մեկ այլ տվյալների բազայից՝ ցանկացած եղանակով վերլուծելու և մշակելու համար։
ConnectionParametersFileIB = "File=""Path_to_base"";Usr=""User_name"";Pwd=""գաղտնաբառ"""; ConnectionParametersClientServerIB = "Srvr=""Server_Name""; Ref=""Base_Name""; Usr=""User_Name""; Pwd=""Password""";Միացման գործառույթը պարզ է և չպետք է հարցեր առաջացնի, եթե բոլոր պարամետրերը ճիշտ են: Վրիպազերծումը և վերլուծությունը արագացնելու համար հնարավոր սխալներավելի լավ է կապը ներառել Փորձի կառուցվածքում: Ֆունկցիան կվերադարձնի «COM օբյեկտ» տեսակի արժեք, որի հետ դուք պետք է աշխատեք՝ ստանալով անհրաժեշտ տվյալները։
&AtServer ֆունկցիան ConnectToBase() արտահանում ConnectionParametersIB = "File=""E:\base 1c\ERP""; Usr=""Administrator"";Pwd=""1"""; V83COMCon= Նոր COMO օբյեկտ ("V83.COMConnector"); Վերադարձի փորձ V83COMCon.Connect(ConnectionParametersIB); Բացառության հաշվետվություն (ErrorDescription()); Վերադարձեք չսահմանված; Փորձի ավարտ; EndFunctionsCOM կապի միջոցով դուք կարող եք ոչ միայն ընտրել տվյալներ, այլև ավելացնել դրանք տվյալների բազայում, որին միանում եք: Հիշեք, որ մենք կարող ենք փոխանցել 4 պարզունակ տվյալների տեսակ COM օբյեկտի միջոցով: Մյուս տեսակները պետք է նշվեն՝ օգտագործելով հարթակում ներկառուցված որոնման գործառույթները: Նշենք, որ գլոբալ հարթակի գործառույթները կանչվում են նաև COM կապի միջոցով:
Մենք տվյալներ ենք ստանում 1C տվյալների բազայից
Ցանկալի օբյեկտը ստանալուց հետո անհրաժեշտ է կարդալ տվյալները մեկ այլ տվյալների բազայից: Դա անելու համար մենք հարցում ենք կիրառում COM կապի միջոցով 1C 8.3-ում՝ օգտագործելով ֆունկցիայից «COM օբյեկտ» տեսակի ստացված արժեքը: Կարևոր է նախ միանալ տվյալների բազային, այնուհետև կատարել հարցումը: Կատարումը կատարվում է NewObject մեթոդի միջոցով՝ որպես պարամետր նշելով օբյեկտի տեսակը լարային տեսքով՝ «Request»:
&OnServer կարգը TestCOMOnServer() Միացում = ConnectToBase(); Եթե TypeValue(Connection) Type("Undefined") Այնուհետեւ QueryBPO = Connection.NewObject("Query"); Հարցում BPZO.Text = "Ընտրեք առաջին 15-ը | Օգտագործողի գրացուցակ. Անունը AS անուն | FROM | Օգտագործողի տեղեկատու AS User Directory"; Ընտրություն = QueryBPO.Run().select(); Մինչ Sample.next() loop Report(Selection.Number); End Cycle; EndIf; Ընթացակարգի ավարտ >Օրինակ՝ որոշակի ստորաբաժանման օգտատերերի մասին տեղեկություններ ստանալու համար հարցումում պարամետրերի միջոցով պայման կդնենք։ Մեկ պարամետր կլինի պարզ տեսակ- տող, իսկ ստորաբաժանումը՝ հղում դեպի «Ձեռնարկության կառուցվածք» գրացուցակի տարրին: Հարցման արդյունքը աղյուսակ է թվարկված դաշտերով, որոնց տիպի առկա են տվյալների բազայում, որի հետ տեղի է ունեցել COM կապը: Եթե Ձեզ անհրաժեշտ է դրանք փոխարկել այլ տեսակների, օգտագործեք ստանդարտ հարթակի գործառույթները.
- Line ();
- Թիվ();
- Ամսաթիվը().
Եթե Ձեզ անհրաժեշտ է զանգված փոխանցել տվյալների բազա՝ ընտրելու համար մի քանի պարամետրերով, օրինակ՝ բաժանումներ, ապա օգտագործվում է նաև NewObject հրամանը։ Նմանապես, դուք կարող եք փոխանցել արժեքների ցուցակ կամ աղյուսակ, դրանք լրացնելով կապի միջոցով մեկ այլ տվյալների բազայի տարրերով: Բոլորը հասանելի են ձեզ համար որոնելու համար: առկա մեթոդներըհարթակի առարկաները և մեխանիզմները:
RequestBPO = Connection.NewObject.("Request"); QueryBPO.Text = "Ընտրեք առաջին 15-ը | User Directory.Name AS Name | FROM | Directory.Users AS User Directory I WHERE | User Directory.Department In (&DesiredDepartment) | Եվ UserDirectory.Name, ինչպիսին է ""%"" + &DesiredName+ "" %" ""; Subdivisions Array = Connection.NewObject("Array"); Բաժանմունքներ array.Add(Connection.Catalogs.EnterpriseStructure.FindByCode(«00-000023»)); Բաժանմունքներ array.Add(Connection.Catalogs.EnterpriseStructure.FindByCode("00-000038")); Բաժանմունքներ array.Add(Connection.Catalogs.EnterpriseStructure.FindByCode(«00-000046»)); Հարցում BPZO.SetParameter («Ցանկալի ենթաբաժին», ստորաբաժանումների զանգված); RequestBPO.SetParameter("RequiredName","Ekaterina"); Ընտրություն = QueryBPO.Run().select(); Մինչ Selection.next() loop Report(Selection.Name); End Cycle;Փաստաթղթեր կամ գրացուցակների տարրեր փոխանցելիս միշտ հարց է առաջանում կոնկրետ օբյեկտի փոխանցումը վերահսկելու մասին: COM կապերով դուք կարող եք լուծել նման խնդիրները եզակի նույնացուցիչի միջոցով: Դուք պետք է գտնեք օբյեկտը pluggable տվյալների բազայում նույնացուցիչով ընթացիկ IB-ից՝ օգտագործելով «GetLink» ֆունկցիան՝ օգտագործելով նույնացուցիչը որպես տող: Եթե չկա մեկը, կարող եք այն ստեղծել COM կապի միջոցով:
StrIdent = String(Directories.Users.FindByCode("00-0000313").UniqueIdentifier()); Եթե NOT ValueFilled(Connection.Catalogs.Users.GetReference(Connection.NewObject("UniqueIdentifier", StrIdent))), ապա NewUser = Connection.Catalogs.Users.CreateItem(); NewUser.Name = Directories.Users.FindByCode("00-0000313").Անուն; NewUser.Individual = Directories.Users.FindByCode("00-0000313").Անհատական; NewUser.Write(); EndIf;Նաև COM կապն իրավունք ունի օգտագործել ընթացակարգեր և գործառույթներ ընդհանուր 1C մոդուլներից՝ միացված «Արտաքին կապ» հատկությամբ: Բացի այս պայմանից, կանչված գործառույթը կամ ընթացակարգը պետք է լինի արտահանման գործառույթ և չներառի սերվերի վրա կատարվող ինտերակտիվ գործողություններ: Հակառակ դեպքում, դուք կտեսնեք սխալ գործողության վերաբերյալ սխալ:
Բաղադրյալ..; VariableFromFunction = Միացում..; ֆունկցիայի կանչ>համընդհանուր մոդուլի անվանում>ընթացակարգի կանչ>ընդհանուր մոդուլի անվանում>1C-ում մեկ այլ տվյալների բազայի հետ արտաքին կապի հնարավորությունները բավականին ընդարձակ են և թույլ են տալիս կատարել բազմաթիվ առաջադրանքներ։ Կարևոր է կարողանալ ճիշտ գնահատել գործիքակազմը և ընտրել օպտիմալ լուծում. Շատ դեպքերում այս հմտությունը ի հայտ է գալիս միայն փորձառությամբ կամ փորձառու մասնագետների աշխատանքի օրինակների ուսումնասիրությամբ:
Տպել (Ctrl+P)
1C տվյալների բազաների միջև տվյալների փոխանակման տարբերակներից մեկը COM կապի միջոցով փոխանակումն է: Օգտագործելով COM կապը, դուք կարող եք միանալ 1C տվյալների բազայից մյուսին և կարդալ կամ գրել տվյալներ: Դուք կարող եք օգտագործել այս մեթոդը և՛ տվյալների բազաների հաճախորդ-սերվերի տարբերակներում, և՛ ներսում ֆայլերի տվյալների բազաներ. Այս հոդվածը քննարկում է 8.3 պլատֆորմի այս տեսակի կապերը
com կապ
Դուք կարող եք ստեղծել երկու տեսակի COM օբյեկտներ 1C հավելվածի համար: Օլե կապեր են V83. Դիմում և com կապեր V83.COM Միակցիչ . Դեպքում V83. Դիմումգործարկվել է 1C հավելվածի գրեթե ամբողջական պատճենը: Օգտագործման դեպքում V83.COM Միակցիչմի փոքր սերվերի մաս է սկսվում: Աշխատանքի արագությունն այս դեպքում ավելի բարձր է, սակայն որոշ գործառույթներ կարող են հասանելի չլինել: Մասնավորապես, աշխատել ձևերի և ընդհանուր մոդուլների հետ, որոնց համար դրված չէ արտաքին կապերով աշխատելու հատկությունը։ Դուք հիմնականում պետք է օգտագործեք V83.COM Միակցիչև միայն ֆունկցիոնալության բացակայության դեպքում V83. Դիմում. Արագության տարբերությունը կարող է հատկապես նկատելի լինել մեծ տվյալների բազաներում։ Պլատֆորմի համար օգտագործվում է 8.2 V82.Application կամ V82.COMConnector
Ստեղծեք OLE կապ
Միացում = Նոր COMObject («V83.Application»);
Ստեղծեք COM կապ
Միացում = Նոր COMObject («V83.COMConnector»);
Միացման տող
//Հաճախորդ-սերվեր տարբերակի համար
StringConnection= “Srvr = “ “ServerName” “;Ref = “ “BaseName” ;
//Ֆայլի ռեժիմի տարբերակի համար.
StringConnection= «Ֆայլ = «PathBase» «; Usr = Մականուն; Pwd = Գաղտնաբառ»;
Փորձ
Միացում = Միացում . Միացնել(ConnectionString) ;
Բացառություն
Հաղորդագրություն = New MessageToUser;
Հաղորդագրություն . Տեքստ =
«Չհաջողվեց միանալ տվյալների բազային» +
Նկարագրություն Սխալ (); Հաղորդագրություն . Զեկուցել();
Վերջ Փորձել;
Կապի խզում
Միացում = Չսահմանված;
Օբյեկտի համար V83. Դիմումպարտադիր է անջատել կապը, հակառակ դեպքում թերի նիստը կախված կմնա, որն այնուհետև պետք է ջնջվի ձեռքով: Դեպքում V83.COM ՄիակցիչԿապը ավտոմատ կերպով դադարեցվում է այն ընթացակարգի ավարտին, որով միացումը կատարվել է, և կա ևս մեկ փոքր պահ. Այն օգտատիրոջ համար, որի հետ կապն իրականացվում է, դրա կարգավորումներում «Հաստատում խնդրեք ծրագիրը փակելիս» վանդակը պետք է անջատված լինի:
NewObject() մեթոդ
Նոր օբյեկտ ստեղծելու համար կարող եք օգտագործել NewObject() մեթոդը, օրինակ՝
Համար V83.COM Միակցիչ
RequestCOM = Միացում. Նոր օբյեկտ ( «խնդրանք»)
;
TableCOM = Միացում. Նոր օբյեկտ ( «Արժեքի աղյուսակ»)
;
ArrayCOM = Միացում: NewObject («Զանգված»);
WidCOM = Connection.NewObject
Համար V83. Դիմում
QueryOLE = Միացում. Նոր օբյեկտ (" հարցում»)
;
TableOLE = Միացում: Նոր Օբյեկտ(«Արժեքի աղյուսակ»)
;
ArrayOLE = Connection.NewObject(«Զանգված»);
WidCOM = Connection.NewObject(«UniqueIdentifier»,StringUID);
RequestCOM . Տեքստ =«ԸՆՏՐԵՔ
| Կազմակերպությունների պաշտոններ Կոդ,
| Կազմակերպությունների պաշտոններ Անուն
|ԻՑ | Directory.PositionsOrganizations
կազմակերպությունների ՀԾ պաշտոնները» թեմայով:;
Արդյունք = RequestCOM: Կատարել ();
Նմուշ = արդյունք. Ընտրեք ();
Մինչ ընտրության. Հաջորդ ()Ցիկլ
Վերջնական ցիկլ;
Կարող եք նաև օգտագործել կազմաձևման օբյեկտների կառավարիչները.
DirectoryCOM = Միացում: Տեղեկատու գրքեր. DirectoryName;
DocumentCOM = Միացում. Փաստաթղթեր. Փաստաթղթի անունը;
RegisterCOM = Միացում: Գրանցման Տեղեկություններ. Գրանցման անունը;
COM կապի միջոցով թվի ստացում և համեմատում
Կազմաձևում սահմանված թվային տարրերի արժեքները համեմատելու համար անհրաժեշտ է վերափոխել այդ տարրերը պարզունակ տեսակներից մեկի, որի համեմատությունը դժվարություններ չի առաջացնում: Այս տեսակները կարող են լինել կամ թվային կամ լարային տեսակ: Դուք կարող եք վերափոխել թվային տարրի արժեքը նման թվային տեսակի
Enum տարր = Connection.Directories.Directory1.FindByCode(1).Attribute1;
PossibleValues = EnumElement.Metadata().EnumValues;
EnumElementNumber = PossibleValues.Index(PossibleValues.Find(Connection.XMLString(EnumElement)));
Եթե EnumItemNumber = 0, ապա հաշվետվություն ( «EnumValue1»);
ElseIf EnumItemNumber = 1 ՀետոՀաշվետվություն ("EnumValue2");
EndIf;
COM-ի միջոցով օբյեկտ ստանալը ID-ով
Կազմաձևման օբյեկտների կառավարիչների միջոցով մենք ստանում ենք com օբյեկտ, օրինակ.
DocumentCOM = Միացում. Փաստաթղթեր. Փաստաթղթի անունը;
Այնուհետև մենք ստանում ենք եզակի նույնացուցիչի տողը.
StringUID = Connection.string ( DocumentCOM.UniqueIdentifier())
ID = Նոր Յ եզակի ID (StringUID);
ՀԵՏ linkByIdentifier = Փաստաթղթեր[DocumentName].GetLink(Identifier);
Եթե Ձեզ անհրաժեշտ է գտնել com օբյեկտը փաստաթղթով ըստ ID-ի, ապա պետք է գրել այսպես.
WidCOM = Connection.NewObject(«UniqueIdentifier»,StringUID);
LinkByIdentifier = Connection.Documents[DocumentName].GetLink(UidCOM);
) Ճիշտ է
Միևնույն ժամանակ, ես մեկ անգամ չէ, որ տեսել եմ, երբ ուղղակի «թափ են անում» հրապարակումներ, որոնք նույնիսկ 10 միավոր չեն քաշում։
Ինչու՞ դա տեղի ունեցավ: Հավանաբար այն պատճառով, որ ինչ-որ մեկին ակնհայտորեն դուր են եկել դրանք:
Ես խոսում եմ սրա մասին և ասում, որ լավ կլիներ հոդվածը չկարդալ ըստ վարկանիշի՝ հասկանալու համար, թե որքանով է դա ձեզ անհրաժեշտ, կամ գնահատել ոչ այնքան պարզունակ +/-։ Իսկ թե ինձ ինչ դուր եկավ, ես այսպես կուղղեի. նա այնքան շատ գոլեր է հավաքել այն պատճառով, որ աստղերն այդպես են ձևավորվել և շատ մարդիկ են հավաքվել կայքում և շատերը հավանել են, դուք ինքներդ էլ հասկանում եք, որ սա խնդիր է. պատահականություն. հոդվածը հեռանալուն պես գլխավոր էջապա այն արդեն կարելի է գտնել միայն խնդրանքով, և այդպիսով բոլոր անցնողներն քվեարկում են: Իսկ գլխավոր էջում աջակցելու համար, որքան հասկանում եմ, թույլ են տալիս ուղղակի մշտական մեկնաբանություններ = հոդվածի առաջխաղացում։
Հենց դրա համար էլ նրանք խանութներ են դնում փողոցների վրա, ի վերջո, հաճախ կարևոր է ոչ թե ապրանքի որակն ու համապատասխանությունը, այլ տեղանքի թափանցիկությունը, քայլող մարդիկ հաճախ գնում են այն, ինչ հաջորդ օրը դուրս կգցեն, զուտ գործընթացի համար: Սա հայտնի հիվանդություն է՝ շոոմանիա։ Կամ պարզապես հոսքի ավելացումը մեծացնում է ճիշտ գնորդի հավանականությունը:
Իսկ դրական ու բացասական կողմերը... ընդամենը մի տեսակ «շնորհակալություն» են ծախսած ժամանակի և աշխատանքի համար
Նրանք. Արդյո՞ք մինուսը նույնպես «շնորհակալություն» է համարվում: Ուստի ես ուզում էի իմանալ ձեր վերաբերմունքը, թե արդյոք անհրաժեշտ է դա դնել նման դեպքերում, և որքանո՞վ են հետաքրքիր մյուսները: Անկախ նրանից, թե այն, երբ հոդվածը վնասակար է / վատ է, թե երբ այն պարզապես անօգուտ / դատարկ է ձեզ համար:
Իմ կարծիքով հոդվածը պարզապես վարկանիշի բարձրացում է թվում, քանի որ.
1. Իմ կողմից տրված տիպերի խնդիրը հեղինակի կողմից ընդհանրապես անտեսվել է, չնայած նա այնքան էլ ծույլ չէր գրել մի փունջ մեկնաբանություններ։
2. Հոդվածում հստակ անճշտություն կա՝ ասվում է, որ դա միակ ճանապարհն է
V82 = Նոր COMobject ("V82.ComConnector"); Կոդ = ContractorCOM.Code;
բայց ես հանգիստ դա անում եմ այսպես մշակման օգնությամբ.
Notify (Base.Directories.Counterparties.FindBy Name("LLC").Code);
և ամեն ինչ լավ է! Իսկ ես ընտրում եմ V82.ComConnector կապը
Ինչ-որ տեղ տարօրինակ է, որ հեղինակին բոլորովին չի հետաքրքրում, որ իր հոդվածում կան այնպիսի խնդիրներ, որոնք մատնանշված են, բայց նա ոչ մի կերպ չի արձագանքում։
3. Բայց դեռ խնդիր կա, երբ հայտնվում է «Class does not exist» սխալը
4. Բայց խնդիր կա, երբ տեղադրվում է 8.2, իսկ հետո տեղադրվում է 8.1 - փորձեք փոխանակել OLE / COM-ի միջոցով տիպիկ UT-BP փոխանակման հետ:
5. Կարո՞ղ եք նշել կայքի հիմնական մշակումը, որը թույլ է տալիս համընդհանուր միանալ OLE / COM-ի միջոցով, որպեսզի սկսնակները ժամանակ չկորցնեն, դուք գրեք նրանց համար: Ի դեպ, չգիտես ինչու, նրա նկարը շողոքորթում է ձեզ հետ, ինչու՞: Եվ արդյունքում՝ 2 խոսք ըստ էության, ևս 6 կուլիսային։
Ընդհանրապես ես ձեր վրա ցեխ չեմ շպրտում, այլ կոնկրետ բացեր եմ մատնանշում, բայց արձագանք չկա։ Եթե սա այն փորձն է, որը դուք կիսում եք, ապա այն ինչ-որ տեղ սխալ է և թերի:
Նկատի ունեմ, որ եթե հեղինակը ցանկություն ուներ հավաքել բոլոր թերությունները, ապա նա կարող էր գոնե լսել ուրիշի փորձը, այլ ոչ թե դիպչել մեկնաբանություններին: Միանգամից իրավիճակ է ստեղծվում, երբ կարդացողը հեղինակից ավելին գիտի, նրան ասում են (երբեմն՝ սխալ), ինքն էլ հակադարձում է։ Արդյունքում ամբողջ տեղեկատվությունը ոչ թե հոդվածում է, այլ մեկնաբանություններում։ Զվարճալի՜ Դա հաճախ է պատահում, բայց միևնույն ժամանակ, ձեզ հարկավոր չէ հանգստանալ այն ամենի վրա, ինչ ցանկանում եք լավագույնը. ես ցույց եմ տալիս, թե ինչպես է դա ավելի լավ, իսկ մյուսները ցույց են տալիս դա: Ներառեք սա հոդվածում, և դա արժի, ոչ բոլորն են հետաքրքրված այս փոխհրաձգության ընթերցմամբ:
Բարև Խաբրավչաններ։
Այս հոդվածում ես ուզում եմ խոսել այն մասին, թե ինչպես է հաստատվել իմ կազմակերպությունում 1C պլատֆորմի հետ ինտեգրումը: Այն, ինչ ինձ դրդեց անել դա, գրեթե լիակատար բացակայությունն էր տեխնիկական տեղեկատվությունայս թեմայի շուրջ. Կարդալով տարբեր հոդվածներ և զեկույցներ 1C-ն ցանկացած տեղեկատվական համակարգի հետ կապելու թեմայով, դուք նորից ու նորից համոզվում եք, որ դրանք բոլորը շուկայավարման, ցուցադրական բնույթի և երբեք տեխնիկական չեն, արտացոլում են խնդիրը և դրա լուծման էությունը:
Ես զգուշացնում եմ ձեզ, որ մեթոդը ոչ մի կերպ չի հավակնում ունիվերսալ լինելուն: Քանի որ կան շատ 1C կոնֆիգուրացիաներ, և տեղեկատվական համակարգեր, լեզուներ և հարթակներ - նույնիսկ ավելին, հնարավոր համակցությունների թիվը հսկայական է: Իմ նպատակն է ցույց տալ մեկ հնարավոր լուծում.
Որպես լեզու, որը ինտեգրվելու է 1C-ի հետ, ես ընտրեցի Python-ը: Այն շատ հարմար է գործընթացների ավտոմատացման համար: Դրան նպաստում է մինիմալիստական շարահյուսությունը (կոդը շատ արագ է մուտքագրվում), հարուստ ստանդարտ գրադարանը (երրորդ կողմի մոդուլների ավելի քիչ կարիք), խաչաձև հարթակ. մեծ հավանականությամբ Linix OS-ում գրված կոդը հաջողությամբ կաշխատի Հայաստանում: Windows.
Սկզբից ես ուրվագծեմ այն տվյալները, որոնցով մենք աշխատելու ենք: Կազմակերպությունը՝ Հեռավոր Արևելքի տարածաշրջանի էլեկտրամատակարարման ընկերություն, սպասարկում է մոտավորապես 400 հազար բաժանորդի, բազան 1C է ինքնուրույն գրված կոնֆիգուրացիայի վրա: Յուրաքանչյուր բաժանորդի համար պահվում են նրա վճարումները, հաշվեգրումները, սպառված ծառայություններն ու հաշվարկային սխեմաները, չափիչ սարքերը, ընթերցումները և բազմաթիվ այլ տվյալներ։
Մի անգամ կազմակերպությունում կար մի ծրագիր, որը գրված էր Դելֆիում և օգտագործում էր MSSQL / Firebird որպես տվյալների բազա: Այդ փառահեղ ժամանակներում հնարավոր էր ցանկացած լեզվով միանալ տվյալների շտեմարանին և կատարել բազմաթիվ գործողություններ՝ ընտրել պարտապանների բաժանորդներ, մուտքագրել ստացված վճարումները, ձայնագրել գործիքների ընթերցումները: Զարմանալի չէ, որ առօրյան ավտոմատացնող սցենարների հավաքածուն անընդհատ աճում է: Ծրագրավորողները կարող էին կատարել ցանկացած գործողություն՝ առանց ծրագիրը բացելու:
Ափսոս, 1C-ին անցնելով, անվճարն ավարտվեց. այլևս հնարավոր չէր ուղղակիորեն միանալ տվյալների բազային: Ընդհանուր առմամբ, 1C հարթակն ինքնին անբաժանելի է և վատ ինտեգրված այլ համակարգերի հետ: Դա, ինչպես ասում են, ինքնին մի բան է։ Տվյալները 1C-ում բեռնելիս պետք է հիշել, որ դրանք այնտեղից հանելը այնքան էլ հեշտ չի լինի: Բայց հաշվի առնելով այն հանգամանքը, որ կազմակերպությունից պահանջվում էր ներդրել վճարային համակարգեր և Անձնական տարածք, պետք էր լուծում գտնել։
Իմ առջեւ դրված գլխավոր խնդիրը հնարավորությունն է արագ ստացումտվյալներ կոնկրետի համար անձնական հաշիվ- Ամբողջական անվանումը, հասցեն, չափիչ սարքերը, գործիքների ընթերցումները, վճարումները, վճարները: Գումարած, փաստաթղթերի ձևավորում՝ հաշտության ակտ, վճարման անդորրագիր: Այսպիսով, հնարավորություն ուղղակի կապտվյալների բազան բացակայում է. բոլորը, ովքեր նայեցին 1C տվյալների բազան SQL սերվերի վրա, տեսան, որ դժվար է դա պարզել այնպիսի աղյուսակների զանգվածում, ինչպիսիք են aaa1, aaa2: Իսկ աղյուսակների և դաշտերի նման անուններով հարցումներ կառուցելն ուղղակի անիրատեսական է: Բացի այդ, շատ 1C աղյուսակներ (հատկապես ամենակարևորները, ինչպիսիք են վերջինի կտրվածքը, մնացորդները և պտույտները) վիրտուալ են և ցրված են տարբեր ֆիզիկական աղյուսակներում՝ հավաքվելով բազմաթիվ միացումներով: Այս մեթոդը հարմար չէ:
1C հարթակն ապահովում է COM կապի միջոցով դրան միանալու հնարավորություն։ Ինչպես շատ windows ծրագրեր, 1C-ի տեղադրման ժամանակ համակարգում գրանցվում են երկու COM օբյեկտներ՝ Automation Server և COM Connector: Դուք կարող եք աշխատել երկու օբյեկտների հետ՝ օգտագործելով COM տեխնոլոգիան աջակցող լեզու:
Automation Server օբյեկտը 1C հավելված է, որը գրեթե չի տարբերվում սովորական հաճախորդի հավելվածից: Տարբերությունն այն է, որ բացի այդ կա հավելվածի օրինակի ծրագրային վերահսկման հնարավորություն։ COM Connector օբյեկտի հետ աշխատելիս գործարկվում է 1C հավելվածի թեթև տարբերակը, որի ձևերը հասանելի չեն, ինչպես նաև ինտերֆեյսի և տեսողական էֆեկտների հետ կապված գործառույթներն ու մեթոդները: Հավելվածն ինքնին սկսվում է «Արտաքին կապ» ռեժիմում: Գլոբալ փոփոխականների սկզբնավորումը (օրինակ՝ ընթացիկ օգտագործողի և նրա կարգավորումների որոշումը) պետք է իրականացվի 1C արտաքին կապի մոդուլում: Եթե արտաքին կապի ռեժիմում կոդում կանչվի մի ֆունկցիա, որը հասանելի չէ այս ռեժիմում, բացառություն կհայտնվի (որը կփոխանցվի մեր python սկրիպտին): Անվտանգ գործառույթներին ուղղված զանգերը պետք է շրջանակված լինեն ձևի կոնստրուկցիաներով
#If NOT OuterConnection Ապա Զգուշացում («Բարև!»); #ՎերջԵթե
Քանի որ COM օբյեկտների հետ աշխատելը միայն Windows-ի համար նախատեսված տեխնոլոգիա է, զարմանալի չէ, որ այն ներառված չէ ստանդարտ Python բաշխման մեջ: Ձեզ անհրաժեշտ կլինի տեղադրել ընդլայնում` մոդուլների մի շարք, որոնք ապահովում են բոլորը ցանկալի ֆունկցիոնալություն Windows-ի ծրագրավորման համար Python-ում: Այն կարելի է ներբեռնել որպես արդեն հավաքված exe տեղադրող: Ընդլայնումն ինքնին ապահովում է մուտք դեպի ռեեստր, ծառայություններ, ODBC, COM օբյեկտներ և այլն: Որպես այլընտրանք, դուք կարող եք անմիջապես տեղադրել ActiveState Python բաշխումը, որտեղ Win32 ընդլայնումը դուրս է գալիս տուփից:
Որոշ ժամանակ փորձեր էի անում COM կապով վեբ հավելվածների, մասնավորապես՝ անձնական հաշվի մշակման մեջ։ Բացահայտվել են հետևյալ թերությունները.
COM կապը դանդաղ է: Ցածր կատարումը COM տեխնոլոգիայի հայտնի մինուսն է:
- 1C-ի հետ կապ հաստատելու գործընթացը, կախված կոնֆիգուրացիայից, կարող է տևել 1-ից 8 վայրկյան (իմ դեպքում՝ 6 վայրկյան): Ավելորդ է ասել, որ յուրաքանչյուր հարցման համար կապ հաստատելը կհանգեցնի նրան, որ յուրաքանչյուր էջ կբեռնվի 8 վայրկյանում:
- Քանի որ python վեբ հավելվածներն աշխատում են որպես անկախ սերվերներ, նախորդ կետը կարելի է փոխհատուցել՝ կապը պահելով որոշ գլոբալ փոփոխականում և վերականգնելով այն սխալի դեպքում։ Ինչպես պահպանել կապը PHP-ում, ես, անկեղծ ասած, դեռ չեմ մտածել:
- Կորած միջպլատֆորմային վեբ հավելված:
Ելնելով վերը թվարկված կետերից՝ որոշվեց փոխել փոխազդեցության սկզբունքը՝ այն բաժանելով 2 մասի՝ առաջինը՝ կախված հարթակից (Windows), բեռնաթափելով 1C տվյալները ցանկացած հարմար ձևաչափով, իսկ երկրորդը՝ հարթակից անկախ, որը կարող է. աշխատել տվյալների հետ՝ սկզբունքորեն չկասկածելով 1C-ի մասին:
Գործողությունների ռազմավարությունը հետևյալն է՝ python սկրիպտը միանում է 1C-ին, կատարում է անհրաժեշտ հարցումները և տվյալները վերբեռնում SQLite տվյալների բազա։ Դուք կարող եք միանալ այս տվյալների բազային Python-ից, PHP-ից, Java-ից: Մեր նախագծերի մեծ մասը python-ում է, և քանի որ ես ատում եմ ձեռքով չմշակված SQL հարցումներ գրելը, SQLite տվյալների բազայի հետ ամբողջ աշխատանքը կատարվում է SQLAlchemy ORM-ի միջոցով: Անհրաժեշտ էր միայն նկարագրել տվյալների բազայի կառուցվածքը դեկլարատիվ ոճով.
sqlalchemy.ext.declarative import declarative_base-ից sqlalchemy import Column, Integer, Numeric, DateTime, Unicode, Boolean, LargeBinary, ForeignKey Base = declarative_base() դասի Abonent(Base). Ճիշտ է) հաշիվ = Column(Unicode(32), index=True) կոդը = Column(Unicode(32)) հասցե = Column(Unicode(512)) fio = Column(Unicode(256)) աղբյուր = Column(Unicode(16)) ) psu = Column(Unicode(256)) tso = Column(Unicode(256)) np = Column(Unicode(256)) փողոց = Column(Unicode(256)) տուն = Column(Integer) flat = Column(Integer) mro = Column(Unicode(256)) դաս Վճարում(Base): __tablename__ = "payments" # և այլն...
Այժմ բավական է ներմուծել այս մոդուլը ցանկացած python նախագծի մեջ, և կարող եք աշխատել տվյալների հետ։
Ես կանխատեսում եմ ձեր հարցը՝ «ինչու՞ SQLite»: Հիմնական պատճառն այն է, որ տվյալների բազան անհրաժեշտ է միայն կարդալու համար, ուստի մենք չպետք է անհանգստանանք SQLite-ում գրելու հետ կապված խնդիրներից: Երկրորդ, այս DBMS-ի ձևաչափը հարմար է. ավելի հարմար է դիտել այն (շատ են անվճար կոմունալ ծառայություններ, ներառյալ FireFox-ի սուպեր ընդլայնումը): Երրորդ, որոշ դեպքերում պահանջվում էր մուտք գործել բաժանորդներ այն մեքենաներից, որոնց վրա կապ չկա MySQL սերվերի հետ: Այս դեպքում բավական է պատճենել SQLite տվյալների բազայի ֆայլը, և այս մեքենայի վրա դուք մուտք կունենաք բոլոր տեղեկատվությանը:
Բեռնաթափումը տեղի է ունենում օրը մեկ անգամ՝ գիշերը։ Տվյալների մուտքագրումը 1C-ում կարող է ավտոմատացվել նույն կերպ: Օրինակ, պահանջվում է գրանցել բաժանորդների թողած ընթերցումները անձնական հաշվի կայքում: Այս դեպքում մենք կրկին միանում ենք 1C-ին և ծրագրային ձևով ստեղծում և իրականացնում «Ցուցմունքներ վերցնելու ակտ» փաստաթուղթը։ Ես կներկայացնեմ կոդը ստորև:
Python-ում COM օբյեկտների հետ աշխատելը մի փոքր անսովոր է: Նախ, կոդի «pythonicity» կորել է. 1C-ում փոփոխականների և գործառույթների անվանման կանոնները, մեղմ ասած, չեն համապատասխանում Python-ի Zen-ին: Երկրորդ, բոլորը գիտեն, որ 1C օբյեկտները հաճախ կոչվում են կիրիլյան նիշեր, որոնք խնդիրներ կառաջացնեն Python-ում զարգանալիս... բայց դրանք լուծելի են։ Առաջարկում եմ դիտել կոդը.
Ներմուծել pythoncom ներմուծում win32com.client V82_CONN_STRING = "Srvr=v8_server;Ref=v8_db;Usr=username;Pwd=megapass;" pythoncom.CoInitialize() V82 = win32com.client.Dispatch("V82.COMConnector").Connect(V82_CONN_STRING)
Ինչպես երևում է ծածկագրից, հաճախորդը սկզբնավորվել է 1C-ով աշխատելու համար: COM օբյեկտը սահմանվում է «V82.COMConnector» անունով: Խնդրում ենք նկատի ունենալ, որ այս անունը վավեր է V8.2 հարթակի համար, եթե ունեք 8.1 տարբերակ, ապա անունը կլինի «V81.COMConnector»:
Նախաստորագրված հաճախորդի վրա մենք կանչում ենք Connect() մեթոդը՝ փոխանցելով այն կապի տողը: Տողը բաղկացած է սերվերի անունից, տվյալների բազայից, օգտվողից և գաղտնաբառից: Ստացված V82 օբյեկտը պահպանում է կապը 1C հավելվածին: Այն չունի Disconnect() մեթոդ կամ նման բան: Բազայից անջատվելու համար բավական է del () ֆունկցիայի միջոցով հեռացնել օբյեկտը հիշողությունից կամ փոփոխականը վերագրել None-ին։
Ունենալով օբյեկտ՝ կարող եք մուտք գործել 1C գլոբալ համատեքստի ցանկացած դաշտ և մեթոդ, գործել ունիվերսալ օբյեկտներով, ինչպիսիք են TabularDocument, TableValues և այլն: Կարևոր է նշել, որ COM կապի միջոցով աշխատելիս 1C-ն աշխատում է «Արտաքին կապ» ռեժիմով: Այն չունի որևէ հատկանիշ ինտերակտիվ աշխատանք, ինչպիսիք են թռուցիկ պատուհանները, ծանուցումները և ամենակարևորը՝ ձևաթղթերը: Համոզված եմ, որ դուք անիծելու եք կոնֆիգուրացիայի մշակողներին մեկից ավելի անգամ՝ փաստաթղթի ձևի մոդուլում Button1Press() ընթացակարգի ամենակարևոր գործառույթը փաթաթելու համար:
Եկեք խոսենք այնպիսի կարևոր բանի մասին, ինչպիսին է կիրիլյան ատրիբուտները: Չնայած այն հանգամանքին, որ 1C-ը երկլեզու միջավայր է, և յուրաքանչյուր ռուսերեն մեթոդի համար կա անգլերեն համարժեք, վաղ թե ուշ ձեզ հարկավոր կլինի դիմել կիրիլյան հատկանիշին: Եթե PHP-ում կամ VBSCript-ում դա որևէ խնդիր չի առաջացնի,
Սահմանել Con = CreateObject("v81.COMConnector") Սահմանել v8 =Con.Connect("Connection string") Set AccountsManager = v8.Documents.Accounts.... Սահմանել AccountsRecord= AccountsManager.CreateItem() AccountsRecord.Account = ... .... AccountsWrite.Write()
Այնուհետև python կոդը պարզապես կխափանվի շարահյուսական սխալով: Ինչ անել? Խմբագրե՞լ կազմաձևը Ոչ, պարզապես օգտագործեք getattr և setattr մեթոդները: Այս գործառույթներին COM օբյեկտ փոխանցելով և Կիրիլյան անունհատկանիշ, դուք կարող եք ստանալ և սահմանել արժեքներ, ըստ այդմ.
#coding=cp1251 catalog = getattr(V82.Catalogs, «Personal Accounts»)
Հետևյալը կարևոր է. ատրիբուտների անունները, ինչպես նաև ֆունկցիաների և մեթոդի պարամետրերը պետք է փոխանցվեն cp1251 կոդավորման մեջ: Ուստի նախապես կոդավորման շփոթությունից խուսափելու համար իմաստ ունի այն հայտարարել ֆայլի սկզբում՝ #coding=cp1251։ Դրանից հետո դուք կարող եք փոխանցել տողերը՝ առանց անհանգստանալու դրանց կոդավորման մասին: Բայց! 1C-ից ստացված բոլոր տողերը (ֆունկցիայի կանչերի արդյունքները, հարցումները) կկոդավորվեն UTF-8-ում:
Կոդի օրինակ, որը հարցում է կատարում 1C միջավայրում, կրկնում է արդյունքի վրա և պահպանում տվյալների բազան SQLite-ում.
#coding=cp1251 q = """ SELECT PersonalAccounts.Code AS code, PersonalAccounts.Building.Location.Name + ", " + PersonalAccounts.ShortAddress AS հասցե, PersonalAccounts.Subscriber.Name AS fio, PersonalAccounts,ParsonAccounts.AS EXPRESS(CharacteristicsPersonalAccountsSliceLast.Value AS Directory.Territorial GridOrganizations).Name AS tso, PersonalAccounts.Building.Settlement.Name AS np,PersonalAccounts.Building.StreetAs.AscountersAcount. Զգեստներ: Ռետոր: Անունը որպես տեղեկատու գրքույկից: Քիչ ապացույց՝ որպես ռեգեստների ձախ միացման դեմքի հաշիվ: Ազդանշանի բնութագրերը: Կրքոտ (, վիդիբնութագրեր = արժեք (տեղեկատու գրքույկ. Տեսանյութի ձևավորված կազմակերպություն)) որպես բնութագրեր որոնիչները: = V82.NewObject( «Հարցում», ք) ընտրություն = հարցում. Կատարել().Ընտրեք() CONN = db.connect() CONN.query(models.Abonent).ջնջել() իսկ ընտրությունը.Հաջորդ(): abonent = models.Abonent() abonent.account = selection.code.strip() abonent.code = selection.code abonent.fio = selection.fio abonent.address = selection.հասցե abonent.psu = selection.psu abonent.tso = selection.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()
Այստեղ CONN-ը SQLite տվյալների բազայի հետ կապի նիստն է: Ստեղծվում է հարցման օբյեկտ, լրացվում է դրա տեքստը: Ինչպես նշվեց վերևում, հարցման տեքստը պետք է լինի cp1251, որի համար նախապես հայտարարված է կոդավորումը: Հարցումը կատարելուց հետո բոլոր բաժանորդները ջնջվում են տվյալների բազայում, որպեսզի կրկնօրինակներ չավելացվեն, այնուհետև դրանք ավելացվում են ցիկլով և հետևում է վերջնական commit-ը:
Հարցումների հետ աշխատելիս ես հայտնաբերեցի հետևյալ կանոնները.
Դաշտերը ընտրելիս նրանց լատիներեն անուններ տվեք, շատ ավելի հարմար կլինի դրանց մուտք գործել ընտրիչի միջոցով (կետ), getattr(-ի) փոխարեն։
- Ընտրեք միայն պարզունակ տվյալների տեսակները՝ տողեր, թվեր, ամսաթվեր և բուլյաններ: Երբեք մի ընտրեք հղումներ դեպի օբյեկտ (փաստաթուղթ, գրացուցակ): Այս համատեքստում դուք բացարձակապես հղումների կարիք չունեք և նույնիսկ վնասակար եք, քանի որ հղումի հատկանիշին կամ մեթոդին ցանկացած մուտք կհանգեցնի COM կապի միջոցով հարցում: Եթե դուք մուտք գործեք կապի ատրիբուտները հանգույցով, այն չափազանց դանդաղ կլինի:
- Եթե ընտրեք Ամսաթիվ դաշտ, այն կվերադարձվի որպես PyTime օբյեկտ: Սա հատուկ տվյալների տեսակ է COM կապի վրա ամսաթիվը/ժամը փոխանցելու համար: Դրա հետ աշխատելն այնքան էլ հարմար չէ, որքան սովորական ամսաթիվը: Եթե այս օբյեկտը փոխանցեք int(-ին), ապա կվերադարձվի ժամանակի դրոշմակնիք, որից հետո կարող եք ստանալ datetime՝ օգտագործելով fromtimestamp() մեթոդը:
Հիմա եկեք տեսնենք, թե ինչպես են ձևավորվում տպագիր փաստաթղթերը: Փաստն այն է, որ սպառողին պետք է հնարավորություն տալ ներբեռնել նախապես պատրաստված փաստաթղթերը, օրինակ՝ վճարման անդորրագիրը կամ հաշտության ակտը։ Այս փաստաթղթերը ստեղծվում են 1C-ում՝ սահմանված պահանջներին համապատասխան, Python-ում դրանց իրականացումը շատ ժամանակ կխլի։ Հետևաբար, ավելի լավ է փաստաթղթեր ստեղծել 1C-ում և պահպանել դրանք excel ձևաչափով.
Այսպիսով, հաշտեցման ակտը ձևավորվում է հատուկ արտաքին մշակմամբ։ Նրանց համար, ովքեր ծանոթ չեն 1C տերմինաբանությանը, վերամշակումը ինքնավար ծրագիր է, որն ունի իր սեփական մոդուլը, ձևերը, ձևանմուշները, որոնք նախատեսված են 1C միջավայրում աշխատելու համար: Անհրաժեշտ է նախաստորագրել մշակումը, լրացնել դրա մանրամասները և զանգահարել գործառույթ, որը մեզ կվերադարձնի աղյուսակային փաստաթուղթ, որը նախատեսված է 1C-ում դիտելու համար: Այս փաստաթուղթը պետք է պահվի Excel ձևաչափով և պատճենվի սերվերում կամ գրվի տվյալների բազայում:
Հղում = getattr(V82.Catalogs, «SystemReports»).FindByDescription(«Elen's Verification Act») nav_url = V82.GetURL(link, «Report») name = V82.ExternalReports.Connect(nav_url) ExternalReport = V82.Ex: (անուն) setattr(ExternalReport, «Personal Account», հղում) table_doc = ExternalReport.GetDoc() ուղի = V82.GetTempFileName(«xls») table_doc.Write(ուղիղ, V82 .SpreadsheetDocumentFileType report.XLS) հաշվետվություն =( .account = reference.Code.strip() report.type = u"act" report.document = open(path, "rb").read() CONN.add(report)
Վերոնշյալ հատվածն անում է հետևյալը. Փաստաթուղթը ձևավորող մշակումը միացված է: Մշակումը կարող է ներկառուցվել կոնֆիգուրացիայի մեջ, պահվել սկավառակի վրա կամ 1C տվյալների բազայում (ինչ-որ գրացուցակում): Քանի որ մշակումը հաճախ փոխվում է, որպեսզի ամեն անգամ կոնֆիգուրացիան չթարմացվի, ամենահաճախ փոփոխվող մշակումը պահվում է «ReportsSystem» գրացուցակում՝ «արժեքի պահեստավորում» տեսակի ատրիբուտում՝ «Report» անունով: Մշակումը կարող է սկզբնավորվել՝ այն բեռնաթափելով տվյալների բազայից սկավառակ և բեռնելով այն, կամ GetURL() մեթոդով, որին պետք է հղում փոխանցել գրացուցակի տարրին և հատկանիշի անունը։ Մենք վերագրում ենք ատրիբուտների արժեքներ ստացված մշակման օբյեկտին, կանչում ենք արտահանված GetDoc() ֆունկցիան և ստանում աղյուսակի փաստաթուղթ, որը պահվում է ժամանակավոր Excel ֆայլում: Այս ֆայլի բովանդակությունը գրված է SQlite տվյալների բազայում:
Վերջին բանը, որ մնում է դիտարկել, տվյալների ծրագրային մուտքագրումն է 1C: Ենթադրենք, որ պահանջվում է ցուցումներ մուտքագրել բաժանորդներից։ Դա անելու համար բավական է ստեղծել և վարել «Ապացույցներ վերցնելու ակտ» փաստաթուղթը.
#coding=cp1251 acts = getattr(V82.Documents, "Act of Act of Action Testimonies") act = acts.CreateDocument() setattr(act, "Indication", 1024.23) setattr(act, "Bubscriber", "Ivanov") # Լրացում այլ մանրամասներով...գործել.Գրել()
Այժմ տվյալների մուտքագրումը ավտոմատացված է:
Այսպիսով, ես ուրվագծեցի մի մեթոդ, որը հիմնված է ծրագրային կերպով տվյալների վերբեռնման և ներբեռնման վրա՝ օգտագործելով COM կապը: Այս մեթոդը հաջողությամբ գործում է իմ կազմակերպությունում արդեն գրեթե մեկ տարի։ 1C-ից ձևավորված բազան սպասարկում է 3 վճարային համակարգեր, ինտերնետ էքվայրինգ (քարտերով վճարում ինտերնետի միջոցով), ինչպես նաև անձնական հաշիվ։ Բացի այդ, տարբեր սկրիպտներ միացված են տվյալների շտեմարանին՝ ռեժիմն ավտոմատացնելու համար:
Չնայած մեթոդի թերություններին (COM կապի դանդաղ արագություն), ընդհանուր առմամբ, այն կայուն է գործում։ Մենք ունենք տվյալներ հարթակից անկախ ձևով (SQLite), որոնց հետ կարելի է աշխատել ցանկացած լեզվից: Իսկ կոդի հիմնական մասը գրված է Python-ով, ինչը նշանակում է, որ հասանելի են բազմաթիվ գործիքներ և տեխնիկա, որոնց մասին նույնիսկ չես կարող երազել 1C-ում:
Սա մեկն է հնարավոր ուղիներըփոխազդեցություն 1C-ի հետ: Համոզված եմ, որ այն նոր չէ և հավանաբար արդեն ինչ-որ մեկի կողմից փորձարկված ու օպտիմալացված է։ Այնուամենայնիվ, ես փորձեցի հնարավորինս շատ մանրամասներ ներկայացնել գործընթացի մասին, որպեսզի փրկեմ ձեզ այն որոգայթներից, որոնց վրա ես ինքս ոտք դրեցի:
Բոլորիդ հաջողություն եմ մաղթում և հիշեք, որ 1C-ն այնքան էլ սարսափելի չէ, որքան նկարված է:
1C տվյալների բազաների միջև տվյալների փոխանակման տարբերակներից մեկը COM կապի միջոցով փոխանակումն է:
Օգտագործելով COM կապը, դուք կարող եք միանալ 1C տվյալների բազայից մյուսին և կարդալ կամ գրել տվյալներ: Դուք կարող եք օգտագործել այս մեթոդը ինչպես տվյալների բազաների հաճախորդ-սերվերի տարբերակներում, այնպես էլ ֆայլերի տվյալների բազաներում: Այս հոդվածում մենք կվերլուծենք նման միացությունների օրինակներ: Օրինակները օգտագործում են հարթակ 8.2:
Դուք կարող եք ստեղծել երկու տեսակի COM օբյեկտներ 1C հավելվածի համար: Սա V82. ԴիմումԵվ V82.COM Միակցիչ. Դեպքում V82. Դիմումգործարկվել է 1C հավելվածի գրեթե ամբողջական պատճենը: օգտագործման դեպքում V82.COM Միակցիչմի փոքր սերվերի մաս է սկսվում:
Աշխատանքի արագությունն այս դեպքում ավելի բարձր է, սակայն որոշ գործառույթներ կարող են հասանելի չլինել: Մասնավորապես, աշխատել ձևերի և ընդհանուր մոդուլների հետ, որոնց համար դրված չէ արտաքին կապերով աշխատելու հատկությունը։ Դուք հիմնականում պետք է օգտագործեք V82.COM Միակցիչև միայն ֆունկցիոնալության բացակայության դեպքում V82. Դիմում. Արագության տարբերությունը կարող է հատկապես նկատելի լինել մեծ տվյալների բազաներում։
Այսպիսով, եկեք սկսենք
- Եկեք ստեղծենք COM օբյեկտ
- Համար V82. ԴիմումՄիացում = Նոր COMObject ("V82.Application");
- Համար V82.COM ՄիակցիչՄիացում = Նոր COMObject ("V82.COMConnector");
- Եկեք ստեղծենք կապի տող
- տվյալների բազայի սերվերային տարբերակի համար ConnectionString = "Srvr = " "ServerName" ";Ref = " "BaseName" ;
- տվյալների բազայի ֆայլի տարբերակի համար ConnectionString = "File = " "PathKBase" "; Usr = Մականուն; Pwd = Գաղտնաբառ";
- Տվյալների բազայի հետ կապ հաստատելըՄիացման փորձ = Միացում: Միացում (ConnectionString); Exception Message = New MessageToUser; Հաղորդագրություն. Տեքստ = + Նկարագրություն Սխալներ() ; Հաղորդագրություն. Զեկուցել() ; Վերջ Փորձել;
- Անջատում բազայիցՄիացում = Չսահմանված;
Օբյեկտի համար V82. Դիմումպարտադիր է անջատել կապը, հակառակ դեպքում թերի նիստը կախված կմնա, որն այնուհետև պետք է ջնջվի ձեռքով: Դեպքում V82.COM ՄիակցիչԿապը ավտոմատ կերպով դադարեցվում է այն ընթացակարգի ավարտին, որով միացումը կատարվել է, և կա ևս մեկ փոքր պահ.
Այն օգտատիրոջ համար, որի հետ կապն իրականացվում է, դրա կարգավորումներում «Հաստատում խնդրեք ծրագիրը փակելիս» վանդակը պետք է անջատված լինի:
Եվ հիմա եկեք հավաքենք բոլոր ծածկագրերը միասին
Միացում = Նոր COMObject ("V82.Application"); //Միացում = New COMObject ("V82.COMConnector"); ConnectionString = "Srvr = ""Server1C"";Ref = ""MyBase""; Usr = Peter; Pwd = 123"; //ConnectionString = "File = ""С:\MyBase""; Usr = Peter; Pwd = 123";Միացման փորձ = Միացում: Միացում (ConnectionString); Exception Message = New MessageToUser; Հաղորդագրություն. Տեքստ = «Անհնար է միանալ տվյալների բազային»+ Նկարագրություն Սխալ() ; Հաղորդագրություն. Զեկուցել() ; Վերջ Փորձել; Միացում = Չսահմանված;
Միացման տեսակի համար V82. Դիմումմեթոդը կիրառվում է սկզբնապես ստեղծված COM օբյեկտի վրա և համար V82.COM Միակցիչմեթոդը կիրառվում է կապի վրա: հետագա աշխատանքը խնդրանքով գնում է ստանդարտ միջոցներ 1C. կոդում այն ունի հետևյալ տեսքը.
Հարցում = Միացում: NewObject («Հայցում»); // Համար V82.COM Միակցիչ Հարցում = Միացում: NewObject («Հայցում»); // Համար V82. Դիմում Հայց. Տեքստ = «Ընտրել | Կազմակերպությունների պաշտոններ Կոդ, | Կազմակերպությունների պաշտոններ Անուն|ԻՑ | տեղեկատու. Կազմակերպությունների պաշտոններ AS Positions of Organizations "; Արդյունք = Հայց. Կատարել (); Նմուշ = Արդյունք: Ընտրեք (); Մինչ ընտրության. Հաջորդ() Ցիկլ վերջի ցիկլ;
1C:Enterprise 8.3 տարբերակի համար ամեն ինչ մնում է անփոփոխ, բացառությամբ, որ COMO օբյեկտներ ստեղծելիս պետք է օգտագործել «V83.COMConnector»կամ V83. Դիմում.
