พิมพ์ (Ctrl+P)

หนึ่งในตัวเลือกสำหรับการแลกเปลี่ยนข้อมูลระหว่างฐานข้อมูล 1C คือการแลกเปลี่ยนผ่านการเชื่อมต่อ COM เมื่อใช้การเชื่อมต่อ COM คุณสามารถเชื่อมต่อจากฐานข้อมูล 1C หนึ่งไปยังอีกฐานข้อมูลหนึ่งและอ่านหรือเขียนข้อมูลได้ วิธีการนี้สามารถใช้ได้ทั้งในฐานข้อมูลเวอร์ชันไคลเอนต์ - เซิร์ฟเวอร์และในฐานข้อมูลไฟล์ บทความนี้จะกล่าวถึงการเชื่อมต่อประเภทนี้บนแพลตฟอร์ม 8.3

การเชื่อมต่อคอม

คุณสามารถสร้างวัตถุ COM สองประเภทสำหรับแอปพลิเคชัน 1C นี่คือการเชื่อมต่อแบบ ole V83.แอปพลิเคชัน และการเชื่อมต่อคอม V83.COMตัวเชื่อมต่อ . ในกรณีที่ V83.แอปพลิเคชันมีการเปิดตัวแอปพลิเคชัน 1C ที่เกือบจะเต็มเปี่ยม ในกรณีที่มีการใช้งาน V83.COMตัวเชื่อมต่อเปิดตัวส่วนเซิร์ฟเวอร์ขนาดเล็ก ความเร็วในการทำงานในกรณีนี้จะสูงกว่า แต่บางฟังก์ชันอาจไม่สามารถใช้งานได้ โดยเฉพาะอย่างยิ่งการทำงานกับแบบฟอร์มและโมดูลทั่วไปที่ไม่ได้ตั้งค่าคุณสมบัติการทำงานกับการเชื่อมต่อภายนอก ส่วนใหญ่คุณควรใช้ V83.COMตัวเชื่อมต่อและเฉพาะในกรณีที่ไม่มีฟังก์ชันการทำงานเท่านั้น V83.แอปพลิเคชัน. ความแตกต่างของความเร็วในการทำงานสามารถสังเกตได้ชัดเจนเป็นพิเศษบนฐานข้อมูลที่มีปริมาณมาก สำหรับแพลตฟอร์ม 8.2 ที่ใช้ V82.Application หรือ V82.COMConnector

สร้างการเชื่อมต่อ OLE

การเชื่อมต่อ = COMObject ใหม่ (“V83.Application” ) ;

สร้างการเชื่อมต่อ COM

การเชื่อมต่อ = COMObject ใหม่ (“V83.COMConnector” ) ;

สตริงการเชื่อมต่อ

//สำหรับตัวเลือกไคลเอนต์เซิร์ฟเวอร์
สตริงการเชื่อมต่อ= “Srvr = ““ชื่อเซิร์ฟเวอร์” “;อ้างอิง = “ “ชื่อฐาน” ;
//สำหรับตัวเลือกโหมดไฟล์:
สตริงการเชื่อมต่อ= “ไฟล์ = “”เส้นทาง KBase” “; Usr = ชื่อผู้ใช้; Pwd = รหัสผ่าน”;
พยายาม
การเชื่อมต่อ = การเชื่อมต่อ . เชื่อมต่อ(สตริงการเชื่อมต่อ);
ข้อยกเว้น
ข้อความ = MessageToUser ใหม่;
ข้อความ . ข้อความ = “ไม่สามารถเชื่อมต่อกับฐานข้อมูล” + คำอธิบายข้อผิดพลาด(); ข้อความ . เพื่อรายงาน();
ความพยายามสิ้นสุด ;

การตัดการเชื่อมต่อ

การเชื่อมต่อ = ไม่ได้กำหนด ;
สำหรับวัตถุ V83.แอปพลิเคชันจำเป็นต้องยุติการเชื่อมต่อ ไม่เช่นนั้นเซสชันที่ไม่สมบูรณ์จะยังคงอยู่ ซึ่งจะต้องถูกลบด้วยตนเอง ในกรณีที่ V83.COMตัวเชื่อมต่อการเชื่อมต่อจะขาดโดยอัตโนมัติเมื่อขั้นตอนการเชื่อมต่อเสร็จสิ้น และยังมีจุดเล็กๆ อีกจุดหนึ่ง สำหรับผู้ใช้ที่ทำการเชื่อมต่อจะต้องปิดการใช้งานช่องทำเครื่องหมาย "ขอการยืนยันเมื่อปิดโปรแกรม" ในการตั้งค่า

วิธีการ NewObject()

หากต้องการสร้างวัตถุใหม่ คุณสามารถใช้เมธอด NewObject() ได้ เช่น:

สำหรับ V83.COMตัวเชื่อมต่อ

ขอCOM = การเชื่อมต่อ ใหม่วัตถุ( "ขอ ") ;
โต๊ะคอม = การเชื่อมต่อ ใหม่วัตถุ( “ตารางค่า”) ;
ArrayCOM = การเชื่อมต่อ NewObject("อาร์เรย์" );
ViewCOM =Connection.NewObject

สำหรับ V83.แอปพลิเคชัน

คำขอOLE = การเชื่อมต่อ วัตถุใหม่(" ขอ ") ;
TableOLE = การเชื่อมต่อ ใหม่Object(“ตารางค่า”) ;
ArrayOLE = Connection.NewObject(“อาร์เรย์” ) ;
ViewCOM =Connection.NewObject(“UniqueIdentifier”, StringUID);

ขอCOM . ข้อความ ="เลือก
| ตำแหน่งขององค์กร รหัส
| ตำแหน่งขององค์กร ชื่อ
|จาก | สารบบตำแหน่งขององค์กร
การวางตำแหน่งขององค์กรอย่างไร”;
ผลลัพธ์ = ขอCOM. วิ่ง();
ตัวอย่าง = ผลลัพธ์ เลือก () ;
ลาก่อนการคัดเลือก ต่อไป()วงจร
เอ็นด์ไซเคิล ;
คุณยังสามารถใช้ตัวจัดการอ็อบเจ็กต์คอนฟิกูเรชัน:
DirectoryCOM = การเชื่อมต่อ ไดเรกทอรี ชื่อไดเรกทอรี;
เอกสารCOM = การเชื่อมต่อ เอกสารประกอบ ชื่อเอกสาร;
RegisterCOM = การเชื่อมต่อ ทะเบียนข้อมูล. ลงทะเบียนชื่อ ;

การรับและการเปรียบเทียบการแจงนับผ่านการเชื่อมต่อ COM

ในการเปรียบเทียบค่าขององค์ประกอบการแจงนับที่กำหนดไว้ในการกำหนดค่าจำเป็นต้องแปลงองค์ประกอบเหล่านี้เป็นประเภทดั้งเดิมประเภทใดประเภทหนึ่งซึ่งการเปรียบเทียบนั้นทำได้ง่าย ประเภทดังกล่าวอาจเป็นได้ทั้งตัวเลขหรือ ประเภทสตริง. คุณสามารถแปลงค่าขององค์ประกอบการแจงนับให้เป็นประเภทตัวเลขได้ดังนี้:

รายการแจงนับ = Connection.Directories.Directory1.FindByCode(1).Props1;

PossibleValues ​​= Enum Element.Metadata().Enum ค่า;

EnumerationElementNumber = PossibleValues.Index(PossibleValues.Find(Connection.XMLString(EnumerationElement)));

ถ้า EnumerationItemNumber = 0 ให้รายงาน ( “ค่าแจงนับ 1”);

ElseIfEnumerationItemNumber = 1 แล้วรายงาน("ค่าการแจงนับ2");

สิ้นสุดถ้า;

การดึงวัตถุผ่าน COM ด้วยตัวระบุ

ผ่านตัวจัดการวัตถุการกำหนดค่าเราได้รับวัตถุ com ตัวอย่างเช่น:
เอกสารCOM = การเชื่อมต่อ เอกสารประกอบ ชื่อเอกสาร;

จากนั้นเราจะได้รับสตริงตัวระบุที่ไม่ซ้ำ:

StringUID =การเชื่อมต่อ.สตริง ( DocumentCOM.UniqueIdentifier())

ตัวระบุ = U ใหม่ ตัวระบุเฉพาะ (StringUID);
กับ linkByIdentifier = เอกสาร[DocumentName].GetLink(ตัวระบุ);

หากคุณต้องการค้นหาวัตถุ com ตามเอกสารตามตัวระบุคุณต้องเขียนดังนี้:

WidCOM= การเชื่อมต่อ NewObject(“UniqueIdentifier”, StringUID);
LinkByIdentifier = Connection.Documents[DocumentName].GetLink(WidCOM);

สวัสดี Khabrachans!

ในบทความนี้ ฉันต้องการพูดคุยเกี่ยวกับวิธีการรวมเข้ากับแพลตฟอร์ม 1C ในองค์กรของฉัน สิ่งที่กระตุ้นให้ฉันทำเช่นนี้คือการขาดงานเกือบสมบูรณ์ ข้อมูลทางเทคนิคเกี่ยวกับธีมนี้ การอ่านบทความและรายงานต่างๆ ในหัวข้อการเชื่อมต่อ 1C กับระบบข้อมูลใดๆ คุณจะมั่นใจครั้งแล้วครั้งเล่าว่าสิ่งเหล่านี้ล้วนเป็นการตลาด การสาธิต และไม่เคยเป็นเรื่องทางเทคนิค ซึ่งสะท้อนถึงปัญหาและแก่นแท้ของการแก้ปัญหา

ฉันเตือนคุณว่าวิธีการนี้ไม่มีทางอ้างว่าเป็นสากล เนื่องจากมีการกำหนดค่า 1C มากมายและ ระบบข้อมูล, ภาษา และแพลตฟอร์ม - ยิ่งไปกว่านั้น จำนวนชุดค่าผสมที่เป็นไปได้มีมากมายมหาศาล เป้าหมายของฉันคือการสาธิตวิธีแก้ปัญหาที่เป็นไปได้วิธีหนึ่ง

ฉันเลือก Python เป็นภาษาที่จะรวมเข้ากับ 1C เหมาะอย่างยิ่งสำหรับกระบวนการอัตโนมัติ สิ่งนี้อำนวยความสะดวกด้วยความเรียบง่ายของไวยากรณ์ (รหัสถูกพิมพ์เร็วมาก) สมบูรณ์ ห้องสมุดมาตรฐาน(ความต้องการโมดูลของบุคคลที่สามน้อยกว่า) ข้ามแพลตฟอร์ม - มีความเป็นไปได้สูงที่โค้ดที่เขียนใน Linix OS จะทำงานบน Windows ได้สำเร็จ

ขั้นแรกฉันจะร่างข้อมูลที่เราจะใช้งาน องค์กรนี้เป็น บริษัท ขายพลังงานในภูมิภาคตะวันออกไกล - ให้บริการสมาชิกประมาณ 400,000 รายฐานข้อมูล 1C ขึ้นอยู่กับการกำหนดค่าที่กำหนดเอง สำหรับผู้สมัครสมาชิกแต่ละราย การชำระเงิน ค่าบริการ บริการที่ใช้และรูปแบบการคำนวณ เมตร การอ่านและข้อมูลอื่น ๆ จะถูกเก็บไว้

กาลครั้งหนึ่ง องค์กรแห่งหนึ่งมีโปรแกรมที่เขียนด้วยภาษา Delphi และใช้ MSSQL/Firebird เป็นฐานข้อมูล ในช่วงเวลาอันรุ่งโรจน์ดังกล่าว คุณสามารถเชื่อมต่อกับฐานข้อมูลโดยใช้ภาษาใดก็ได้และดำเนินการได้หลายอย่าง - เลือกสมาชิกลูกหนี้ การชำระเงินภายหลังที่ได้รับ บันทึกการอ่านเครื่องมือ จึงไม่น่าแปลกใจที่ชุดสคริปต์ที่ทำให้กิจวัตรอัตโนมัติมีการเติบโตอย่างต่อเนื่อง โปรแกรมเมอร์สามารถดำเนินการใดๆ ได้โดยไม่ต้องเปิดโปรแกรมเอง

อนิจจาเมื่อเปลี่ยนไปใช้ 1C freebie สิ้นสุดลง - ไม่สามารถเชื่อมต่อกับฐานข้อมูลโดยตรงได้อีกต่อไป โดยทั่วไปแล้ว แพลตฟอร์ม 1C นั้นแยกไม่ได้และไม่สามารถรวมเข้ากับระบบอื่นได้ดี อย่างที่พวกเขาพูดกันเธอก็มีอยู่ในตัวมันเอง เมื่อโหลดข้อมูลลงใน 1C คุณควรจำไว้ว่าการแยกข้อมูลออกจากที่นั่นไม่ใช่เรื่องง่าย แต่ในมุมมองที่องค์กรจำเป็นต้องนำระบบการชำระเงินมาใช้และ พื้นที่ส่วนบุคคลจำเป็นต้องหาวิธีแก้ปัญหาบางอย่าง

งานหลักที่ฉันเผชิญคือความสามารถในการรับข้อมูลเฉพาะอย่างรวดเร็ว บัญชีส่วนตัว- ชื่อนามสกุล ที่อยู่ อุปกรณ์วัดแสง อ่านมิเตอร์ การชำระเงิน ค่าธรรมเนียม พร้อมจัดทำเอกสาร-รายงานการกระทบยอด, ใบเสร็จรับเงิน ดังนั้นจึงไม่มีความเป็นไปได้ในการเชื่อมต่อโดยตรงกับฐานข้อมูล ใครก็ตามที่เคยดูฐานข้อมูล 1C บนเซิร์ฟเวอร์ SQL จะเห็นว่าเป็นการยากที่จะเข้าใจจำนวนตารางเช่น aaa1, aaa2 และการสร้างคิวรีด้วยชื่อตารางและฟิลด์ดังกล่าวนั้นไม่สมจริงเลย นอกจากนี้ ตาราง 1C จำนวนมาก (โดยเฉพาะอย่างยิ่งตารางที่สำคัญที่สุด เช่น ส่วนของข้อมูลล่าสุด ยอดคงเหลือ และการปฏิวัติ) เป็นแบบเสมือนและกระจัดกระจายไปตามตารางทางกายภาพต่างๆ ซึ่งรวบรวมโดยการรวมหลายรายการ วิธีนี้ไม่เหมาะ

แพลตฟอร์ม 1C ให้ความสามารถในการเชื่อมต่อผ่านการเชื่อมต่อ COM เช่นเดียวกับโปรแกรม Windows หลายโปรแกรมในระหว่างการติดตั้ง 1C วัตถุ COM สองตัวจะถูกลงทะเบียนในระบบ - เซิร์ฟเวอร์อัตโนมัติและตัวเชื่อมต่อ COM วัตถุทั้งสองสามารถทำงานได้โดยใช้ภาษาที่รองรับเทคโนโลยี COM

ออบเจ็กต์ Automation Server เป็นแอปพลิเคชัน 1C ซึ่งแทบไม่แตกต่างจากแอปพลิเคชันไคลเอ็นต์ทั่วไป ความแตกต่างคือมีโอกาสเพิ่มเติม การควบคุมโปรแกรมอินสแตนซ์ของแอปพลิเคชัน เมื่อทำงานกับวัตถุ COM Connector แอปพลิเคชัน 1C เวอร์ชันน้ำหนักเบาจะเปิดตัว ซึ่งในรูปแบบตลอดจนฟังก์ชันและวิธีการที่เกี่ยวข้องกับอินเทอร์เฟซและเอฟเฟกต์ภาพไม่พร้อมใช้งาน แอปพลิเคชันจะเริ่มต้นในโหมด "การเชื่อมต่อภายนอก" การเริ่มต้นตัวแปรโกลบอล (เช่น การกำหนด ผู้ใช้ปัจจุบันและการตั้งค่า) จะต้องดำเนินการในโมดูลการเชื่อมต่อภายนอก 1C หากอยู่ในโหมดการเชื่อมต่อภายนอก โค้ดเรียกใช้ฟังก์ชันที่ไม่พร้อมใช้งานในโหมดนี้ จะมีข้อยกเว้นเกิดขึ้น (ซึ่งจะถูกส่งผ่านไปยังสคริปต์ Python ของเรา) การเรียกไปยังฟังก์ชันที่ไม่ปลอดภัยควรถูกล้อมกรอบด้วยโครงสร้างของแบบฟอร์ม

#If ไม่ใช่ OuterJoin ให้เตือน ("สวัสดี!"); #สิ้นสุดถ้า

เนื่องจากการทำงานกับออบเจ็กต์ COM เป็นเทคโนโลยีที่ใช้เฉพาะ Windows เท่านั้น จึงไม่น่าแปลกใจที่จะไม่รวมอยู่ในการกระจาย Python มาตรฐาน คุณจะต้องติดตั้งส่วนขยาย - ชุดโมดูลที่มีฟังก์ชันการทำงานที่จำเป็นทั้งหมดสำหรับการเขียนโปรแกรมภายใต้ Windows ใน Python สามารถดาวน์โหลดเป็นตัวติดตั้ง exe ที่สร้างไว้ล่วงหน้าได้ ส่วนขยายนี้ให้การเข้าถึงรีจิสทรี บริการ ODBC วัตถุ COM ฯลฯ อีกทางเลือกหนึ่ง คุณสามารถติดตั้งการกระจาย ActiveState Python ได้ทันทีซึ่งมาพร้อมกับส่วนขยาย Win32 ทันที

ฉันได้ทดลองใช้การเชื่อมต่อ COM มาระยะหนึ่งแล้วในการพัฒนาแอปพลิเคชันเว็บ โดยเฉพาะบัญชีส่วนบุคคล ข้อเสียต่อไปนี้ถูกระบุ:

การเชื่อมต่อ COM ช้า ประสิทธิภาพต่ำเป็นข้อเสียที่รู้จักกันดีของเทคโนโลยี COM
- กระบวนการสร้างการเชื่อมต่อกับ 1C ขึ้นอยู่กับการกำหนดค่าอาจใช้เวลาตั้งแต่ 1 ถึง 8 วินาที (ในกรณีของฉัน - 6 วินาที) จำเป็นต้องพูด การสร้างการเชื่อมต่อสำหรับแต่ละคำขอจะส่งผลให้แต่ละหน้าใช้เวลาโหลด 8 วินาที
- เนื่องจากเว็บแอปพลิเคชันใน Python ทำงานเป็นเซิร์ฟเวอร์อิสระ จุดก่อนหน้าจึงสามารถชดเชยได้โดยการจัดเก็บการเชื่อมต่อในตัวแปรส่วนกลางบางตัวและกู้คืนในกรณีที่เกิดข้อผิดพลาด พูดตามตรง ฉันยังไม่ได้คิดถึงวิธีรักษาการเชื่อมต่อใน PHP เลย
- ฟังก์ชันการทำงานข้ามแพลตฟอร์มของเว็บแอปพลิเคชันหายไป

ตามประเด็นที่ระบุไว้ข้างต้น มีการตัดสินใจที่จะเปลี่ยนหลักการของการโต้ตอบโดยแบ่งออกเป็น 2 ส่วน - ส่วนแรกขึ้นอยู่กับแพลตฟอร์ม (ตามหน้าต่าง) การอัปโหลดข้อมูล 1C ในรูปแบบที่สะดวกและส่วนที่สองไม่ขึ้นอยู่กับแพลตฟอร์ม สามารถทำงานกับข้อมูลโดยไม่ต้องสงสัยอะไรเกี่ยวกับ 1C ในหลักการ

กลยุทธ์การดำเนินการมีดังนี้: สคริปต์ Python เชื่อมต่อกับ 1C ดำเนินการค้นหาที่จำเป็นและอัปโหลดข้อมูลไปยังฐานข้อมูล SQLite คุณสามารถเชื่อมต่อกับฐานข้อมูลนี้ได้จาก Python, PHP, Java โครงการส่วนใหญ่ของเราทำงานใน Python และเนื่องจากฉันไม่สามารถทนเขียนคำสั่ง SQL แบบดิบด้วยมือได้ งานทั้งหมดกับฐานข้อมูล SQLite จึงทำผ่าน SQLAlchemy ORM สิ่งที่จำเป็นต้องมีคือการอธิบายโครงสร้างข้อมูลฐานข้อมูลในรูปแบบการประกาศ:

จาก sqlalchemy.ext.declarative import declarative_base จากคอลัมน์นำเข้า sqlalchemy, จำนวนเต็ม, ตัวเลข, DateTime, Unicode, บูลีน, LargeBinary, ForeignKey Base = declarative_base() class Abonent(Base): __tablename__ = "abonents" id = Column(Integer, primary_key= True) บัญชี = คอลัมน์ (Unicode (32), ดัชนี = True) รหัส = คอลัมน์ (Unicode (32)) ที่อยู่ = คอลัมน์ (Unicode (512)) fio = คอลัมน์ (Unicode (256)) แหล่งที่มา = คอลัมน์ (Unicode (16) ) psu = คอลัมน์(Unicode(256)) tso = คอลัมน์(Unicode(256)) np = คอลัมน์(Unicode(256)) street = คอลัมน์(Unicode(256)) house = คอลัมน์(จำนวนเต็ม) flat = คอลัมน์(จำนวนเต็ม) mro = คอลัมน์ (Unicode(256)) คลาส Payment(Base): __tablename__ = "Payments" # และอื่นๆ...

ตอนนี้คุณเพียงแค่ต้องนำเข้าโมดูลนี้ไปยังโปรเจ็กต์ Python ใดก็ได้ และคุณก็สามารถทำงานกับข้อมูลได้

ฉันคาดหวังคำถามของคุณ - “ทำไมต้อง SQLite”? เหตุผลหลักคือฐานข้อมูลเป็นแบบอ่านอย่างเดียว ดังนั้นปัญหาในการเขียนไปยัง SQLite จึงไม่ต้องกังวลกับเรา ประการที่สองรูปแบบของ DBMS นี้สะดวก - ดูสะดวกกว่า (มีมากมาย สาธารณูปโภคฟรีรวมถึงส่วนขยายขั้นสูงสำหรับ FireFox) ประการที่สาม ในบางกรณี จำเป็นต้องเข้าถึงสมาชิกจากเครื่องที่ไม่ได้เชื่อมต่อกับเซิร์ฟเวอร์ MySQL ในกรณีนี้ การคัดลอกไฟล์ฐานข้อมูล SQLite ก็เพียงพอแล้ว และเครื่องนี้จะสามารถเข้าถึงข้อมูลทั้งหมดได้

การขนถ่ายเกิดขึ้นวันละครั้งในเวลากลางคืน การป้อนข้อมูลลงใน 1C สามารถทำได้โดยอัตโนมัติในลักษณะเดียวกัน ตัวอย่างเช่น จำเป็นต้องบันทึกการอ่านที่เหลือโดยสมาชิกบนเว็บไซต์บัญชีส่วนตัว ในกรณีนี้เราเชื่อมต่อกับ 1C อีกครั้งและสร้างและโพสต์เอกสาร "พระราชบัญญัติการอ่าน" โดยทางโปรแกรม ฉันจะให้รหัสด้านล่าง

การทำงานกับวัตถุ COM ใน Python นั้นค่อนข้างผิดปกติ ประการแรก "Pythonicity" ของโค้ดหายไป - กฎสำหรับการตั้งชื่อตัวแปรและฟังก์ชันใน 1C พูดง่ายๆ ก็คือไม่สอดคล้องกับ Zen of Python ประการที่สอง ทุกคนรู้ดีว่าวัตถุ 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").เชื่อมต่อ(V82_CONN_STRING)

ดังที่เห็นได้จากโค้ด ไคลเอนต์ได้รับการเตรียมใช้งานให้ทำงานกับ 1C วัตถุ COM ถูกกำหนดโดยชื่อ “V82.COMConnector” โปรดทราบว่าชื่อนี้ใช้ได้กับแพลตฟอร์ม V8.2 หากคุณมีเวอร์ชัน 8.1 ชื่อนี้จะเป็น “V81.COMConnector”

เราเรียกเมธอด Connect() บนไคลเอนต์ที่เตรียมใช้งานแล้ว โดยส่งผ่านสตริงการเชื่อมต่อ สตริงประกอบด้วยชื่อเซิร์ฟเวอร์ ฐานข้อมูล ผู้ใช้ และรหัสผ่าน วัตถุ V82 ที่ได้จะจัดเก็บการเชื่อมต่อกับแอปพลิเคชัน 1C ไม่มีเมธอด Disconnect() หรืออะไรทำนองนั้น หากต้องการตัดการเชื่อมต่อจากฐานข้อมูล เพียงลบออบเจ็กต์ออกจากหน่วยความจำโดยใช้ฟังก์ชัน del() หรือกำหนดให้กับตัวแปร None

การมีวัตถุ คุณสามารถเข้าถึงฟิลด์และวิธีการใด ๆ ของบริบทสากล 1C ดำเนินการกับวัตถุสากล เช่น TabularDocument, ValueTable เป็นต้น สิ่งสำคัญคือต้องทราบว่าเมื่อทำงานผ่านการเชื่อมต่อ COM 1C จะทำงานในโหมด "การเชื่อมต่อภายนอก" ไม่อนุญาตให้ใช้ฟังก์ชันโต้ตอบใดๆ เช่น กล่องโต้ตอบป๊อปอัป การแจ้งเตือน และที่สำคัญที่สุดคือแบบฟอร์ม ฉันแน่ใจว่าคุณจะสาปแช่งนักพัฒนาการกำหนดค่าที่ใส่ฟังก์ชันการทำงานที่สำคัญที่สุดในขั้นตอน Button1Press() ในโมดูลแบบฟอร์มเอกสารมากกว่าหนึ่งครั้ง

เรามาพูดถึงสิ่งสำคัญเช่นคุณลักษณะของซีริลลิกกันดีกว่า แม้ว่าข้อเท็จจริงที่ว่า 1C จะเป็นสภาพแวดล้อมแบบสองภาษาและสำหรับวิธีรัสเซียแต่ละวิธีก็มีอะนาล็อกภาษาอังกฤษไม่ช้าก็เร็วคุณจะต้องหันไปใช้คุณลักษณะซีริลลิก หากไม่ทำให้เกิดปัญหาใดๆ ในภาษา PHP หรือ VBSCript

ตั้งค่า Con = CreateObject("v81.COMConnector") ตั้งค่า v8 =Con.Connect("สตริงการเชื่อมต่อ") ตั้งค่า AccountsManager = v8.Documents.Accounts.... ตั้งค่า AccountsRecord= AccountsManager.CreateItem() AccountsRecord.Account = ... . .... AccountsRecord.Write()

จากนั้นโค้ด Python จะขัดข้องโดยมีข้อผิดพลาดทางไวยากรณ์ จะทำอย่างไร? แก้ไขการกำหนดค่า? ไม่ การใช้เมธอด getattr และ setattr ก็เพียงพอแล้ว โดยการส่งวัตถุ COM และชื่อซิริลลิกของแอตทริบิวต์ไปยังฟังก์ชันเหล่านี้ คุณจะได้รับและตั้งค่าตามนั้น:

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

สิ่งสำคัญต่อไปนี้: จะต้องส่งชื่อของรายละเอียดตลอดจนพารามิเตอร์ของฟังก์ชันและวิธีการในการเข้ารหัส cp1251 ดังนั้น เพื่อหลีกเลี่ยงความสับสนกับการเข้ารหัสล่วงหน้า จึงควรประกาศไว้ที่ตอนต้นของไฟล์: #coding=cp1251 จากนั้นคุณสามารถส่งผ่านสตริงได้โดยไม่ต้องกังวลกับการเข้ารหัส แต่! สตริงทั้งหมดที่ได้รับจาก 1C (ผลลัพธ์ของฟังก์ชันการโทร, แบบสอบถาม) จะเป็นการเข้ารหัส UTF-8

ตัวอย่างของโค้ดที่ดำเนินการแบบสอบถามในสภาพแวดล้อม 1C วนซ้ำผลลัพธ์และบันทึกฐานข้อมูลใน SQLite:

#coding=cp1251 q = """ เลือกบัญชีส่วนบุคคล รหัส AS รหัส บัญชีส่วนบุคคล อาคาร การชำระบัญชี ชื่อ + ”, " + บัญชีส่วนบุคคล ที่อยู่แบบสั้น AS ที่อยู่ บัญชีส่วนบุคคล ผู้สมัครสมาชิก ชื่อ AS fio บัญชีส่วนบุคคล แผนก ชื่อ AS psu, EXPRESS (ลักษณะของบัญชีส่วนบุคคล Slice of the Last. Value AS Directory. องค์กรเครือข่ายอาณาเขต) ชื่อ AS tso, บัญชีส่วนบุคคล. อาคาร. มีประชากร. ชื่อ AS np, บัญชีส่วนบุคคล. อาคาร. ถนน. ชื่อ. AS street, Personal Accounts. Building. House AS house, Personal Account a.MainRoom.RoomNumber AS flat , PersonalAccounts.Division.Parent.Name AS mro FROM Directory.PersonalAccounts AS PersonalAccounts LEFT CONNECTION RegisterInformation.CharacteristicsPersonalAccounts.Slice of the Last(, TypeCharacteristics) = VALUE(Directory.Types of Characteristics.Territorial Network Organisation)) AS CharacteristicsL PersonalAccountsSliceLast ซอฟต์แวร์ PersonalAccounts.Link = CharacteristicsPersonalAccountsSliceLast.Object """ query = V82.NewObject("Query", q) Selection = query.Execute().Choose( ) CONN = db.connect() CONN.query(models.Abonent).delete() ในขณะที่เลือก ถัดไป(): abonent = models.Abonent() abonent.account = Select.code.strip() abonent.code = การเลือก .code abonent.fio = Select.fio abonent.address = Select.address abonent.psu = Selection.psu abonent.tso = การเลือก tso abonent.source = u "ASRN" abonent.np = Select.np abonent.street = การเลือก .street abonent.house = Select.house abonent.flat = Select.flat abonent.mro = Select.mro CONN.add (abonent) CONN.commit ()

ที่นี่ CONN คือเซสชันการเชื่อมต่อกับฐานข้อมูล SQLite ออบเจ็กต์คิวรีถูกสร้างขึ้นและกรอกข้อความในออบเจ็กต์ ตามที่ระบุไว้ข้างต้น ข้อความคำขอจะต้องอยู่ใน cp1251 ซึ่งมีการประกาศการเข้ารหัสก่อน หลังจากดำเนินการตามคำขอ สมาชิกทั้งหมดจะถูกลบในฐานข้อมูลเพื่อไม่ให้เพิ่มรายการซ้ำ จากนั้นสมาชิกจะถูกเพิ่มในลูปและคอมมิตขั้นสุดท้ายจะตามมา

เมื่อทำงานกับคำขอ ฉันค้นพบกฎต่อไปนี้

เมื่อเลือกฟิลด์ ให้ตั้งชื่อเป็นตัวอักษรละติน ซึ่งจะสะดวกกว่ามากในการเข้าถึงผ่านตัวเลือก (จุด) แทนที่จะใช้ getattr()
- เลือกเฉพาะประเภทข้อมูลดั้งเดิม: สตริง ตัวเลข วันที่ และบูลีน อย่าเลือกลิงก์ไปยังวัตถุ (เอกสาร หนังสืออ้างอิง)! ในบริบทนี้ คุณไม่จำเป็นต้องมีลิงก์เลยและเป็นอันตรายด้วยซ้ำ เนื่องจากการเรียกไปยังอุปกรณ์ประกอบลิงก์หรือวิธีการใด ๆ จะส่งผลให้เกิดการร้องขอผ่านการเชื่อมต่อ COM หากคุณเข้าถึงคุณลักษณะของลิงก์แบบวนซ้ำ จะช้ามาก
- หากคุณเลือกฟิลด์ประเภท Date ฟิลด์นั้นจะถูกส่งกลับเป็นวัตถุ PyTime นี่เป็นชนิดข้อมูลพิเศษสำหรับการส่งวันที่-เวลาในการเชื่อมต่อ COM ไม่สะดวกในการทำงานเหมือนวันเวลาปกติ หากคุณส่งวัตถุนี้ไปที่ int() มันจะส่งคืนการประทับเวลา ซึ่งคุณสามารถรับวันที่และเวลาได้โดยใช้เมธอด fromtimestamp()

ตอนนี้เรามาดูกันว่าเอกสารที่พิมพ์ออกมาเป็นอย่างไร ความจริงก็คือผู้บริโภคต้องได้รับโอกาสในการดาวน์โหลดเอกสารที่เตรียมไว้ล่วงหน้า เช่น ใบเสร็จรับเงินหรือรายงานการกระทบยอด เอกสารเหล่านี้สร้างขึ้นใน 1C ตามข้อกำหนดที่กำหนดไว้ การใช้งานใน Python จะใช้เวลานาน ดังนั้นจึงเป็นการดีกว่าที่จะสร้างเอกสารใน 1C และบันทึกไว้ รูปแบบ Excel.

ดังนั้นเอกสารพระราชบัญญัติการกระทบยอดจึงถูกสร้างขึ้นโดยหน่วยงานพิเศษ การประมวลผลภายนอก. สำหรับผู้ที่ไม่คุ้นเคยกับคำศัพท์ 1C: การประมวลผลเป็นโปรแกรมแบบสแตนด์อโลนที่มีโมดูล แบบฟอร์ม เทมเพลตของตัวเอง ซึ่งออกแบบมาเพื่อทำงานในสภาพแวดล้อม 1C จำเป็นต้องเริ่มต้นการประมวลผล กรอกรายละเอียด และเรียกใช้ฟังก์ชันที่จะส่งคืนเอกสารสเปรดชีตที่มีไว้สำหรับดูใน 1C เอกสารนี้จะต้องบันทึกในรูปแบบ Excel และคัดลอกไปยังเซิร์ฟเวอร์หรือบันทึกไว้ในฐานข้อมูล

ลิงก์ = getattr(V82.Catalogs, "System Reports").FindByDescription("Ellen Reconciliation Report") nav_url = V82.GetURL(link, "Report") name = V82.ExternalReports.Connect(nav_url) ExternalReport = V82.ExternalReports สร้าง (ชื่อ) setattr(ExternalReport, "PersonalAccount", การอ้างอิง) table_doc = ExternalReport.GetDoc() path = V82.GetTempFileName("xls") table_doc.Write(path, V82 .SpreadsheetDocumentFileType.XLS) report = models.Report() รายงาน .account = Reference.Code.strip() report.type = u"act" report.document = open(path, "rb").read() CONN.add(รายงาน)

ส่วนข้างต้นทำหน้าที่ต่อไปนี้: เชื่อมต่อการประมวลผลที่สร้างเอกสารแล้ว การประมวลผลสามารถสร้างได้ในการกำหนดค่า เก็บไว้ในดิสก์หรือในฐานข้อมูล 1C (ในบางไดเร็กทอรี) เนื่องจากการประมวลผลเปลี่ยนแปลงบ่อยครั้ง เพื่อไม่ให้อัปเดตการกำหนดค่าในแต่ละครั้ง การประมวลผลที่เปลี่ยนแปลงบ่อยที่สุดจะถูกจัดเก็บไว้ในไดเร็กทอรี "รายงานระบบ" ในแอตทริบิวต์ "ที่เก็บข้อมูลค่า" ชื่อรายงาน การประมวลผลสามารถเริ่มต้นได้โดยการยกเลิกการโหลดจากฐานข้อมูลไปยังดิสก์แล้วโหลด หรือใช้เมธอด GetURL() ซึ่งคุณต้องส่งลิงก์ไปยังองค์ประกอบไดเร็กทอรีและชื่อของแอททริบิวต์ เรากำหนดค่าของรายละเอียดให้กับออบเจ็กต์การประมวลผลที่ได้รับ เรียกใช้ฟังก์ชันที่ส่งออก GetDoc() และรับเอกสารสเปรดชีตที่บันทึกลงในไฟล์ Excel ชั่วคราว เนื้อหาของไฟล์นี้ถูกเขียนไปยังฐานข้อมูล SQlite

สิ่งสุดท้ายที่ต้องพิจารณาคือการป้อนข้อมูลโดยทางโปรแกรมลงใน 1C สมมติว่าคุณต้องป้อนคำให้การจากสมาชิก ในการดำเนินการนี้ ก็เพียงพอที่จะสร้างและดำเนินการเอกสาร "พระราชบัญญัติการรับพยาน":

#coding=cp1251 acts = getattr(V82.Documents, "Act of Taking Testimony") act = acts.CreateDocument() setattr(act, "Testimony", 1024.23) setattr(act, "Subscriber", "Ivanov") # การกรอก ในรายละเอียดอื่นๆ .. act.Write()
ขณะนี้การป้อนข้อมูลเป็นแบบอัตโนมัติ

ดังนั้นฉันจึงสรุปวิธีการที่อิงจากการอัปโหลดและดาวน์โหลดข้อมูลทางโปรแกรมโดยใช้การเชื่อมต่อ 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.แอปพลิเคชัน. ความแตกต่างของความเร็วในการทำงานสามารถสังเกตได้ชัดเจนเป็นพิเศษบนฐานข้อมูลที่มีปริมาณมาก

มาเริ่มกันเลย

1. มาสร้างวัตถุ COM กัน
   • สำหรับ V82.แอปพลิเคชันการเชื่อมต่อ = COMObject ใหม่ ("V82.Application" ) ;
   • สำหรับ V82.COMตัวเชื่อมต่อการเชื่อมต่อ = COMObject ใหม่ ("V82.COMConnector" ) ;
2. มาสร้างสตริงการเชื่อมต่อกันเถอะ
   • สำหรับเวอร์ชันเซิร์ฟเวอร์ของฐานข้อมูล ConnectionString = "Srvr = " "ServerName" ";Ref = " "BaseName" ;
   • สำหรับเวอร์ชันไฟล์ของฐานข้อมูล ConnectionString = "File = " "PathKBase" "; Usr = ชื่อผู้ใช้; Pwd = รหัสผ่าน";
3. การเชื่อมต่อกับฐานข้อมูลพยายามเชื่อมต่อ = การเชื่อมต่อ เชื่อมต่อ (สตริงการเชื่อมต่อ); ข้อความข้อยกเว้น = MessageToUser ใหม่; ข้อความ. ข้อความ = + คำอธิบายข้อผิดพลาด() ; ข้อความ. เพื่อรายงาน() ; ความพยายามสิ้นสุด ;
4. กำลังตัดการเชื่อมต่อจากฐานข้อมูลการเชื่อมต่อ = ไม่ได้กำหนด ;

   สำหรับวัตถุ V82.แอปพลิเคชันจำเป็นต้องยุติการเชื่อมต่อ ไม่เช่นนั้นเซสชันที่ไม่สมบูรณ์จะยังคงอยู่ ซึ่งจะต้องถูกลบด้วยตนเอง ในกรณีที่ V82.COMตัวเชื่อมต่อการเชื่อมต่อจะขาดโดยอัตโนมัติเมื่อขั้นตอนการเชื่อมต่อเสร็จสิ้น และยังมีจุดเล็กๆ อีกจุดหนึ่ง

   สำหรับผู้ใช้ที่ทำการเชื่อมต่อจะต้องปิดการใช้งานช่องทำเครื่องหมาย "ขอการยืนยันเมื่อปิดโปรแกรม" ในการตั้งค่า

ตอนนี้เรามารวมโค้ดทั้งหมดเข้าด้วยกัน

การเชื่อมต่อ = COMObject ใหม่ ("V82.Application" ) ; //การเชื่อมต่อ = COMObject ใหม่ ("V82.COMConnector"); ConnectionString = "Srvr = " "Server1C" ";Ref = " "MyBase" "; Usr = Petya; Pwd = 123" ; //ConnectionString = "File = ""С:\MyBase""; Usr = Petya; Pwd = 123";พยายามเชื่อมต่อ = การเชื่อมต่อ เชื่อมต่อ (สตริงการเชื่อมต่อ); ข้อความข้อยกเว้น = MessageToUser ใหม่; ข้อความ. ข้อความ = "ไม่สามารถเชื่อมต่อกับฐานข้อมูลได้"+ คำอธิบายข้อผิดพลาด() ; ข้อความ. เพื่อรายงาน() ; ความพยายามสิ้นสุด ; การเชื่อมต่อ = ไม่ได้กำหนด ;

สำหรับประเภทการเชื่อมต่อ V82.แอปพลิเคชันวิธีการนี้ใช้สำหรับวัตถุ COM ที่ถูกสร้างขึ้นในตอนแรกและสำหรับ V82.COMตัวเชื่อมต่อใช้วิธีการเชื่อมต่อกับการเชื่อมต่อ ดำเนินการต่อไปตามคำร้องขอ วิธีการมาตรฐาน 1ซี ในโค้ดดูเหมือนว่านี้:

คำขอ = การเชื่อมต่อ NewObject("คำขอ" ); // สำหรับ V82.COMตัวเชื่อมต่อ คำขอ = การเชื่อมต่อ NewObject("คำขอ" ); // สำหรับ V82.แอปพลิเคชัน ขอ. ข้อความ = "เลือก | ตำแหน่งขององค์กร รหัส | ตำแหน่งขององค์กร ชื่อ|จาก | สารบบตำแหน่งขององค์กร AS ตำแหน่งขององค์กร"; ผลลัพธ์ = คำขอ วิ่ง(); ตัวอย่าง = ผลลัพธ์ เลือก() ; ลาก่อนการคัดเลือก ถัดไป() วนรอบ EndLoop ;

สำหรับเวอร์ชัน 1C:Enterprise 8.3 ทุกอย่างยังคงไม่เปลี่ยนแปลง ยกเว้นเมื่อคุณสร้างออบเจ็กต์ COM คุณต้องใช้ "ตัวเชื่อมต่อ V83.COM"หรือ "V83.แอปพลิเคชัน".

) ถูกตัอง

ในเวลาเดียวกัน ฉันได้เห็นมากกว่าหนึ่งครั้งเมื่อสิ่งพิมพ์ที่มีคะแนนไม่ถึง 10 คะแนนก็ "ถูกถอดออกไป"
ทำไมสิ่งนี้ถึงเกิดขึ้น? เห็นได้ชัดว่ามีคนชอบพวกเขาอย่างชัดเจน

นี่คือสิ่งที่ฉันกำลังพูดถึง เป็นการดีที่จะเข้าใจว่าคุณต้องการมันมากแค่ไหนโดยไม่ต้องอ่านบทความการให้คะแนนหรือประเมินอย่างไม่เป็นทางการ +/- สำหรับสิ่งที่ฉันชอบฉันจะแก้ไขด้วยวิธีนี้: มันได้รับมากเนื่องจากการจัดเรียงดวงดาวและผู้คนจำนวนมากรวมตัวกันบนเว็บไซต์และหลายคนชอบมัน คุณเองเข้าใจว่านี่เป็นเรื่องของโอกาสเพราะ ทันทีที่บทความออกไป หน้าแรกแล้วจะพบได้ก็ต่อเมื่อร้องขอเท่านั้น และทุกคนก็ลงคะแนนเสียง และเท่าที่ฉันเข้าใจ ความคิดเห็นคงที่ = การโปรโมตบทความทำให้คุณสามารถคงไว้ในหน้าหลักได้
นี่คือเหตุผลว่าทำไมพวกเขาถึงวางร้านค้าบนถนนสาธารณะ - ท้ายที่สุดแล้วสิ่งที่มักจะสำคัญไม่ใช่คุณภาพและความเกี่ยวข้องของสินค้า แต่เป็นความสามารถในการสัญจรของสถานที่ ผู้คนที่เดินมักจะซื้อของที่พวกเขาจะทิ้งในวันถัดไปเพียง เพื่อประโยชน์ของกระบวนการ นี่คือโรคที่ทุกคนรู้จักมานานแล้ว - การติดช้อปปิ้ง หรือเพียงแค่เพิ่มกระแสก็เพิ่มโอกาสของผู้ซื้อที่เหมาะสม

และข้อดีข้อเสีย... - นี่เป็นเพียงการ "ขอบคุณ" ที่สละเวลาและงานที่ใช้ไป

เหล่านั้น. เครื่องหมายลบถือเป็น "ขอบคุณ" ด้วยหรือไม่ ฉันต้องการทราบความคิดเห็นของคุณว่าควรใช้ในกรณีเช่นนี้หรือไม่ และคนอื่น ๆ คิดว่าน่าสนใจแค่ไหน? คุณควรใส่ไว้เมื่อบทความเป็นอันตราย/ไม่ดี หรือเมื่อบทความนั้นไร้ประโยชน์/ว่างเปล่าสำหรับคุณ?
ในความคิดของฉัน บทความนี้ดูเหมือนเป็นการเพิ่มเรตติ้งธรรมดาๆ เพราะ:
1. ปัญหาเกี่ยวกับประเภทที่ฉันอ้างถึงถูกผู้เขียนเพิกเฉยโดยสิ้นเชิง แม้ว่าเขาจะไม่ขี้เกียจเกินไปที่จะเขียนความคิดเห็นมากมายก็ตาม
2. มีความไม่ถูกต้องอย่างเห็นได้ชัดในบทความ: ว่ากันว่านี่เป็นวิธีเดียวเท่านั้น

V82 = COMObject ใหม่ ("V82.ComConnector"); รหัส = AccountCOM.Code;

แต่ฉันสามารถทำได้ง่ายๆ โดยใช้การประมวลผลดังนี้:

รายงาน (ฐาน. ไดเรกทอรี. คู่สัญญา. ค้นหาตามชื่อ ("LLC"). รหัส);

และทุกอย่างเรียบร้อยดี! และฉันเลือกการเชื่อมต่อ V82.ComConnector
เป็นเรื่องแปลกที่ผู้เขียนไม่สนใจเลยว่าบทความของเขามีปัญหาตามที่ได้ชี้ให้เห็น แต่เขาไม่โต้ตอบในทางใดทางหนึ่ง
3. แต่ยังมีปัญหาอยู่เมื่อข้อผิดพลาด “ไม่มีคลาส” ปรากฏขึ้น
4. แต่มีปัญหาเมื่อติดตั้ง 8.2 แล้วจึงติดตั้ง 8.1 - ลองแลกเปลี่ยนผ่าน OLE/COM ด้วยการแลกเปลี่ยน UT-BP มาตรฐาน!
5. คุณช่วยระบุการประมวลผลหลักบนไซต์ที่อนุญาตให้คุณเชื่อมต่อแบบสากลผ่าน OLE/COM เพื่อให้ผู้เริ่มต้นไม่เสียเวลา คุณเขียนให้พวกเขาได้ไหม! ยังไงก็ตาม ด้วยเหตุผลบางอย่างที่รูปของเธอปรากฏบนหน้าจอของคุณ เพราะเหตุใด? และผลก็คือ 2 คำในคุณธรรม และอีก 6 คำเบื้องหลัง

โดยทั่วไปแล้ว ฉันจะไม่ทิ้งโคลน แต่ชี้ให้เห็นช่องว่างเฉพาะ แต่ไม่มีปฏิกิริยาใดๆ หากนี่คือประสบการณ์ที่คุณกำลังแบ่งปัน แสดงว่ามีข้อผิดพลาดและไม่สมบูรณ์ในทางใดทางหนึ่ง
ประเด็นของฉันคือหากผู้เขียนมีความปรารถนาที่จะรวบรวมข้อบกพร่องทั้งหมด อย่างน้อยเขาก็สามารถรับฟังประสบการณ์ของผู้อื่นได้ และไม่แสดงความคิดเห็น สถานการณ์เกิดขึ้นทันทีเมื่อผู้ที่อ่านรู้มากกว่าผู้เขียน พวกเขาบอกเขา (บางครั้งก็ไม่ถูกต้อง) และเขาก็โต้กลับด้วย เป็นผลให้ข้อมูลทั้งหมดไม่ได้อยู่ในบทความ แต่อยู่ในความคิดเห็น! ตลก! สิ่งนี้มักจะเกิดขึ้น แต่คุณไม่จำเป็นต้องมุ่งเน้นไปที่ความจริงที่ว่าคุณต้องการสิ่งที่ดีที่สุด - ฉันแสดงสิ่งที่ดีที่สุดและคนอื่น ๆ ก็แสดงให้เห็น! รวมสิ่งนี้ไว้ในบทความแล้วมันจะคุ้มค่า ไม่ใช่ทุกคนที่สนใจอ่านการต่อสู้กันครั้งนี้

วิธีหนึ่งในการถ่ายโอนข้อมูลจากการกำหนดค่า 1C หนึ่งไปยังอีกการกำหนดค่าหนึ่งคือ การเชื่อมต่อซอฟต์แวร์โดยใช้คอม บริษัทหลายแห่งใช้ฐานข้อมูลที่แตกต่างกันหลายแห่ง ซึ่งระหว่างนั้นจะต้องมีการเชื่อมต่อและการขึ้นต่อกันบางอย่าง หากจำเป็นไม่เพียง แต่ในการถ่ายโอนข้อมูลเท่านั้น แต่ยังต้องดำเนินการประมวลผลข้อมูลบางอย่างด้วย การเชื่อมต่อ COM จะเป็นกลไกที่เหมาะสมที่สุด ความสามารถในการวิเคราะห์ข้อมูลจากฐานข้อมูล 1C อื่นมีประโยชน์สำหรับนักพัฒนาทุกคน

เราเชื่อมต่อผ่าน COM ไปยังฐานข้อมูล 1C

ในการใช้การเชื่อมต่อ COM ใน 1C จะใช้กลไกพิเศษที่เรียกว่า COMConnector ออบเจ็กต์นี้ได้รับการติดตั้งพร้อมกับแพลตฟอร์มและใช้สำหรับการสื่อสาร ฐานข้อมูล. ควรสังเกตว่าสำหรับวัตถุเวอร์ชัน 8.2 และ 8.3 ที่มีชื่อต่างกัน - "V82.COMConnector" และ "V83.COMConnector" ตามลำดับ

โปรดจำไว้ว่าระยะเวลาของการเชื่อมต่อ COM กับฐานข้อมูลนั้นต้องเสียสิทธิ์การใช้งาน - อย่าดำเนินการกับการเชื่อมต่อหลายรายการพร้อมกัน นี่เป็นสิ่งสำคัญอย่างยิ่งสำหรับองค์กรที่มีใบอนุญาตจำนวนจำกัด ปัญหานี้สามารถแก้ไขได้โดยใช้ งานประจำดำเนินการเมื่อไม่มีการเชื่อมต่อผู้ใช้ที่ใช้งานอยู่ในฐานข้อมูล

เพื่อให้สามารถเชื่อมต่อกับฐานข้อมูลอื่นและขอข้อมูลที่จำเป็นได้ คุณต้องทราบข้อมูลต่อไปนี้:

1. เป็นประเภทใด - ไฟล์หรือไคลเอนต์ - เซิร์ฟเวอร์
2. มันตั้งอยู่ที่ไหน;
3. คุณสามารถใช้ชื่อและรหัสผ่านใดในการเข้าสู่ระบบ?
4. คุณสนใจข้อมูลอะไรบ้าง?

จากสามจุดแรก เพื่อใช้การเชื่อมต่อ COM คุณต้องสร้างสตริงของพารามิเตอร์ มันจะแตกต่างกันไปขึ้นอยู่กับประเภทของความปลอดภัยของข้อมูล รูปร่าง. เมื่อใช้สตริงที่ได้รับ จะทำการเชื่อมต่อด้วยความช่วยเหลือซึ่งคุณสามารถรวบรวมข้อมูลจากฐานข้อมูลอื่นเพื่อการวิเคราะห์และประมวลผลโดยใช้วิธีใดก็ได้

พารามิเตอร์การเชื่อมต่อFileIB = "File=""Path_to_database""; Usr=""User_name"";Pwd=""Password"""; พารามิเตอร์การเชื่อมต่อClientServerIB = "Srvr=""Server_Name""; Ref=""Database_Name""; Usr=""User_Name""; Pwd=""Password""";

ฟังก์ชั่นการเชื่อมต่อนั้นเรียบง่ายและไม่ควรทำให้เกิดคำถามใดๆ หากระบุพารามิเตอร์ทั้งหมดอย่างถูกต้อง เพื่อเร่งการดีบักและการวิเคราะห์ ข้อผิดพลาดที่เป็นไปได้เป็นการดีกว่าที่จะรวมการเชื่อมต่อไว้ในโครงสร้าง "ลอง" ฟังก์ชันจะส่งกลับค่าประเภท "วัตถุ COM" ซึ่งคุณจะทำงานเพื่อรับข้อมูลที่จำเป็น

&ฟังก์ชัน OnServer ConnectToBase() พารามิเตอร์ ExportConnectionIB = "File=""E:\1c Database\ERP""; Usr=""Administrator"";Pwd=""1"""; V83COMCon= COMObject ใหม่ ("V83.COMConnector"); พยายามส่งคืน V83COMCon.Connect (พารามิเตอร์การเชื่อมต่อ IB); รายงานข้อยกเว้น (คำอธิบายข้อผิดพลาด ()); กลับไม่ได้กำหนด; สิ้นสุดความพยายาม; EndFunction

ด้วยการเชื่อมต่อ COM คุณไม่เพียงสามารถเลือกข้อมูลได้ แต่ยังเพิ่มลงในฐานข้อมูลที่คุณกำลังเชื่อมต่อด้วย โปรดจำไว้ว่าเราสามารถถ่ายโอนข้อมูลดั้งเดิม 4 ประเภทผ่านวัตถุ COM จะต้องระบุประเภทอื่นๆ โดยใช้ฟังก์ชันการค้นหาในตัวของแพลตฟอร์ม โปรดทราบว่าฟังก์ชั่นแพลตฟอร์มระดับโลกนั้นเรียกผ่านการเชื่อมต่อ COM เช่นกัน

เราได้รับข้อมูลจากฐานข้อมูล 1C

หลังจากที่คุณได้รับออบเจ็กต์ที่ต้องการแล้ว คุณจะต้องอ่านข้อมูลจากฐานข้อมูลอื่น ในการดำเนินการนี้เราใช้คำขอผ่านการเชื่อมต่อ COM ใน 1C 8.3 โดยใช้ค่าที่ได้รับประเภท "วัตถุ COM" จากฟังก์ชัน สิ่งสำคัญคือต้องเชื่อมต่อกับฐานข้อมูลก่อนแล้วจึงดำเนินการตามคำขอ การดำเนินการเกิดขึ้นผ่านวิธี NewObject โดยระบุประเภทวัตถุในรูปแบบสตริงเป็นพารามิเตอร์ - "คำขอ"

&ขั้นตอน OnServer TestCOMOnServer() การเชื่อมต่อ = ConnectToBase(); ถ้า TypeValue(การเชื่อมต่อ) พิมพ์("ไม่ได้กำหนด") ดังนั้น RequestBPZO = Connection.NewObject("คำขอ"); RequestBPZO.Text = "SELECT 15 แรก | DirectoryUser.Name AS Name |FROM | Directory.users AS DirectoryUser"; เลือก = RequestBPZO.Execute().select(); ในขณะที่ Selection.next() รายงานลูป (Selection.Number); สิ้นสุดรอบ; สิ้นสุดถ้า; สิ้นสุดขั้นตอน >

ตัวอย่างเช่น หากต้องการรับข้อมูลเกี่ยวกับผู้ใช้ของแผนกใดแผนกหนึ่ง เราจะกำหนดเงื่อนไขในคำขอผ่านพารามิเตอร์ พารามิเตอร์หนึ่งจะเป็นประเภทธรรมดา - สตริงและส่วนจะเป็นลิงก์ไปยังองค์ประกอบไดเร็กทอรี "โครงสร้างองค์กร" ผลลัพธ์ของแบบสอบถามคือตารางที่มีเขตข้อมูลที่แสดงอยู่ในประเภทที่มีอยู่ในฐานข้อมูลที่เกิดการเชื่อมต่อ COM หากคุณต้องการแปลงเป็นประเภทอื่น ให้ใช้ฟังก์ชันแพลตฟอร์มมาตรฐาน:

• เส้น();
• ตัวเลข();
• วันที่()

RequestBPZO = Connection.NewObject("คำขอ"); RequestBPZO.Text = "SELECT 15 แรก | DirectoryUser.Name AS Name | FROM | Directory.Users AS DirectoryUser I WHERE | DirectoryUser.Department = &RequiredDepartment | And DirectoryUser.Name like ""%"" + &RequiredName+ ""%""" ; คำขอ BPZO.SetParameter("Required Department", Connection. Directories. Enterprise Structure. Find By Code("00-000023")); RequestBPZO.SetParameter("RequiredName", "Ekaterina"); เลือก = RequestBPZO.Execute().select(); ในขณะที่ Selection.next() รายงานลูป (Selection.Name); สิ้นสุดรอบ;

หากคุณต้องการถ่ายโอนอาร์เรย์ไปยังฐานข้อมูลเพื่อเลือกตามพารามิเตอร์หลายตัว เช่น แผนก คำสั่ง NewObject ก็จะถูกใช้งานเช่นกัน ในทำนองเดียวกัน คุณสามารถส่งรายการหรือตารางค่า โดยเติมองค์ประกอบของฐานข้อมูลอื่นผ่านการเชื่อมต่อได้ วิธีการวัตถุและกลไกที่มีอยู่ทั้งหมดของแพลตฟอร์มพร้อมให้คุณค้นหาได้

RequestBPZO = Connection.NewObject.("คำขอ"); RequestBPZO.Text = "SELECT 15 แรก | DirectoryUser.Name AS Name | FROM | Directory.Users AS DirectoryUser I WHERE | DirectoryUser.Department B (&NecessaryDepartment) | และ DirectoryUser.Name เช่น ""%"" + &NecessaryName+ ""%" " "; อาร์เรย์ของแผนก = Connection.NewObject("Array"); อาร์เรย์ของ Departments.Add (Connection.Directories.Enterprise Structure.Find By Code ("00-000023")); อาร์เรย์ของ Departments.Add (Connection.Directories.Enterprise Structure.Find By Code ("00-000038")); อาร์เรย์ของ Departments.Add (Connection.Directories.Enterprise Structure.Find By Code ("00-000046")); ขอ BPZO.SetParameter("Required Department", Array of Departments); RequestBPZO.SetParameter("RequiredName", "Ekaterina"); เลือก = RequestBPZO.Execute().select(); ในขณะที่ Selection.next() รายงานลูป (Selection.Name); สิ้นสุดรอบ;

เมื่อถ่ายโอนเอกสารหรือองค์ประกอบไดเร็กทอรี คำถามในการควบคุมการถ่ายโอนอ็อบเจ็กต์เฉพาะมักเกิดขึ้นเสมอ ด้วยความช่วยเหลือของการเชื่อมต่อ COM ปัญหาดังกล่าวสามารถแก้ไขได้ผ่านตัวระบุที่ไม่ซ้ำกัน คุณต้องค้นหาออบเจ็กต์ในฐานข้อมูลปลั๊กอินด้วยตัวระบุจากความปลอดภัยของข้อมูลปัจจุบันโดยใช้ฟังก์ชัน "GetLink" โดยใช้ตัวระบุเป็นสตริง หากไม่พบ คุณสามารถสร้างได้โดยใช้การเชื่อมต่อ COM

StriIdent = String(Directories.Users.FindByCode("00-0000313").UniqueIdentifier()); ถ้าไม่ใช่ ValueFilled(Connection.Directories.Users.GetLink(Connection.NewObject("UniqueIdentifier", StrIdent))) แล้ว NewUser = Connection.Directories.Users.CreateItem(); NewUser.Name = Directories.Users.FindByCode("00-0000313").ชื่อ; NewUser.Individual = Directories.Users.FindByCode("00-0000313").Individual; ผู้ใช้ใหม่.เขียน(); สิ้นสุดถ้า;

นอกจากนี้การเชื่อมต่อ COM ยังมีสิทธิ์ใช้ขั้นตอนและฟังก์ชันจากโมดูล 1C ทั่วไปที่เปิดใช้งานคุณสมบัติ "การเชื่อมต่อภายนอก" นอกเหนือจากเงื่อนไขนี้ ฟังก์ชันหรือขั้นตอนที่เรียกว่าจะต้องถูกส่งออก และไม่รวมการดำเนินการแบบโต้ตอบที่ทำบนเซิร์ฟเวอร์ มิฉะนั้น คุณจะเห็นข้อผิดพลาดเกี่ยวกับการดำเนินการที่ไม่ถูกต้อง

สารประกอบ..; VariableFunction = การเชื่อมต่อ..; การเรียกฟังก์ชัน>ชื่อโมดูลทั่วไป>การเรียกขั้นตอน>ชื่อโมดูลทั่วไป>

ความเป็นไปได้ในการเชื่อมต่อภายนอกกับฐานข้อมูลอื่นใน 1C นั้นค่อนข้างกว้างขวางและสามารถช่วยให้คุณทำงานหลายอย่างได้ สิ่งสำคัญคือต้องสามารถประเมินเครื่องมือและเลือกได้อย่างถูกต้อง ทางออกที่ดีที่สุด. ในกรณีส่วนใหญ่ทักษะนี้จะปรากฏเฉพาะเมื่อมีประสบการณ์หรือโดยการศึกษาตัวอย่างผลงานของผู้เชี่ยวชาญที่มีประสบการณ์เท่านั้น