Web2py - คู่มือฉบับย่อ
web2pyถูกกำหนดให้เป็นเฟรมเวิร์กเว็บโอเพนซอร์สฟรีสำหรับการพัฒนาที่คล่องตัวซึ่งเกี่ยวข้องกับเว็บแอปพลิเคชันที่ขับเคลื่อนด้วยฐานข้อมูล มันเขียนด้วย Python และโปรแกรมใน Python มันเป็นเฟรมเวิร์กแบบเต็มสแต็ก ประกอบด้วยส่วนประกอบที่จำเป็นทั้งหมดผู้พัฒนาจำเป็นต้องสร้างเว็บแอปพลิเคชันที่ทำงานได้อย่างสมบูรณ์
web2py กรอบเป็นไปตาม Model-View-Controller รูปแบบของการใช้งานเว็บที่แตกต่างจากรูปแบบดั้งเดิม
Modelเป็นส่วนหนึ่งของแอปพลิเคชันที่มีตรรกะสำหรับข้อมูล อ็อบเจ็กต์ในแบบจำลองใช้สำหรับการดึงและจัดเก็บข้อมูลจากฐานข้อมูล
Viewเป็นส่วนหนึ่งของแอปพลิเคชันซึ่งช่วยในการแสดงผลข้อมูลแก่ผู้ใช้ปลายทาง การแสดงข้อมูลดึงมาจาก Model
Controllerเป็นส่วนหนึ่งของแอปพลิเคชันที่จัดการการโต้ตอบของผู้ใช้ คอนโทรลเลอร์สามารถอ่านข้อมูลจากมุมมองควบคุมอินพุตของผู้ใช้และส่งข้อมูลอินพุตไปยังโมเดลที่ระบุ
web2pyมีคุณสมบัติในตัวเพื่อจัดการคุกกี้และเซสชัน หลังจากทำธุรกรรม (ในรูปแบบของ SQL) เซสชันจะถูกจัดเก็บพร้อมกัน
web2pyมีความสามารถในการรันงานตามช่วงเวลาที่กำหนดหลังจากเสร็จสิ้นการดำเนินการบางอย่าง ซึ่งสามารถทำได้ด้วยCRON.
web2py - เวิร์กโฟลว์
ดูแผนภาพเวิร์กโฟลว์ที่ระบุด้านล่าง
แผนภาพเวิร์กโฟลว์อธิบายไว้ด้านล่าง
Models, Views และ Controller ส่วนประกอบประกอบเป็นแอปพลิเคชัน web2py ของผู้ใช้
สามารถโฮสต์แอปพลิเคชันหลายรายการใน web2py เดียวกันได้
เบราว์เซอร์ส่งคำขอ HTTP ไปยังเซิร์ฟเวอร์และเซิร์ฟเวอร์โต้ตอบด้วย Model, Controller และ View เพื่อดึงเอาท์พุทที่จำเป็น
ลูกศรแสดงถึงการสื่อสารกับเอ็นจิ้นฐานข้อมูล แบบสอบถามฐานข้อมูลสามารถเขียนใน SQL ดิบหรือโดยใช้ web2py Database Abstraction Layer (ซึ่งจะกล่าวถึงในบทต่อไป) เพื่อให้web2py รหัสแอปพลิเคชันไม่ขึ้นอยู่กับเอ็นจิ้นฐานข้อมูลใด ๆ
Model สร้างการเชื่อมต่อฐานข้อมูลกับฐานข้อมูลและโต้ตอบกับไฟล์ Controller. Controller ในทางกลับกันโต้ตอบกับไฟล์ View เพื่อแสดงการแสดงข้อมูล
Dispatcherแมป URL ที่ร้องขอตามที่ระบุในการตอบสนอง HTTP กับการเรียกใช้ฟังก์ชันในคอนโทรลเลอร์ เอาต์พุตของฟังก์ชันอาจเป็นสตริงหรือตารางแฮช
ข้อมูลแสดงผลโดยไฟล์ View. หากผู้ใช้ร้องขอเพจ HTML (ค่าเริ่มต้น) ข้อมูลจะถูกแสดงในเพจ HTML หากผู้ใช้ร้องขอหน้าเดียวกันใน XML web2py จะพยายามค้นหามุมมองที่สามารถแสดงผลพจนานุกรมใน XML
โปรโตคอลที่รองรับของ web2py ได้แก่ HTML, XML, JSON, RSS, CSV และ RTF
โมเดล - ดู - คอนโทรลเลอร์
model-view-controller การเป็นตัวแทนของ web2py มีดังนี้ -
รุ่น
"db.py" is the model:
db = DAL('sqlite://storage.sqlite')
db.define_table(employee, Field('name'), Field(‘phone’))
Modelรวมถึงตรรกะของข้อมูลแอปพลิเคชัน มันเชื่อมต่อกับฐานข้อมูลดังที่กล่าวไว้ในรูปด้านบน พิจารณาว่ากำลังใช้ SQLite และเก็บไว้ในไฟล์storage.sqliteไฟล์ที่มีตารางกำหนดเป็นพนักงาน หากไม่มีตาราง web2py จะช่วยโดยการสร้างตารางตามลำดับ
ตัวควบคุม
โปรแกรม "default.py" คือ Controller.
def employees():
grid = SQLFORM.grid(db.contact, user_signature = False)
return locals()
ใน web2pyการแมป URL ช่วยในการเข้าถึงฟังก์ชันและโมดูล สำหรับตัวอย่างข้างต้น Controller มีฟังก์ชันเดียว (หรือ "การกระทำ") ที่เรียกว่าพนักงาน
การดำเนินการโดย Controller ส่งคืนสตริงหรือพจนานุกรม Python ซึ่งเป็นการรวมกันของคีย์และค่ารวมถึงชุดตัวแปรในเครื่อง
ดู
"default/contacts.html" คือ View.
{{extend 'layout.html'}}
<h1>Manage My Employees</h1>
{{=grid}}
สำหรับตัวอย่างที่กำหนด View แสดงผลลัพธ์หลังจากเรียกใช้ฟังก์ชันคอนโทรลเลอร์ที่เกี่ยวข้อง
จุดประสงค์ของสิ่งนี้ Viewคือการแสดงผลตัวแปรในพจนานุกรมซึ่งอยู่ในรูปแบบของ HTML View ไฟล์เขียนด้วย HTML แต่ฝังโค้ด Python ด้วยความช่วยเหลือของ {{ and }} ตัวคั่น
โค้ดที่ฝังลงใน HTML ประกอบด้วยโค้ด Python ในพจนานุกรม
เริ่มต้นด้วย web2py
web2py มาในแพ็คเกจไบนารีสำหรับระบบปฏิบัติการหลักทั้งหมดเช่น Windows, UNIX และ Mac OS X
ติดตั้ง web2py ได้ง่ายเพราะ -
ประกอบด้วยตัวแปล Python ดังนั้นคุณไม่จำเป็นต้องติดตั้งไว้ล่วงหน้า นอกจากนี้ยังมีเวอร์ชันซอร์สโค้ดที่ทำงานบนระบบปฏิบัติการทั้งหมด
ลิงค์ต่อไปนี้ประกอบด้วยแพ็คเกจไบนารีของ web2pyสำหรับการดาวน์โหลดตามความต้องการของผู้ใช้ - www.web2py.com
web2pyกรอบงานไม่จำเป็นต้องติดตั้งล่วงหน้าซึ่งแตกต่างจากกรอบงานอื่น ๆ ผู้ใช้ต้องดาวน์โหลดไฟล์ zip และเปิดเครื่องรูดตามความต้องการของระบบปฏิบัติการ
web2py เฟรมเวิร์กเขียนด้วย Python ซึ่งเป็นภาษาไดนามิกที่สมบูรณ์ซึ่งไม่จำเป็นต้องมีการคอมไพล์หรือการติดตั้งที่ซับซ้อนในการรัน
มันใช้เครื่องเสมือนเช่นภาษาโปรแกรมอื่น ๆ เช่น Java หรือ. net และสามารถคอมไพล์ซอร์สโค้ดที่เขียนโดยนักพัฒนาได้อย่างโปร่งใส
ระบบปฏิบัติการ | คำสั่ง |
---|---|
Unix และ Linux (การแจกจ่ายซอร์ส) | python web2py.py |
OS X (การแจกแจงแบบไบนารี) | เปิด web2py.app |
Windows (การกระจาย web2py แบบไบนารี) | web2py.exe |
Windows (แหล่งที่มาของการแจกจ่าย web2py) | c: /Python27/python.exe web2py.py |
Python สามารถกำหนดได้ว่าเป็นการผสมผสานระหว่างภาษาเชิงวัตถุและภาษาโต้ตอบ เป็นซอฟต์แวร์โอเพนซอร์ส Guido van Rossum ตั้งครรภ์งูหลามในช่วงปลายทศวรรษ 1980
Python เป็นภาษาที่คล้ายกับ PERL (Practical Extraction and Reporting Language) ซึ่งได้รับความนิยมเนื่องจากมีไวยากรณ์ที่ชัดเจนและอ่านง่าย
คุณสมบัติเด่นที่สำคัญของ Python มีดังนี้ -
กล่าวกันว่า Python นั้นค่อนข้างง่ายต่อการเรียนรู้และพกพา ข้อความสามารถตีความได้อย่างง่ายดายในระบบปฏิบัติการหลายระบบรวมถึงระบบที่ใช้ UNIXMac OS, MS-DOS, OS/2และ Windows รุ่นต่างๆ
Python พกพาได้กับระบบปฏิบัติการหลัก ๆ ทั้งหมด ใช้ไวยากรณ์ที่เข้าใจง่ายทำให้โปรแกรมต่างๆเป็นมิตรกับผู้ใช้
มาพร้อมกับไลบรารีมาตรฐานขนาดใหญ่ที่รองรับงานต่างๆมากมาย
จากแผนภาพด้านบนจะเห็นได้ชัดเจนว่า Python เป็นการรวมกันของสคริปต์และภาษาโปรแกรม มีการตีความภายในโปรแกรมอื่นเช่นภาษาสคริปต์
เวอร์ชันของ Python
Python มีการใช้งานคุณภาพการผลิตสามแบบซึ่งเรียกว่า CPython, Jython และ IronPython สิ่งเหล่านี้เรียกว่าเป็นเวอร์ชันของ Python
Classic Python aka CPython เป็นคอมไพเลอร์ล่ามและประกอบด้วยโมดูลส่วนขยายในตัวและส่วนขยายเสริมซึ่งใช้งานในภาษาซีมาตรฐาน
Jython เป็นการใช้งาน Python สำหรับ Java Virtual Machine (JVM)
IronPythonได้รับการออกแบบโดย Microsoft ซึ่งรวมถึง Common Language Runtime (CLR) เป็นที่รู้จักกันทั่วไปในชื่อ. NET
เริ่มต้นขึ้น
โปรแกรม Python พื้นฐานในระบบปฏิบัติการใด ๆ เริ่มต้นด้วยส่วนหัว โปรแกรมจะถูกเก็บไว้ด้วย.py คำสั่ง extension และ Python ใช้สำหรับรันโปรแกรม
ตัวอย่างเช่น, python_rstprogram.pyจะให้ผลลัพธ์ที่ต้องการ นอกจากนี้ยังจะสร้างข้อผิดพลาดหากมี
Python ใช้การเยื้องเพื่อคั่นบล็อกของโค้ด บล็อกเริ่มต้นด้วยบรรทัดที่ลงท้ายด้วยโคลอนและต่อไปสำหรับทุกบรรทัดในรูปแบบที่คล้ายกันซึ่งมีการเยื้องที่ใกล้เคียงกันหรือสูงกว่าเป็นบรรทัดถัดไป
# Basic program in Python
print "Welcome to Python!\n"
ผลลัพธ์ของโปรแกรมจะเป็น -
Welcome to Python!
เยื้อง
การเยื้องของโปรแกรมมีความสำคัญมากใน Python มีอคติและตำนานบางอย่างเกี่ยวกับกฎการเยื้องของ Python สำหรับนักพัฒนาที่เพิ่งเริ่มใช้ Python
กฎทั่วไปสำหรับโปรแกรมเมอร์ทุกคนคือ -
“ ช่องว่างมีความสำคัญในซอร์สโค้ด Python”
ช่องว่างชั้นนำซึ่งรวมถึงช่องว่างและแท็บที่จุดเริ่มต้นของบรรทัดตรรกะของ Python จะคำนวณระดับการเยื้องของบรรทัด
บันทึก
ระดับการเยื้องยังกำหนดการจัดกลุ่มของคำสั่ง
เป็นเรื่องปกติที่จะใช้ช่องว่างสี่ช่องเช่นแท็บสำหรับการเยื้องแต่ละระดับ
เป็นนโยบายที่ดีที่จะไม่ใช้แท็บผสมกับช่องว่างซึ่งอาจทำให้เกิดความสับสนซึ่งมองไม่เห็น
Python ยังสร้างข้อผิดพลาดเวลาคอมไพล์หากไม่มีการเยื้อง
IndentationError: expected an indented block
ควบคุมคำสั่ง Flow
ขั้นตอนการควบคุมของโปรแกรม Python ถูกควบคุมโดยคำสั่งเงื่อนไขการวนซ้ำและการเรียกใช้ฟังก์ชัน
If คำสั่งเรียกใช้บล็อกของรหัสภายใต้เงื่อนไขที่กำหนดพร้อมกับ else และ elif (การรวมกันของ else-if)
For คำสั่งวนซ้ำบนออบเจ็กต์จับแต่ละองค์ประกอบไปยังตัวแปรโลคัลเพื่อใช้โดยบล็อกที่แนบมา
While คำสั่งเรียกใช้บล็อกของรหัสภายใต้เงื่อนไขซึ่งก็คือ True.
Withคำสั่งล้อมบล็อกรหัสภายในตัวจัดการบริบท ได้รับการเพิ่มเป็นทางเลือกที่อ่านได้ง่ายขึ้นสำหรับไฟล์try/finally คำให้การ.
# If statement in Python
x = int(raw_input("Please enter an integer: ")) #Taking input from the user
if x<0:
print "1 - Got a negative expression value"
print x
else:
print "1 - Got a positive expression value"
print x
print "Good bye!"
เอาต์พุต
sh-4.3$ python main.py
Please enter an integer: 4
1 - Got a positive expression value
4
Good bye!
ฟังก์ชั่น
คำสั่งในโปรแกรม Python ทั่วไปได้รับการจัดระเบียบและจัดกลุ่มในรูปแบบเฉพาะที่เรียกว่า “Functions". ฟังก์ชันคือกลุ่มของคำสั่งที่ดำเนินการตามคำขอ Python มีฟังก์ชันในตัวมากมายและอนุญาตให้โปรแกรมเมอร์กำหนดฟังก์ชันของตนเองได้
ใน Python ฟังก์ชันคือค่าที่ได้รับการจัดการเช่นเดียวกับออบเจ็กต์อื่น ๆ ในภาษาโปรแกรม
def คำสั่งเป็นวิธีที่ใช้บ่อยที่สุดในการกำหนดฟังก์ชัน def เป็นคำสั่งประกอบประโยคเดียวที่มีไวยากรณ์ต่อไปนี้ -
def function-name (parameters):statement(s)
ตัวอย่างต่อไปนี้แสดงให้เห็นถึงฟังก์ชันเครื่องกำเนิดไฟฟ้า สามารถใช้เป็นวัตถุที่ทำซ้ำได้ซึ่งจะสร้างวัตถุในลักษณะเดียวกัน
def demo ():
for i in range(5):
yield (i*i)
for j in demo():
print j
เอาต์พุต
sh-4.3$ python main.py
0
1
4
9
16
คุณสมบัติพิเศษวิธีการและตัวดำเนินการ
แอตทริบิวต์วิธีการและตัวดำเนินการที่เริ่มต้นด้วยขีดล่างสองเท่าของคลาสมักเป็นพฤติกรรมส่วนตัว บางคำเป็นคำหลักที่สงวนไว้ซึ่งมีความหมายพิเศษ
สามรายการดังต่อไปนี้ -
__len__
__getitem__
__setitem__
ตัวดำเนินการพิเศษอื่น ๆ ได้แก่ __getattr__ และ __setattr__ ซึ่งกำหนด get และ set แอตทริบิวต์สำหรับคลาส
ไฟล์ฟังก์ชั่น I / O
Python มีฟังก์ชันในการเปิดและปิดไฟล์บางไฟล์ ซึ่งสามารถทำได้ด้วยความช่วยเหลือของopen(), write() และ close() ฟังก์ชั่น.
คำสั่งที่ช่วยในการป้อนข้อมูลและเอาต์พุตไฟล์มีดังนี้ -
ซีเนียร์ No | คำสั่งและการทำงาน |
---|---|
1 | open() ช่วยในการเปิดไฟล์หรือเอกสาร |
2 | write() ช่วยในการเขียนสตริงในไฟล์หรือเอกสาร |
3 | read() ช่วยในการอ่านเนื้อหาในไฟล์ที่มีอยู่ |
4 | close() วิธีนี้จะปิดอ็อบเจ็กต์ไฟล์ |
ตัวอย่าง
พิจารณาไฟล์ชื่อ “demo.txt”ซึ่งมีอยู่แล้วโดยมีข้อความ“ นี่คือไฟล์สาธิต”
#!/usr/bin/python
# Open a file
fo = open("demo.txt", "wb")
fo.write( "Insering new line \n");
# Close opend file
fo.close()
สตริงที่พร้อมใช้งานหลังจากเปิดไฟล์จะเป็น -
This is a demo file
Inserting a new line
web2py เป็นเว็บเฟรมเวิร์กแบบสแต็กเต็มรูปแบบที่นักพัฒนาสามารถใช้เพื่อพัฒนาเว็บแอปพลิเคชันได้อย่างสมบูรณ์ ประกอบด้วยการรวมฐานข้อมูล SQL และเว็บเซิร์ฟเวอร์แบบมัลติเธรดสำหรับการออกแบบโปรแกรม
เว็บอินเตอร์เฟสสำหรับการออกแบบโปรแกรมของผู้ใช้
เมื่อดำเนินการคำสั่งตามระบบปฏิบัติการ web2py จะแสดงหน้าต่างเริ่มต้นระบบจากนั้นแสดงวิดเจ็ต GUI ที่ขอให้ผู้ใช้เลือก -
- รหัสผ่านผู้ดูแลระบบครั้งเดียว
- ที่อยู่ IP ของอินเทอร์เฟซเครือข่ายที่จะใช้สำหรับเว็บเซิร์ฟเวอร์
- และหมายเลขพอร์ตที่จะให้บริการตามคำขอ
ผู้ดูแลระบบมีสิทธิ์ทั้งหมดในการเพิ่มและแก้ไขเว็บแอปพลิเคชันใหม่
โดยค่าเริ่มต้น web2py จะรันเว็บเซิร์ฟเวอร์บน 127.0.0.1:8000 (พอร์ต 8000 บน localhost) แต่ผู้ใช้สามารถเรียกใช้บนที่อยู่ IP และพอร์ตใดก็ได้ตามความต้องการ
วิดเจ็ต web2py GUI จะแสดงดังที่แสดงด้านล่าง
รหัสผ่านถูกใช้ในอินเทอร์เฟซการดูแลระบบสำหรับการเปลี่ยนแปลงใด ๆ ในโมดูลใหม่
หลังจากผู้ใช้ตั้งรหัสผ่านการดูแลระบบแล้ว web2py จะเริ่มต้นเว็บเบราว์เซอร์ที่หน้าด้วย URL ต่อไปนี้ - http://127.0.0.1:8000/
หน้ายินดีต้อนรับของกรอบจะแสดงดังภาพด้านล่าง
การออกแบบโปรแกรมพื้นฐานใน web2py
หลังจากเริ่มแอปพลิเคชัน web2py ด้วย URL ที่กล่าวถึงข้างต้นเราสามารถใช้อินเทอร์เฟซการดูแลระบบเพื่อสร้างโมดูลใหม่ตัวอย่างเช่น “helloWorld”.
อินเทอร์เฟซสำหรับผู้ดูแลระบบจะขอรหัสผ่านเพื่อวัตถุประสงค์ในการตรวจสอบความถูกต้องเนื่องจากผู้ดูแลระบบมีอำนาจทั้งหมดในการเพิ่มเติมและแก้ไขเว็บแอปพลิเคชัน
ภาพรวมที่ให้ไว้ข้างต้นประกอบด้วยรายละเอียดของเพจซึ่งแสดงรายการแอปพลิเคชัน web2py ที่ติดตั้งทั้งหมดและอนุญาตให้ผู้ดูแลระบบจัดการได้ ตามค่าเริ่มต้นเฟรมเวิร์ก web2py จะมาพร้อมกับแอพพลิเคชั่นสามตัว พวกเขาคือ -
อัน admin แอปพลิเคชันที่ผู้ใช้กำลังใช้งานอยู่
อัน examples แอปพลิเคชันพร้อมเอกสารโต้ตอบออนไลน์และอินสแตนซ์ของเว็บไซต์อย่างเป็นทางการของ web2py
ก welcomeใบสมัคร ประกอบด้วยเทมเพลตพื้นฐานสำหรับแอปพลิเคชัน web2py อื่น ๆ เป็นที่รู้จักกันในชื่อscaffolding application. แอปพลิเคชันยังยินดีต้อนรับผู้ใช้เมื่อเริ่มต้น
ให้ชื่อของแอปพลิเคชันใหม่เป็น “helloWorld”.
เมื่อมีการสร้างแอปพลิเคชันใหม่ผู้ใช้จะถูกเปลี่ยนเส้นทางไปยังหน้าที่ประกอบด้วยมุมมองแบบจำลองและตัวควบคุมของแอปพลิเคชันที่เกี่ยวข้อง
ผู้ใช้สามารถดูแอปพลิเคชันที่สร้างขึ้นใหม่ได้โดยระบุ URL ต่อไปนี้ - http://127.0.0.1:8000/helloWorld
โดยค่าเริ่มต้นผู้ใช้สามารถดูหน้าจอต่อไปนี้ในการกดปุ่ม URL ที่กล่าวถึงข้างต้น
สำหรับการพิมพ์ข้อความของเว็บแอปพลิเคชันที่กำหนด “helloWorld”การเปลี่ยนแปลงจะทำในไฟล์ default.py ตัวควบคุม
ฟังก์ชันชื่อ “index”เป็นฟังก์ชันเริ่มต้นสำหรับการส่งคืนค่าและแสดงผลลัพธ์ที่จำเป็น ดังที่ได้กล่าวมาแล้วข้างต้นสตริง“Hello World- Welcome to my first web application” ใช้เป็นค่าส่งกลับซึ่งจะแสดงผลลัพธ์ในหน้าจอ
ผลลัพธ์จะแสดงดังนี้ -
โพสต์แบ็ค
กลไกในการตรวจสอบความถูกต้องของการป้อนข้อมูลของแบบฟอร์มเป็นเรื่องปกติมากและไม่ถือว่าเป็นวิธีการเขียนโปรแกรมที่ดีเช่นนี้ อินพุตจะได้รับการตรวจสอบความถูกต้องในแต่ละครั้งซึ่งเป็นภาระในการตรวจสอบความถูกต้อง
รูปแบบที่ดีกว่าใน web2py คือการส่งแบบฟอร์มไปยังการดำเนินการเดียวกันซึ่งสร้างขึ้น กลไกนี้เรียกว่า“postback”ซึ่งเป็นคุณสมบัติหลักของ web2py ในระยะสั้นการยอมจำนนด้วยตนเองทำได้ในpostback.
def first():
if request.vars.visitor_name: #if visitor name exists
session.visitor_name = request.vars.visitor_name
redirect(URL('second'))#postback is implemented
return dict()
แอปพลิเคชัน CRUD
web2py มีแอพพลิเคชั่นซึ่งทำหน้าที่สร้างดึงข้อมูลอัปเดตและลบ CRUD วงจรอธิบายถึงฟังก์ชันองค์ประกอบของฐานข้อมูลซึ่งคงอยู่
ตรรกะของแอปพลิเคชันทั้งหมดเขียนขึ้นในแบบจำลองซึ่งตัวควบคุมดึงข้อมูลมาและแสดงต่อผู้ใช้ด้วยความช่วยเหลือของมุมมอง
appadmin
สำหรับ PHP แอปพลิเคชันเซิร์ฟเวอร์จะรวมรายการฐานข้อมูลทั้งหมดไว้ภายใต้ phpmyadmin. ในทำนองเดียวกัน web2py มีอินเทอร์เฟซสำหรับจัดการสร้างและลบตารางหรือฐานข้อมูลซึ่งเรียกว่า“appadmin.”
ก่อนที่จะใช้ตรรกะหลังตารางจำเป็นต้องสร้างฐานข้อมูลและตารางที่เกี่ยวข้อง
URL ในการเข้าถึง appadmin -
http://127.0.0.1:8000/applicationname/appadmin
ในการกดปุ่ม URL ผู้ใช้จะได้รับรายชื่อตารางที่เกี่ยวข้องกับแอปพลิเคชันที่กำหนด
อินเทอร์เฟซนี้ไม่ได้ตั้งใจให้เป็นแบบสาธารณะ ออกแบบมาเพื่อให้เข้าถึงฐานข้อมูลได้ง่าย ประกอบด้วยสองไฟล์คือ - คอนโทรลเลอร์“appadmin.py” และมุมมอง “appadmin.html”.
สามารถแบ่งหน้าได้ครั้งละ 100 ระเบียน การใช้งานของ“appadmin” จะกล่าวถึงในบทต่อ ๆ ไป
ตัวเลือกบรรทัดคำสั่ง
เราได้เรียนรู้วิธีการเริ่มต้นเซิร์ฟเวอร์ web2py โดยใช้วิดเจ็ต GUI ในบทที่แล้ว
วิดเจ็ตนี้สามารถข้ามได้โดยเริ่มต้นเซิร์ฟเวอร์จาก command line พรอมต์
python web2py.py -a 'รหัสผ่านของคุณ' -i 127.0.0.1 -p 8000
เมื่อใดก็ตามที่เซิร์ฟเวอร์ web2py เริ่มทำงานเซิร์ฟเวอร์จะสร้างไฟล์ "parameters_8000.py"โดยที่รหัสผ่านทั้งหมดจะถูกเก็บไว้ในรูปแบบที่ถูกแฮช
เพื่อความปลอดภัยเพิ่มเติมสามารถใช้บรรทัดคำสั่งต่อไปนี้ -
python web2py.py -a '<recycle>' -i 127.0.0.1 -p 8000
สำหรับสถานการณ์ข้างต้น web2py จะใช้รหัสผ่านที่แฮชที่เก็บไว้ใน "parameters_8000.py".
ในกรณีถ้าไฟล์ "parameters_8000.py"ถูกลบโดยไม่ได้ตั้งใจหรือเนื่องจากสาเหตุอื่น ๆ อินเทอร์เฟซการดูแลระบบบนเว็บถูกปิดใช้งานใน web2py
การแมป URL / การจัดส่ง
การทำงานของ web2py ขึ้นอยู่กับ model-view-controller ซึ่งแมป URL ในรูปแบบเฉพาะ - http://127.0.0.1:8000/a/d/f.html
เส้นทางไปจนถึงฟังก์ชัน “f()” ที่กล่าวถึงในคอนโทรลเลอร์ d.pyอยู่ภายใต้แอปพลิเคชันชื่อ“ a” หากไม่มีตัวควบคุมอยู่ในแอปพลิเคชัน web2py จะใช้ตัวควบคุมเริ่มต้นที่ชื่อ“default.py”.
หากไม่มีฟังก์ชันตามที่ระบุใน URL แสดงว่าฟังก์ชันเริ่มต้นที่เรียกว่า init()ถูกนำมาใช้. การทำงานของ URL แสดงตามแผนผังในภาพด้านล่าง
ส่วนขยาย .htmlเป็นทางเลือกสำหรับ URL ส่วนขยายกำหนดส่วนขยายของViewที่แสดงผลลัพธ์ของฟังก์ชันที่กำหนดไว้ในคอนโทรลเลอร์ เนื้อหาเดียวกันให้บริการในหลายรูปแบบเช่น html, xml, json, rss เป็นต้น
การร้องขอจะถูกส่งโดยขึ้นอยู่กับฟังก์ชันซึ่งยอมรับอาร์กิวเมนต์และให้ผลลัพธ์ที่เหมาะสมแก่ผู้ใช้ เป็นตัวควบคุมซึ่งโต้ตอบกับโมเดลและมุมมองของแอปพลิเคชันเพื่อให้ได้ผลลัพธ์ตามความต้องการของผู้ใช้
web2py - เวิร์กโฟลว์
ขั้นตอนการทำงานของ web2py จะกล่าวถึงด้านล่าง -
เว็บเซิร์ฟเวอร์จัดการคำขอ HTTP แต่ละรายการพร้อมกันในเธรดของตนเอง
ส่วนหัวของคำขอ HTTP จะถูกแยกวิเคราะห์และส่งต่อไปยังผู้มอบหมายงาน
Dispatcher จัดการคำขอแอปพลิเคชันและแมปไฟล์ PATH_INFOใน URL ของการเรียกใช้ฟังก์ชัน ทุกการเรียกใช้ฟังก์ชันจะแสดงใน URL
คำขอทั้งหมดสำหรับไฟล์ที่รวมอยู่ในโฟลเดอร์แบบคงที่ได้รับการจัดการโดยตรงและไฟล์ขนาดใหญ่จะถูกสตรีมไปยังไคลเอนต์
การร้องขอสิ่งใดก็ตามยกเว้นไฟล์แบบคงที่จะถูกแมปลงในการดำเนินการ
หากส่วนหัวของคำขอมีคุกกี้เซสชันสำหรับแอปวัตถุเซสชันจะถูกเรียกคืน หรือมิฉะนั้นรหัสเซสชันจะถูกสร้างขึ้น
หากการดำเนินการส่งคืนค่าเป็นสตริงค่านี้จะส่งกลับไปยังไคลเอ็นต์
หากการดำเนินการส่งคืนสามารถทำซ้ำได้จะใช้เพื่อวนซ้ำและสตรีมข้อมูลไปยังไคลเอนต์
แบบจำลองเงื่อนไข
ในบทที่แล้วเราเห็นการทำงานของไฟล์ Controllers. web2py ใช้โมเดลมุมมองและคอนโทรลเลอร์ในแต่ละแอปพลิเคชัน ดังนั้นจึงจำเป็นต้องเข้าใจการทำงานของไฟล์Model.
ไม่เหมือนกับแอปพลิเคชัน MVC อื่น ๆ โมเดลใน web2py จะถือว่าเป็นไปตามเงื่อนไข โมเดลในโฟลเดอร์ย่อยจะถูกดำเนินการตามการใช้งานของคอนโทรลเลอร์ สิ่งนี้สามารถแสดงให้เห็นได้ด้วยตัวอย่างต่อไปนี้ -
พิจารณา URL - http://127.0.0.1:8000/a/d/f.html
ในกรณีนี้, ‘a’ เป็นชื่อของแอปพลิเคชัน ‘d’ คือชื่อตัวควบคุมและ f()คือฟังก์ชันที่เกี่ยวข้องกับคอนโทรลเลอร์ รายชื่อรุ่นที่จะดำเนินการมีดังนี้ -
applications/a/models/*.py
applications/a/models/d/*.py
applications/a/models/d/f/*.py
ห้องสมุด
web2py มีไลบรารีซึ่งสัมผัสกับแอปพลิเคชันทั้งหมดเป็นวัตถุ ออบเจ็กต์เหล่านี้ถูกกำหนดไว้ภายในไฟล์หลักภายใต้ไดเร็กทอรีชื่อ "gluon"
หลายโมดูลเช่นเทมเพลต DAL ไม่มีการอ้างอิงและสามารถนำไปใช้นอกกรอบของ web2py นอกจากนี้ยังรักษาการทดสอบหน่วยซึ่งถือเป็นแนวปฏิบัติที่ดี
การใช้งาน
แอปพลิเคชัน web2py แสดงอยู่ด้านล่างในรูปแบบไดอะแกรม
Applications ที่พัฒนาใน web2py ประกอบด้วยส่วนต่างๆดังต่อไปนี้ -
Models - แสดงข้อมูลและตารางฐานข้อมูล
Controllers - อธิบายตรรกะของแอปพลิเคชันและขั้นตอนการทำงาน
Views - ช่วยในการแสดงผลการแสดงข้อมูล
Languages - อธิบายวิธีการแปลสตริงในแอปพลิเคชันเป็นภาษาต่างๆที่รองรับ
Static files - ไม่ต้องการการประมวลผล (เช่นรูปภาพสไตล์ชีท CSS เป็นต้น)
ABOUT และ README - รายละเอียดโครงการ.
Errors - จัดเก็บรายงานข้อผิดพลาดที่สร้างโดยแอปพลิเคชัน
Sessions - จัดเก็บข้อมูลที่เกี่ยวข้องกับผู้ใช้แต่ละคน
Databases - จัดเก็บฐานข้อมูล SQLite และข้อมูลตารางเพิ่มเติม
Cache - จัดเก็บรายการแอปพลิเคชันที่แคชไว้
Modules - โมดูลเป็นโมดูล Python เสริมอื่น ๆ
Private - ไฟล์ที่รวมอยู่นั้นเข้าถึงได้โดยคอนโทรลเลอร์ แต่ไม่ใช่โดยนักพัฒนาโดยตรง
Uploads - ไฟล์ถูกเข้าถึงโดยโมเดล แต่ไม่ได้รับการเข้าถึงโดยตรงจากผู้พัฒนา
API
ใน web2py models, controllers และ views จะดำเนินการในสภาพแวดล้อมที่มีการนำเข้าวัตถุบางอย่างสำหรับนักพัฒนา
Global Objects - คำขอการตอบสนองเซสชันแคช
Helpers- web2py มีคลาสตัวช่วยซึ่งสามารถใช้สร้าง HTML โดยใช้โปรแกรม มันสอดคล้องกับแท็ก HTML เรียกว่า“HTML helpers”.
ตัวอย่างเช่น A, B, FIELDSET, FORM เป็นต้น
เซสชัน
เซสชันสามารถกำหนดให้เป็นที่จัดเก็บข้อมูลฝั่งเซิร์ฟเวอร์ซึ่งจะคงอยู่ตลอดการโต้ตอบของผู้ใช้ตลอดทั้งเว็บแอปพลิเคชัน
เซสชันใน web2py เป็นอินสแตนซ์ของคลาสพื้นที่เก็บข้อมูล
ตัวอย่างเช่นตัวแปรสามารถเก็บไว้ในเซสชันเป็น
session.myvariable = "hello"
ค่านี้สามารถเรียกคืนเป็น
a = session.myvariable
ค่าของตัวแปรสามารถเรียกคืนได้ตราบเท่าที่โค้ดถูกเรียกใช้ในเซสชันเดียวกันโดยผู้ใช้คนเดียวกัน
หนึ่งในวิธีการที่สำคัญใน web2py สำหรับเซสชันคือ “forget” -
session.forget(response);
มันสั่งให้ web2py ไม่บันทึกเซสชัน
เรียกใช้งานในพื้นหลัง
คำขอ HTTP มาถึงเว็บเซิร์ฟเวอร์ซึ่งจัดการแต่ละคำขอในเธรดของตัวเองแบบขนาน งานที่ใช้งานอยู่จะเกิดขึ้นในส่วนหน้าในขณะที่งานอื่น ๆ จะอยู่เบื้องหลัง การจัดการงานเบื้องหลังเป็นหนึ่งในคุณสมบัติหลักของ web2py
ควรเก็บงานที่ต้องใช้เวลามากในพื้นหลัง กลไกบางอย่างมีการระบุไว้ดังต่อไปนี้ซึ่งจัดการงานเบื้องหลัง -
CRON
Queues
Scheduler
CRON
ใน web2py CRONให้ความสามารถในการรันงานภายในช่วงเวลาที่กำหนด แต่ละแอปพลิเคชันมีไฟล์ CRON ซึ่งกำหนดฟังก์ชันการทำงาน
เครื่องมือจัดกำหนดการ
ตัวกำหนดตารางเวลาในตัวช่วยในการรันงานในพื้นหลังโดยการตั้งค่าลำดับความสำคัญ มีกลไกในการสร้างกำหนดเวลาและแก้ไขงาน
เหตุการณ์ตามกำหนดการแสดงอยู่ในโมเดลที่มีชื่อไฟล์ “scheduler.py”.
การสร้างแอปพลิเคชัน
เรามีภาพรวมของการสร้างโมเดลและคอนโทรลเลอร์ใน web2py ที่นี่เราจะมุ่งเน้นไปที่การสร้างแอปพลิเคชันที่ชื่อ“Contacts”. แอปพลิเคชันจำเป็นต้องรักษารายชื่อ บริษัท และรายชื่อบุคคลที่ทำงานใน บริษัท เหล่านั้น
การสร้างแบบจำลอง
ในที่นี้การระบุตารางสำหรับพจนานุกรมข้อมูลเป็นแบบจำลอง โมเดลสำหรับแอปพลิเคชันผู้ติดต่อจะถูกสร้างขึ้นภายใต้ "models” โฟลเดอร์ ไฟล์ถูกเก็บไว้ในmodels/db_contacts.py.
# in file: models/db_custom.py
db.define_table('company', Field('name', notnull = True, unique = True), format = '%(name)s')
db.define_table(
'contact',
Field('name', notnull = True),
Field('company', 'reference company'),
Field('picture', 'upload'),
Field('email', requires = IS_EMAIL()),
Field('phone_number', requires = IS_MATCH('[\d\-\(\) ]+')),
Field('address'),
format = '%(name)s'
)
db.define_table(
'log',
Field('body', 'text', notnull = True),
Field('posted_on', 'datetime'),
Field('contact', 'reference contact')
)
เมื่อสร้างไฟล์ด้านบนแล้วคุณสามารถเข้าถึงตารางได้ด้วยความช่วยเหลือของ URL http://127.0.0.1:8000/contacts/appadmin
การสร้างตัวควบคุม
Controller จะรวมฟังก์ชั่นบางอย่างสำหรับการแสดงรายการแก้ไขและลบรายชื่อ
# in file: controllers/default.py
def index():return locals()
def companies():companies = db(db.company).select(orderby = db.company.name)
return locals()
def contacts():company = db.company(request.args(0)) or redirect(URL('companies'))
contacts = db(db.contact.company == company.id).select(orderby = db.contact.name)
return locals()
@auth.requires_login()
def company_create():form = crud.create(db.company, next = 'companies')
return locals()
@auth.requires_login()
def company_edit():company = db.company(request.args(0)) or redirect(URL('companies'))
form = crud.update(db.company, company, next='companies')
return locals()
@auth.requires_login()
def contact_create():db.contact.company.default = request.args(0)
form = crud.create(db.contact, next = 'companies')
return locals()
@auth.requires_login()
def contact_edit():contact = db.contact(request.args(0)) or redirect(URL('companies'))
form = crud.update(db.contact, contact, next = 'companies')
return locals()
def user():return dict(form = auth())
การสร้างไฟล์ view พร้อมกับผลลัพธ์จะกล่าวถึงในบทถัดไป
web2py framework ใช้ Models, Controllers และ Viewsในการใช้งาน รวมถึงไวยากรณ์ Python ที่แก้ไขเล็กน้อยในไฟล์Views สำหรับโค้ดที่อ่านได้มากขึ้นโดยไม่มีข้อ จำกัด ใด ๆ ตามที่กำหนดไว้ในการใช้งาน Python ที่เหมาะสม
จุดประสงค์หลักของ web2py Viewคือการฝังโค้ด python ในเอกสาร HTML อย่างไรก็ตามมีปัญหาบางประการซึ่งมีดังนี้ -
- การหลบหนีของโค้ด python ที่ฝังในเอกสาร HTML
- ตามการเยื้องตาม Python ซึ่งอาจส่งผลต่อกฎ HTML
เพื่อหลีกเลี่ยงปัญหา web2py ใช้ตัวคั่น {{.. }} ในส่วนมุมมอง ตัวคั่นช่วยในการหลบหนีรหัสหลามที่ฝังไว้ นอกจากนี้ยังช่วยในการปฏิบัติตามกฎ HTML ของการเยื้อง
รหัสที่รวมอยู่ภายใน {{..}}ตัวคั่นรวมถึงรหัส Python โดยไม่ได้ตั้งใจ เนื่องจากโดยปกติ Python ใช้การเยื้องเพื่อคั่นบล็อกของโค้ดดังนั้นโค้ดที่ไม่ได้ตั้งใจภายในตัวคั่นจึงควรได้รับการดูแลอย่างเหมาะสม เพื่อแก้ไขปัญหานี้ web2py ใช้ไฟล์“pass” คำสำคัญ.
บล็อกรหัสที่ขึ้นต้นด้วยบรรทัดสิ้นสุดด้วยเครื่องหมายจุดคู่และลงท้ายด้วยบรรทัดที่ขึ้นต้นด้วยรหัสผ่าน
Note - pass เป็นคีย์เวิร์ด Python ไม่ใช่คีย์เวิร์ด web2py
รหัสต่อไปนี้แสดงการใช้งานของคำสำคัญผ่าน -
{{
if num > 0:
response.write('positive number')
else:
response.write('negative number')
pass
}}
ผู้ช่วยเหลือ HTML
web2py มีคลาสตัวช่วยที่สามารถใช้สร้าง HTML โดยใช้โปรแกรม มันสอดคล้องกับแท็ก HTML ซึ่งเรียกว่า "ผู้ช่วย HTML"
ตัวอย่างเช่น -
[(A('Home', _href = URL('default', 'home')), False, None, []), ...]
ที่นี่ A เป็นผู้ช่วยที่สอดคล้องกับจุดยึด <a>แท็กของ HTML สร้างจุดยึด HTML<a> แท็กโดยทางโปรแกรม
ตัวช่วย HTML ประกอบด้วยสองประเภท ได้แก่ positional และ named ข้อโต้แย้ง
Positional อาร์กิวเมนต์ถูกตีความว่าเป็นวัตถุที่อยู่ระหว่างแท็กเปิดและปิดของ HTML
Named อาร์กิวเมนต์เริ่มต้นด้วยขีดล่างถูกตีความเป็นแท็ก HTML
ผู้ช่วยยังมีประโยชน์ในการทำให้อนุกรมของสตริงด้วย _str_และวิธี xml ตัวอย่างเช่น -
>>> print str(DIV(“hello world”))
เอาต์พุต
<div> hello world </div>
Note - ตัวช่วย HTML จัดเตรียมการเป็นตัวแทนฝั่งเซิร์ฟเวอร์ของ Document Object Model (DOM)
ผู้ช่วยเหลือ XML
XML ถูกเรียกว่าเป็นอ็อบเจ็กต์ซึ่งห่อหุ้มข้อความที่ไม่ควรหลีกเลี่ยง ข้อความอาจมีหรือไม่มี XML ที่ถูกต้อง
ตัวอย่างเช่นสำหรับโค้ดที่กล่าวถึงด้านล่างอาจมี JavaScript
>>> print XML('<script>alert("unsafe!")</script>')
เอาต์พุต
<script> alert(“unsafe!”)</script>
ตัวช่วยในตัว
มีตัวช่วยในตัวมากมายที่ใช้ใน web2py ตัวช่วยในตัว HTML บางส่วนมีการระบุไว้ด้านล่าง
ชื่อ | การใช้งาน | ตัวอย่าง |
---|---|---|
ก | ตัวช่วยนี้ใช้เพื่อสร้างลิงก์ สอดคล้องกับแท็กจุดยึด | |
ข | ตัวช่วยนี้ช่วยในการทำให้เนื้อหาของข้อความเป็นตัวหนา | |
ร่างกาย | ตัวช่วยนี้ทำให้เนื้อหาของเพจ นอกจากนี้ยังมีตัวดำเนินการคูณเพื่อเพิ่มจำนวนตัวแบ่ง | |
รหัส | ดำเนินการเน้นไวยากรณ์สำหรับรหัส Python, C, C ++ และ web2py ผู้ช่วยนี้ยังมีความสามารถในการเชื่อมโยงเอกสาร API | |
FIELDSET | จะสร้างช่องป้อนข้อมูลร่วมกับป้ายกำกับ | |
ศีรษะ | ช่วยในการติดแท็ก <head> แท็กของหน้า HTML | |
IMG | ช่วยในการฝังภาพสำหรับหน้า HTML ที่กำหนด | |
ผู้ช่วยเหลือที่กำหนดเอง
ตัวช่วยเหล่านี้ใช้เพื่อปรับแต่งแท็กตามความต้องการ web2py ใช้ตัวช่วยแบบกำหนดเองต่อไปนี้ -
TAG
web2py ใช้ TAG เป็นตัวสร้างแท็กสากล ช่วยในการสร้างแท็ก XML ที่กำหนดเอง ไวยากรณ์ทั่วไปมีดังนี้ -
{{ = TAG.name('a', 'b', _c = 'd')}}
สร้างโค้ด XML เป็น: <name c = "d"> ab </name>
TAG เป็นวัตถุและTAG.name
หรือTAG['name']
เป็นฟังก์ชันที่ส่งคืนคลาสผู้ช่วยเหลือชั่วคราว
เมนู
ตัวช่วยนี้สร้างรายการของรายการหรือค่าของรายการเมนูโดยสร้างโครงสร้างแบบต้นไม้ที่แสดงถึงเมนู รายการเมนูอยู่ในรูปแบบresponse.menu. ตัวอย่างเช่น -
print MENU([['One', False, 'link1'], ['Two', False, 'link2']])
ผลลัพธ์จะแสดงดังนี้ -
<ul class = "web2py-menu web2py-menu-vertical">
<li><a href = "link1">One</a></li>
<li><a href = "link2">Two</a></li>
</ul>
ความงาม
ช่วยในการสร้างตัวแทนของวัตถุผสมรวมถึงรายการและพจนานุกรม ตัวอย่างเช่น,
{{ = BEAUTIFY({"a": ["hello", XML("world")], "b": (1, 2)})}}
ส่งคืนอ็อบเจ็กต์ XML ที่สามารถทำให้เป็นอนุกรมได้กับ XML โดยมีการแทนอาร์กิวเมนต์ตัวสร้าง ในกรณีนี้การแสดงจะเป็น -
{"a": ["hello", XML("world")], "b": (1, 2)}
ผลลัพธ์จะแสดงผลเป็น -
<table>
<tr>
<td>a</td>
<td>:</td>
<td>hello<br />world</td>
</tr>
<tr>
<td>b</td>
<td>:</td>
<td>1<br />2</td>
</tr>
</table>
การแสดงผล DOM ฝั่งเซิร์ฟเวอร์
การแสดงผลฝั่งเซิร์ฟเวอร์อนุญาตให้ผู้ใช้แสดงสถานะเริ่มต้นของคอมโพเนนต์ web2py ล่วงหน้า ตัวช่วยที่ได้รับทั้งหมดมีองค์ประกอบการค้นหาและองค์ประกอบเพื่อแสดง DOM ทางฝั่งเซิร์ฟเวอร์
elementส่งคืนองค์ประกอบลูกแรกที่ตรงกับเงื่อนไขที่ระบุ ในทางกลับกัน,elementsส่งคืนรายการเด็กที่ตรงกันทั้งหมด ทั้งสองใช้ไวยากรณ์เดียวกัน
สิ่งนี้สามารถแสดงให้เห็นได้ด้วยตัวอย่างต่อไปนี้ -
a = DIV(DIV(DIV('a', _id = 'target',_class = 'abc')))
d = a.elements('div#target')
d[0][0] = 'changed'
print a
ผลลัพธ์จะได้รับเป็น -
<div><div><div id = "target" class = "abc">changed</div></div></div>
เค้าโครงหน้า
มุมมองใช้เพื่อแสดงผลลัพธ์ให้กับผู้ใช้ปลายทาง สามารถขยายและรวมมุมมองอื่น ๆ ได้เช่นกัน สิ่งนี้จะใช้โครงสร้างที่เหมือนต้นไม้
ตัวอย่าง - “index.html” ขยายไปถึง “layout.html” ซึ่งอาจรวมถึง “menu.html” ซึ่งจะรวมถึง “header.html”.
{{extend 'layout.html'}}
<h1>Hello World</h1>
{{include 'page.html'}}
ตัวอย่าง
ในบทก่อนหน้านี้เราได้สร้างโมเดลและตัวควบคุมสำหรับโมดูลของ บริษัท ตอนนี้เราจะเน้นไปที่การสร้างมุมมองซึ่งช่วยในการแสดงผลการแสดงข้อมูล
ตามค่าเริ่มต้นมุมมองใน web2py จะรวม layout.html และ index.htmlซึ่งกำหนดส่วนโดยรวมของการแสดงข้อมูล
{{extend 'layout.html'}}
<h2>Companies</h2>
<table>
{{for company in companies:}}
<tr>
<td>{{ = A(company.name, _href = URL('contacts', args = company.id))}}</td>
<td>{{ = A('edit', _href = URL('company_edit', args = company.id))}}</td>
</tr>
{{pass}}
<tr>
<td>{{ = A('add company', _href = URL('company_create'))}}</td>
</tr>
</table>
ผลลัพธ์จะเป็นดังนี้ -
Database Abstraction Layer (DAL)ถือเป็นจุดแข็งที่สำคัญของ web2py DAL แสดงอินเตอร์เฟสการเขียนโปรแกรมประยุกต์ (API) อย่างง่ายให้กับไวยากรณ์ SQL ที่เป็นพื้นฐาน
ในบทนี้เราจะทำความรู้จักกับแอปพลิเคชันที่ไม่สำคัญของ DAL เช่นการสร้างคิวรีเพื่อค้นหาด้วยแท็กอย่างมีประสิทธิภาพและการสร้างแผนผังหมวดหมู่ตามลำดับชั้น
คุณสมบัติที่สำคัญบางประการของ DAL ได้แก่ -
web2py มี Database Abstraction Layer (DAL) ซึ่งเป็น API ที่แมปวัตถุ Python เข้ากับวัตถุฐานข้อมูล วัตถุฐานข้อมูลสามารถเป็นแบบสอบถามตารางและระเบียน
DAL สร้าง SQL แบบไดนามิกตามเวลาจริงโดยใช้ภาษาถิ่นที่ระบุสำหรับแบ็คเอนด์ของฐานข้อมูลดังนั้นจึงไม่จำเป็นสำหรับนักพัฒนาในการเขียนแบบสอบถาม SQL ที่สมบูรณ์
ข้อได้เปรียบที่สำคัญของการใช้ DAL คือแอปพลิเคชันจะสามารถพกพาได้กับฐานข้อมูลประเภทต่างๆ
เริ่มต้นใช้งาน DAL
แอปพลิเคชันส่วนใหญ่ใน web2py ต้องการการเชื่อมต่อฐานข้อมูล ดังนั้นการสร้างแบบจำลองฐานข้อมูลจึงเป็นขั้นตอนแรกในการออกแบบแอปพลิเคชัน
พิจารณาแอปพลิเคชันที่สร้างขึ้นใหม่ชื่อ “helloWorld”. ฐานข้อมูลถูกนำไปใช้ภายใต้โมเดลของแอปพลิเคชัน ทุกรุ่นสำหรับแอปพลิเคชันที่เกี่ยวข้องประกอบด้วยไฟล์ชื่อ -models/db_custom.py.
ขั้นตอนต่อไปนี้ใช้สำหรับการนำ DAL ไปใช้ -
ขั้นตอนที่ 1 - ตัวสร้าง DAL
สร้างการเชื่อมต่อฐานข้อมูล สิ่งนี้ถูกสร้างขึ้นโดยใช้วัตถุ DAL ซึ่งเรียกอีกอย่างว่าตัวสร้าง DAL
db = DAL ('sqlite://storage.sqlite')
คุณสมบัติเด่นของ DAL คือช่วยให้สามารถเชื่อมต่อกับฐานข้อมูลเดียวกันหรือกับฐานข้อมูลที่แตกต่างกันได้แม้จะมีฐานข้อมูลประเภทต่างๆ เป็นที่สังเกตว่ามีบรรทัดนี้อยู่ในไฟล์แล้วmodels/db.py. ดังนั้นคุณอาจไม่จำเป็นต้องใช้เว้นแต่คุณจะลบออกหรือจำเป็นต้องเชื่อมต่อกับฐานข้อมูลอื่น โดยค่าเริ่มต้น web2py จะเชื่อมต่อกับฐานข้อมูล SQLite ที่เก็บไว้ในไฟล์storage.sqlite.
ไฟล์นี้อยู่ในโฟลเดอร์ฐานข้อมูลของแอปพลิเคชัน หากไม่มีไฟล์จะถูกสร้างขึ้นโดย web2py เมื่อแอปพลิเคชันถูกเรียกใช้ครั้งแรก
SQLite นั้นรวดเร็วและเก็บข้อมูลทั้งหมดไว้ในไฟล์เดียว ซึ่งหมายความว่าข้อมูลของคุณสามารถถ่ายโอนจากแอปพลิเคชันหนึ่งไปยังอีกแอปพลิเคชันได้อย่างง่ายดาย ในความเป็นจริงฐานข้อมูล SQLite ได้รับการบรรจุโดย web2py พร้อมกับแอปพลิเคชัน ให้การสนับสนุน SQL เต็มรูปแบบรวมถึงการแปลการรวมและการรวม
มีข้อเสียสองประการของ SQLite
ประการหนึ่งคือไม่บังคับใช้ประเภทคอลัมน์และไม่มี ALTER TABLE ยกเว้นการเพิ่มและวางคอลัมน์
ข้อเสียอีกประการหนึ่งคือฐานข้อมูลทั้งหมดถูกล็อกโดยธุรกรรมใด ๆ ที่ต้องมีการเข้าถึงการเขียน
ขั้นตอนที่ 2 - ตัวสร้างตาราง
เมื่อสร้างการเชื่อมต่อกับฐานข้อมูลแล้วเราสามารถใช้ไฟล์ define_table วิธีการกำหนดตารางใหม่
ตัวอย่างเช่น -
db.define_table('invoice',Field('name'))
วิธีการข้างต้นยังใช้ระหว่างตัวสร้างตาราง ไวยากรณ์สำหรับตัวสร้างตารางจะเหมือนกัน อาร์กิวเมนต์แรกคือชื่อตารางและตามด้วยรายการField(s). ตัวสร้างฟิลด์รับอาร์กิวเมนต์ต่อไปนี้ -
ซีเนียร์ No | อาร์กิวเมนต์และการใช้งาน |
---|---|
1 | The field name ชื่อของเขตข้อมูลในตาราง |
2 | The field type รับค่าที่มีประเภทข้อมูลเช่นสตริง (ค่าเริ่มต้น) ข้อความบูลีนจำนวนเต็มและอื่น ๆ |
3 | Length กำหนดความยาวสูงสุด |
4 | default = None นี่คือค่าเริ่มต้นเมื่อมีการแทรกระเบียนใหม่ |
5 | update = None วิธีนี้ใช้งานได้เหมือนกับค่าเริ่มต้น แต่ค่านี้จะใช้เฉพาะในการอัปเดตเท่านั้นไม่ใช่ในการแทรก |
6 | Notnull สิ่งนี้ระบุว่าค่าฟิลด์สามารถเป็น NULL หรือไม่ |
7 | readable = True สิ่งนี้ระบุว่าฟิลด์สามารถอ่านได้ในแบบฟอร์มหรือไม่ |
8 | writable = True สิ่งนี้ระบุว่าฟิลด์สามารถเขียนได้ในรูปแบบหรือไม่ |
9 | label = "Field Name" นี่คือป้ายกำกับที่จะใช้สำหรับฟิลด์นี้ในแบบฟอร์ม |
define_table วิธีการใช้อาร์กิวเมนต์ที่มีชื่อสามตัว
ไวยากรณ์
db.define_table('....',migrate=True, fake_migrate=False, format = '%(id)s')
migrate = True - สิ่งนี้สั่งให้ web2py สร้างตารางหากไม่มีอยู่หรือแก้ไขหากไม่ตรงกับข้อกำหนดของโมเดล
fake_migrate = False - หากโมเดลตรงกับเนื้อหาตารางฐานข้อมูลให้ตั้งค่า fake_migrate = True ซึ่งช่วยให้ web2py สร้างข้อมูลขึ้นมาใหม่
format = '%(id)s' - นี่คือสตริงรูปแบบที่กำหนดวิธีการแสดงเรกคอร์ดบนตารางที่กำหนด
การสร้าง Raw SQL
ด้วยการใช้ DAL เราสามารถสร้างการเชื่อมต่อกับฐานข้อมูลและสร้างตารางและฟิลด์ใหม่โดยใช้ตัวสร้างตารางและตัวสร้างฟิลด์
บางครั้งจำเป็นต้องสร้างคำสั่ง SQL เพื่อให้สอดคล้องกับผลลัพธ์ที่จำเป็น web2py มีฟังก์ชันต่างๆซึ่งช่วยในการสร้าง SQL ดิบซึ่งได้รับดังต่อไปนี้ -
_แทรก
ช่วยในการดึงคำสั่งแทรกสำหรับตารางที่กำหนด ตัวอย่างเช่น,
print db.person._insert(name ='ABC')
มันจะดึงคำสั่งแทรกสำหรับตารางชื่อ "คน"
เอาต์พุตคำสั่ง SQL -
INSERT INTO person(name) VALUES ('ABC');
_นับ
ช่วยในการดึงคำสั่ง SQL ซึ่งให้จำนวนระเบียน ตัวอย่างเช่นพิจารณาตารางชื่อ 'บุคคล' และเราต้องหาจำนวนบุคคลที่มีชื่อ 'ABC'
print db(db.person.name ==' ABC ')._count()
เอาต์พุตคำสั่ง SQL -
SELECT count(*) FROM person WHERE person.name = ' ABC ';
_เลือก
ช่วยในการดึงคำสั่ง SQL ที่เลือก ตัวอย่างเช่นพิจารณาตารางชื่อ 'บุคคล' และเราต้องหารายชื่อบุคคลที่มีชื่อ 'ABC'
print db(db.person.name == ' ABC ')._select()
เอาต์พุตคำสั่ง SQL -
SELECT person.name FROM person WHERE person.name = ' ABC ';
_ลบ
ช่วยในการดึงไฟล์ delete SQLงบ ตัวอย่างเช่นพิจารณาตารางที่ชื่อ 'person' และเราจำเป็นต้องลบข้อความที่มีชื่อ 'ABC'
print db(db.person.name == ' ABC ')._delete()
เอาต์พุตคำสั่ง SQL -
DELETE FROM person WHERE person.name = ' ABC ';4
_update
ช่วยในการดึงข้อมูลคำสั่ง SQL ที่อัปเดต ตัวอย่างเช่นพิจารณาตารางที่ชื่อ 'person' และเราจำเป็นต้องอัปเดตชื่อคอลัมน์ด้วยค่าอื่น ๆ
print db(db.person.name == ' ABC ')._update()
เอาต์พุตคำสั่ง SQL -
UPDATE person SET WHERE person.name = ’Alex’;
ปัญหาเกี่ยวกับ DAL (Gotchas)
SQLite
SQLite ขาดการสนับสนุนในการวางหรือแก้ไขคอลัมน์ การลบเขตข้อมูลออกจากตารางจะช่วยให้สามารถใช้งานได้ในฐานข้อมูลเนื่องจาก web2py จะไม่ทราบถึงการเปลี่ยนแปลงใด ๆ ที่เกิดขึ้น
ในกรณีนี้จำเป็นต้องตั้งค่าไฟล์ fake_migrate = True ซึ่งจะช่วยในการกำหนดข้อมูลเมตาใหม่เพื่อให้การเปลี่ยนแปลงใด ๆ เช่นแก้ไขหรือลบจะถูกเก็บไว้ภายใต้ความรู้ของ web2py
SQLite ไม่สนับสนุนประเภทบูลีน สำหรับสิ่งนี้ web2py จะแมป Booleans เป็นสตริงอักขระ 1 ตัวภายในโดยมี 'T' และ 'F' แทนtrue และ False ตามลำดับ
MySQL
MySQL ไม่รองรับคุณสมบัติ ALTER TABLE ดังนั้นการย้ายฐานข้อมูลจึงเกี่ยวข้องกับการกระทำหลายอย่าง สถานการณ์นี้สามารถหลีกเลี่ยงได้โดยการตั้งค่าพารามิเตอร์fake_migrate = True ในขณะที่กำหนดฐานข้อมูลซึ่งจะยังคงมีข้อมูลเมตาทั้งหมดอยู่
Oracle
Oracle ไม่สนับสนุนคุณลักษณะของการแบ่งหน้าของระเบียน นอกจากนี้ยังขาดการสนับสนุนสำหรับคำหลัก OFFSET หรือขีด จำกัด ด้วยเหตุนี้ web2py จึงมีการแบ่งหน้าด้วยความช่วยเหลือของ DAL แบบซ้อนสามทางที่ซับซ้อน DAL จำเป็นต้องจัดการการแบ่งหน้าด้วยตนเองหากมีการใช้ฐานข้อมูล Oracle
web2py มาพร้อมกับฟังก์ชันที่มีประสิทธิภาพสำหรับการสร้างแบบฟอร์ม สี่วิธีที่แตกต่างกันในการสร้างแบบฟอร์มใน web2py มีดังนี้ -
FORM- ในแง่ของตัวช่วย HTML ถือเป็นการใช้งานระดับต่ำ อ็อบเจ็กต์ FORM ตระหนักถึงเนื้อหาฟิลด์
SQLFORM - มีฟังก์ชันการสร้างอัปเดตและลบไปยังฐานข้อมูลที่มีอยู่
SQLFORM.factory- ถือเป็นเลเยอร์นามธรรมที่ด้านบนของ SQLFORM ซึ่งสร้างรูปแบบคล้ายกับ SQLFORM ที่นี่ไม่จำเป็นต้องสร้างฐานข้อมูลใหม่
CRUD Methods - ตามชื่อที่แนะนำมันมีคุณสมบัติสร้างดึงข้อมูลอัปเดตและลบด้วยฟังก์ชันที่คล้ายกันตาม SQLFORM
แบบฟอร์ม
พิจารณาแอปพลิเคชันที่ยอมรับข้อมูลจากผู้ใช้และมีปุ่ม "ส่ง" เพื่อส่งคำตอบ
ตัวควบคุม
ตัวควบคุม“ default.py” จะรวมฟังก์ชันที่เกี่ยวข้องดังต่อไปนี้
def display_form():
return dict()
ดู
มุมมองที่เกี่ยวข้อง "default / display_form.html" จะแสดงผลการแสดงฟอร์มใน HTML เป็น -
{{extend 'layout.html'}}
<h2>Basic Form</h2>
<form enctype = "multipart/form-data" action = "{{= URL()}}" method = "post">
Your name:
<input name = "name" />
<input type = "submit" />
</form>
<h2>Submitted variables</h2>
{{= BEAUTIFY(request.vars)}}
ตัวอย่างข้างต้นเป็นรูปแบบ HTML ปกติซึ่งขอให้ผู้ใช้ป้อนข้อมูล สามารถสร้างแบบฟอร์มเดียวกันได้โดยใช้ตัวช่วยเช่น FORM object
ตัวควบคุม
def display_form():
form = FORM('Value:', INPUT(_value = 'name'), INPUT(_type = 'submit'))
return dict(form = form)
ฟังก์ชันข้างต้นในตัวควบคุม "default.py" รวมถึงวัตถุ FORM (ตัวช่วย HTML) ซึ่งช่วยในการสร้างแบบ
ดู
{{extend 'layout.html'}}
<h2>Basic form</h2>
{{= form}}
<h2>Submitted variables</h2>
{{= BEAUTIFY(request.vars)}}
เขาสร้างขึ้นโดยคำสั่ง {{= form}}ทำให้เป็นอนุกรมของวัตถุ FORM เมื่อผู้ใช้กรอกแบบฟอร์มและคลิกที่ปุ่มส่งฟอร์มจะส่งเองและตัวแปรrequest.vars.value พร้อมกับค่าอินพุตจะแสดงที่ด้านล่าง
SQLFORM
ช่วยในการสร้างฟอร์มไปยังฐานข้อมูลที่มีอยู่ ขั้นตอนในการใช้งานมีการอธิบายไว้ด้านล่าง
สร้างการเชื่อมต่อกับฐานข้อมูลโดยใช้ DAL สิ่งนี้ถูกสร้างขึ้นโดยใช้วัตถุ DAL ซึ่งเรียกอีกอย่างว่า DAL constructor หลังจากสร้างการเชื่อมต่อแล้วผู้ใช้สามารถสร้างตารางตามลำดับ
db = DAL('sqlite://storage.sqlite')
db.define_table('employee', Field('name', requires = IS_NOT_EMPTY()))
ดังนั้นเราจึงสร้างตารางชื่อ "พนักงาน" ตัวควบคุมสร้างแบบฟอร์มและปุ่มด้วยข้อความต่อไปนี้ -
form = SQLFORM(
db.mytable,
record = mytable_index,
deletable = True,
submit_button = T('Update')
)
ดังนั้นสำหรับตารางพนักงานที่สร้างขึ้นการปรับเปลี่ยนในคอนโทรลเลอร์จะเป็น -
def display_form():
form = SQLFORM(db.person)
ไม่มีการแก้ไขใน View. ในคอนโทรลเลอร์ใหม่จำเป็นต้องสร้างแบบฟอร์มเนื่องจากตัวสร้าง SQLFORM สร้างขึ้นจากตาราง db. พนักงานถูกกำหนดไว้ในโมเดล รูปแบบใหม่เมื่อทำให้เป็นอนุกรมจะปรากฏดังนี้ -
<form enctype = "multipart/form-data" action = "" method = "post">
<table>
<tr id = "employee_name__row">
<td>
<label id = "person_name__label" for = "person_name">Your name: </label>
</td>
<td>
<input type = "text" class = "string" name = "name" value = "" id = "employee_name" />
</td>
<td></td>
</tr>
<tr id = "submit_record__row">
<td></td>
<td><input value = "Submit" type = "submit" /></td>
<td></td>
</tr>
</table>
<input value = "9038845529" type = "hidden" name = "_formkey" />
<input value = "employee" type = "hidden" name = "_formname" />
</form>
แท็กทั้งหมดในแบบฟอร์มมีชื่อที่ได้มาจากชื่อตารางและฟิลด์
อัน SQLFORMออบเจ็กต์ยังเกี่ยวข้องกับฟิลด์ "อัปโหลด" ด้วยการบันทึกไฟล์ที่อัปโหลดในโฟลเดอร์ "อัปโหลด" โดยอัตโนมัติ SQLFORM แสดงค่า "บูลีน" ในรูปแบบของช่องทำเครื่องหมายและค่าข้อความด้วยความช่วยเหลือของ“textareas”.
SQLFORM ยังใช้วิธีการกระบวนการซึ่งจำเป็นหากผู้ใช้ต้องการเก็บค่าด้วย SQLFORM ที่เกี่ยวข้อง
ถ้า form.process(keepvalues = True) ก็เป็นที่ยอมรับ
ตัวอย่าง
def display_form():
form = SQLFORM(db.employee)
if form.process().accepted:
response.flash = 'form accepted'
elif form.errors:
response.flash = 'form has errors'
else:
response.flash = 'please fill out the form'
return dict(form = form)
SQLFORM.factory
บางครั้งผู้ใช้จำเป็นต้องสร้างแบบฟอร์มในลักษณะที่มีตารางฐานข้อมูลที่มีอยู่โดยไม่ต้องใช้ฐานข้อมูล ผู้ใช้เพียงแค่ต้องการใช้ประโยชน์จากความสามารถของ SQLFORM
ทำได้ผ่านทาง form.factory และจะยังคงอยู่ในเซสชัน
def form_from_factory():
form = SQLFORM.factory(
Field('your_name', requires = IS_NOT_EMPTY()),
Field('your_image', 'upload'))
if form.process().accepted:
response.flash = 'form accepted'
session.your_name = form.vars.your_name
session.your_image = form.vars.your_image
elif form.errors:
response.flash = 'form has errors'
return dict(form = form)
แบบฟอร์มจะปรากฏเป็น SQLFORM โดยมีชื่อและรูปภาพเป็นฟิลด์ แต่ไม่มีตารางที่มีอยู่ในฐานข้อมูล
มุมมอง "default / form_from_factory.html" จะแสดงเป็น -
{{extend 'layout.html'}}
{{= form}}
วิธีการ CRUD
CRUDเป็น API ที่ใช้กับ SQLFORM ตามชื่อที่แนะนำมันใช้สำหรับการสร้างการเรียกใช้การอัปเดตและการลบแบบฟอร์มที่เหมาะสม
CRUD เมื่อเปรียบเทียบกับ API อื่น ๆ ใน web2py จะไม่ถูกเปิดเผย ดังนั้นจึงจำเป็นที่จะต้องนำเข้า
from gluon.tools import Crud
crud = Crud(db)
วัตถุ CRUD ที่กำหนดไว้ข้างต้นมี API ต่อไปนี้ -
ซีเนียร์ No | API และฟังก์ชันการทำงาน |
---|---|
1 | crud.tables() ส่งคืนรายการตารางที่กำหนดในฐานข้อมูล |
2 | crud.create(db.tablename) ส่งคืนฟอร์มสร้างสำหรับไฟล์ table tablename. |
3 | crud.read(db.tablename, id) ส่งคืนรูปแบบอ่านอย่างเดียวสำหรับ tablename และบันทึกรหัส |
4 | crud.delete(db.tablename, id) ลบบันทึก |
5 | crud.select(db.tablename, query) ส่งคืนรายการระเบียนที่เลือกจากตาราง |
6 | crud.search(db.tablename) ส่งคืนทูเพิล (ฟอร์มระเบียน) โดยที่ฟอร์มคือฟอร์มการค้นหา |
7 | crud() ส่งกลับรายการใดรายการหนึ่งข้างต้นตาม request.args () |
การสร้างแบบฟอร์ม
ให้เราสร้างแบบฟอร์ม ทำตามรหัสที่ระบุด้านล่าง
รุ่น
โมเดลใหม่ถูกสร้างขึ้นภายใต้ไฟล์ modelsโฟลเดอร์ของแอปพลิเคชัน ชื่อของไฟล์จะเป็น“dynamic_search.py”.
def build_query(field, op, value):
if op == 'equals':
return field == value
elif op == 'not equal':
return field != value
elif op == 'greater than':
return field > value
elif op == 'less than':
return field < value
elif op == 'starts with':
return field.startswith(value)
elif op == 'ends with':
return field.endswith(value)
elif op == 'contains':
return field.contains(value)
def dynamic_search(table):
tbl = TABLE()
selected = []
ops = ['equals',
'not equal',
'greater than',
'less than',
'starts with',
'ends with',
'contains']
query = table.id > 0
for field in table.fields:
chkval = request.vars.get('chk'+field,None)
txtval = request.vars.get('txt'+field,None)
opval = request.vars.get('op'+field,None)
row = TR(TD(INPUT(_type = "checkbox",_name = "chk"+field,value = chkval == 'on')),
TD(field),TD(SELECT(ops,_name = "op"+field,value = opval)),
TD(INPUT(_type = "text",_name = "txt"+field,_value = txtval)))
tbl.append(row)
if chkval:
if txtval:
query &= build_query(table[field], opval,txtval)
selected.append(table[field])
form = FORM(tbl,INPUT(_type="submit"))
results = db(query).select(*selected)
return form, results
ตัวควบคุม
ไฟล์ที่เกี่ยวข้องคือ “dynamic_search.py” ภายใต้ส่วนคอนโทรลเลอร์จะมีรหัสต่อไปนี้ -
def index():
form,results = dynamic_search(db.things)
return dict(form = form,results = results)
ดู
เราสามารถแสดงสิ่งนี้ด้วยมุมมองต่อไปนี้
{{extend 'layout.html'}}
{{= form}}
{{= results}}
นี่คือสิ่งที่ดูเหมือน -
web2py มีฟังก์ชันการส่งอีเมลและ SMS ไปยังผู้ใช้ ใช้ไลบรารีเพื่อส่งอีเมลและ SMS
การตั้งค่าอีเมล
คลาสในตัว ได้แก่ gluon.tools.Mailclass ใช้ในการส่งอีเมลใน web2py framework สามารถกำหนดเมลล์ได้ด้วยคลาสนี้
from gluon.tools import Mail
mail = Mail()
mail.settings.server = 'smtp.example.com:25'
mail.settings.sender = '[email protected]'
mail.settings.login = 'username:password'
อีเมลผู้ส่งตามที่กล่าวไว้ในตัวอย่างข้างต้นพร้อมกับรหัสผ่านจะได้รับการรับรองความถูกต้องทุกครั้งเมื่อมีการส่งอีเมล
หากผู้ใช้ต้องการทดลองหรือใช้เพื่อจุดประสงค์ในการดีบักบางอย่างสามารถทำได้โดยใช้รหัสต่อไปนี้
mail.settings.server = 'logging'
ตอนนี้อีเมลทั้งหมดจะไม่ถูกส่ง แต่จะถูกล็อกไว้ในคอนโซล
การส่งอีเมล
เมื่อเราตั้งค่าการกำหนดค่าสำหรับอีเมลโดยใช้อ็อบเจ็กต์เมลแล้วสามารถส่งอีเมลไปยังผู้ใช้จำนวนมากได้
ไวยากรณ์ที่สมบูรณ์ของ mail.send() มีดังนี้ -
send(
to, subject = 'Abc',
message = 'None', attachments = [],
cc = [], bcc = [], reply_to = [],
sender = None, encoding = 'utf-8',
raw = True, headers = {}
)
การดำเนินงานของ mail.send() ได้รับด้านล่าง
mail.send(
to = ['[email protected]'], subject = 'hello',
reply_to = '[email protected]',
message = 'Hello ! How are you?'
)
Mailส่งคืนนิพจน์บูลีนตามการตอบสนองของเซิร์ฟเวอร์การส่งเมลที่ผู้ใช้ปลายทางได้รับเมล มันกลับมาTrue หากประสบความสำเร็จในการส่งอีเมลไปยังผู้ใช้
คุณลักษณะของ cc และ bcc รวมถึงรายชื่อที่อยู่อีเมลที่ถูกต้องสำหรับอีเมลที่ตั้งใจจะส่ง
การส่ง SMS
การใช้งานในการส่งข้อความ SMS แตกต่างจากการส่งอีเมลใน web2py framework เนื่องจากจะต้องใช้บริการของบุคคลที่สามที่สามารถถ่ายทอดข้อความไปยังผู้รับได้ บริการของบุคคลที่สามไม่ใช่บริการฟรีและจะแตกต่างกันอย่างเห็นได้ชัดตามภูมิภาคทางภูมิศาสตร์ (ในแต่ละประเทศ)
web2py ใช้โมดูลเพื่อช่วยในการส่ง SMS ด้วยกระบวนการต่อไปนี้ -
from gluon.contrib.sms_utils
import SMSCODES, sms_email
email = sms_email('1 (111) 111-1111','T-Mobile USA (abc)')
mail.send(to = email, subject = 'test', message = 'test')
ในตัวอย่างข้างต้น SMSCODES เป็นพจนานุกรมที่ดูแลโดย web2py ซึ่งจะจับคู่ชื่อของ บริษัท โทรศัพท์รายใหญ่กับที่อยู่อีเมล postfix
บริษัท โทรศัพท์มักจะถือว่าอีเมลที่มาจากบริการของบุคคลที่สามเป็นสแปม วิธีที่ดีกว่าคือ บริษัท โทรศัพท์ส่ง SMS เอง บริษัท โทรศัพท์ทุกแห่งจะมีที่อยู่อีเมลที่ไม่ซ้ำกันสำหรับหมายเลขโทรศัพท์มือถือทุกหมายเลขในพื้นที่จัดเก็บข้อมูลและสามารถส่ง SMS ไปยังอีเมลได้โดยตรง
ในตัวอย่างข้างต้น
sms_email ฟังก์ชันรับหมายเลขโทรศัพท์ (เป็นสตริง) ซึ่งจะส่งกลับที่อยู่อีเมลของโทรศัพท์
แอพ scaffolding มีหลายไฟล์ หนึ่งในนั้นคือ model / db.py ซึ่งนำเข้าสี่
ชั้นเรียนจาก gluon.tools รวมไลบรารีอีเมลและกำหนดวัตถุส่วนกลางต่างๆ
แอปพลิเคชัน scaffolding ยังกำหนดตารางที่ต้องการโดยวัตถุรับรองความถูกต้องเช่น db.auth_user. แอปพลิเคชันนั่งร้านเริ่มต้นได้รับการออกแบบมาเพื่อลดจำนวนไฟล์ไม่ให้เป็นแบบแยกส่วน โดยเฉพาะอย่างยิ่งไฟล์โมเดลdb.pyมีการกำหนดค่าซึ่งในสภาพแวดล้อมการใช้งานจริงจะถูกเก็บไว้ในไฟล์แยกต่างหาก
ที่นี่เราขอแนะนำให้สร้างไฟล์กำหนดค่า -
from gluon.storage import Storage
settings = Storage()
settings.production = False
if
settings.production:
settings.db_uri = 'sqlite://production.sqlite'
settings.migrate = False
else:
settings.db_uri = 'sqlite://development.sqlite'
settings.migrate = True
settings.title = request.
settings.subtitle = 'write something here'
settings.author = 'you'
settings.author_email = '[email protected]'
settings.keywords = ''
settings.description = ''
settings.layout_theme = 'Default'
settings.security_key = 'a098c897-724b-4e05-b2d8-8ee993385ae6'
settings.email_server = 'localhost'
settings.email_sender = '[email protected]'
settings.email_login = ''
settings.login_method = 'local'
settings.login_config = ''
การรับรองความถูกต้อง
เกือบทุกแอปพลิเคชันต้องสามารถตรวจสอบสิทธิ์ผู้ใช้และตั้งค่าสิทธิ์ได้ web2py มาพร้อมกับการควบคุมการเข้าถึงตามบทบาทที่กว้างขวางและปรับแต่งได้mechanism.web2py. นอกจากนี้ยังรองรับโปรโตคอลเช่น CAS, OpenID, OAuth 1.0, LDAP, PAM, X509 และอื่น ๆ อีกมากมาย
web2py มีกลไกที่เรียกว่า Role Based Access Control mechanism (RBAC) ซึ่งเป็นแนวทางในการ จำกัด การเข้าถึงระบบสำหรับผู้ใช้ที่ได้รับอนุญาต คลาส web2py ที่ใช้ RBAC เรียกว่า Auth
ดูสคีมาที่ระบุด้านล่าง
Auth กำหนดตารางต่อไปนี้ -
ซีเนียร์ No | ชื่อตารางและคำอธิบาย |
---|---|
1 | auth_user จัดเก็บชื่อที่อยู่อีเมลรหัสผ่านและสถานะของผู้ใช้ |
2 | auth_group จัดเก็บกลุ่มหรือบทบาทสำหรับผู้ใช้ในโครงสร้างแบบกลุ่มต่อกลุ่ม |
3 | auth_membership จัดเก็บข้อมูลของผู้ใช้ลิงก์และกลุ่มในโครงสร้างแบบกลุ่มต่อกลุ่ม |
4 | auth_permission ตารางจะเชื่อมโยงกลุ่มและสิทธิ์ |
5 | auth_event บันทึกการเปลี่ยนแปลงในตารางอื่นและการเข้าถึงสำเร็จ |
6 | auth_cas ใช้สำหรับ Central Authentication Service |
การปรับแต่ง Auth
มีสองวิธีในการปรับแต่ง Auth
กำหนดแบบกำหนดเอง db.auth_user ตารางตั้งแต่เริ่มต้น
ให้ web2py กำหนด auth ตาราง.
ให้เราดูวิธีสุดท้ายในการกำหนด authตาราง. ในdb.py รุ่นแทนที่บรรทัดต่อไปนี้ -
auth.define_tables()
แทนที่ด้วยรหัสต่อไปนี้ -
auth.settings.extra_fields['auth_user'] = [
Field('phone_number',requires = IS_MATCH('\d{3}\-\d{3}\-\d{4}')),
Field('address','text')
]
auth.define_tables(username = True)
สมมติฐานคือผู้ใช้แต่ละคนประกอบด้วยหมายเลขโทรศัพท์ชื่อผู้ใช้และที่อยู่
auth.settings.extra_fieldsเป็นพจนานุกรมของช่องพิเศษ คีย์คือชื่อของตารางรับรองความถูกต้องที่จะเพิ่มฟิลด์พิเศษ ค่าคือรายการของเขตข้อมูลเพิ่มเติม ที่นี่เราได้เพิ่มฟิลด์พิเศษสองฟิลด์phone_number and address.
usernameจะต้องได้รับการปฏิบัติเป็นพิเศษเนื่องจากมีส่วนเกี่ยวข้องกับกระบวนการตรวจสอบสิทธิ์ซึ่งโดยปกติจะขึ้นอยู่กับฟิลด์อีเมล เมื่อส่งอาร์กิวเมนต์ชื่อผู้ใช้ไปยังบรรทัดต่อไปนี้จะมีการแจ้งให้ web2py ทราบว่าเราต้องการฟิลด์ชื่อผู้ใช้และเราต้องการใช้เพื่อเข้าสู่ระบบแทนฟิลด์อีเมล มันทำหน้าที่เหมือนคีย์หลัก
auth.define_tables(username = True)
ชื่อผู้ใช้ถือเป็นค่าเฉพาะ อาจมีบางกรณีที่การลงทะเบียนเกิดขึ้นนอกแบบฟอร์มการลงทะเบียนปกติ นอกจากนี้ยังเกิดขึ้นเพื่อให้ผู้ใช้ใหม่ถูกบังคับให้เข้าสู่ระบบเพื่อลงทะเบียนให้เสร็จสมบูรณ์
ซึ่งสามารถทำได้โดยใช้ฟิลด์จำลอง complete_registration ที่ตั้งค่าเป็น False ตามค่าเริ่มต้นและตั้งค่าเป็น True เมื่อพวกเขาอัปเดตโปรไฟล์
auth.settings.extra_fields['auth_user'] = [
Field('phone_number',requires = IS_MATCH('\d{3}\-\d{3}\-\d{4}'),
comment = "i.e. 123-123-1234"),
Field('address','text'),
Field('complete_registration',default = False,update = True,
writable = False, readable = False)
]
auth.define_tables(username = True)
สถานการณ์นี้อาจตั้งใจให้ผู้ใช้ใหม่เมื่อเข้าสู่ระบบเพื่อลงทะเบียนให้เสร็จสมบูรณ์
ใน db.pyในโฟลเดอร์โมเดลเราสามารถต่อท้ายรหัสต่อไปนี้ -
if auth.user and not auth.user.complete_registration:
if not (request.controller,request.function) == ('default','user'):
redirect(URL('default','user/profile'))
การดำเนินการนี้จะบังคับให้ผู้ใช้ใหม่แก้ไขโปรไฟล์ของตนตามข้อกำหนด
การอนุญาต
เป็นกระบวนการให้สิทธิ์การเข้าถึงบางอย่างหรือให้สิทธิ์บางอย่างแก่ผู้ใช้
ใน web2py เมื่อสร้างหรือลงทะเบียนผู้ใช้ใหม่กลุ่มใหม่จะถูกสร้างขึ้นเพื่อให้มีผู้ใช้ บทบาทของผู้ใช้ใหม่เรียกตามอัตภาพว่า“user_[id]” โดยที่ id คือการระบุเฉพาะของผู้ใช้
ค่าเริ่มต้นสำหรับการสร้างกลุ่มใหม่คือ -
auth.settings.create_user_groups = "user_%(id)s"
การสร้างกลุ่มระหว่างผู้ใช้สามารถปิดใช้งานได้โดย -
auth.settings.create_user_groups = None
การสร้างการให้สิทธิ์การเข้าถึงแก่สมาชิกโดยเฉพาะและการอนุญาตสามารถทำได้โดยใช้โปรแกรมด้วยความช่วยเหลือของผู้ดูแลระบบด้วย
การใช้งานบางส่วนมีดังต่อไปนี้ -
ซีเนียร์ No | คำสั่งและการใช้งาน |
---|---|
1 | auth.add_group('role', 'description') ส่งคืน id ของกลุ่มที่สร้างขึ้นใหม่ |
2 | auth.del_group(group_id) ลบกลุ่มที่มีรหัสที่ระบุ |
3 | auth.del_group(auth.id_group('user_7')) ลบกลุ่มผู้ใช้ด้วยรหัสประจำตัวที่กำหนด |
4 | auth.user_group(user_id) ส่งคืนค่า id ของกลุ่มที่เชื่อมโยงโดยไม่ซ้ำกันสำหรับผู้ใช้ที่ระบุ |
5 | auth.add_membership(group_id, user_id) ส่งคืนค่าของ user_id สำหรับ group_id ที่กำหนด |
6 | auth.del_membership(group_id, user_id) ยกเลิกการเข้าถึง member_id ที่กำหนดเช่น user_id จากกลุ่มที่กำหนด |
7 | auth.has_membership(group_id, user_id, role) ตรวจสอบว่า user_id เป็นของกลุ่มที่กำหนดหรือไม่ |
บริการรับรองความถูกต้องส่วนกลาง (CAS)
web2py มีมาตรฐานอุตสาหกรรมคือ Client Authentication Service - CAS สำหรับทั้งไคลเอนต์และเซิร์ฟเวอร์ในตัว web2py เป็นเครื่องมือตรวจสอบสิทธิ์ของบุคคลที่สาม
เป็นโปรโตคอลแบบเปิดสำหรับการตรวจสอบสิทธิ์แบบกระจาย การทำงานของ CAS มีดังนี้ -
หากผู้ใช้เยี่ยมชมเว็บไซต์โปรโตคอลจะตรวจสอบว่าผู้ใช้ได้รับการพิสูจน์ตัวตนหรือไม่
หากผู้ใช้ไม่ได้รับการพิสูจน์ตัวตนกับแอปพลิเคชันโปรโตคอลจะเปลี่ยนเส้นทางไปยังหน้าที่ผู้ใช้สามารถลงทะเบียนหรือเข้าสู่ระบบแอปพลิเคชันได้
หากการลงทะเบียนเสร็จสมบูรณ์ผู้ใช้จะได้รับอีเมล การลงทะเบียนจะไม่สมบูรณ์จนกว่าและเว้นแต่ผู้ใช้จะยืนยันอีเมล
หลังจากลงทะเบียนสำเร็จผู้ใช้จะได้รับการตรวจสอบความถูกต้องด้วยรหัสซึ่งใช้โดยอุปกรณ์ CAS
คีย์นี้ใช้เพื่อรับข้อมูลประจำตัวของผู้ใช้ผ่านการร้องขอ HTTP ซึ่งตั้งค่าไว้เบื้องหลัง
web2py ให้การสนับสนุนโปรโตคอลต่างๆเช่น XML, JSON, RSS, CSV, XMLRPC, JSONRPC, AMFRPC และ SOAP แต่ละโปรโตคอลเหล่านั้นได้รับการสนับสนุนในหลายวิธีและเราสร้างความแตกต่างระหว่าง -
- การแสดงผลลัพธ์ของฟังก์ชันในรูปแบบที่กำหนด
- การเรียกขั้นตอนระยะไกล
การแสดงพจนานุกรม
พิจารณารหัสต่อไปนี้ซึ่งรักษาการนับของเซสชัน
def count():
session.counter = (session.counter or 0) + 1
return dict(counter = session.counter, now = request.now)
ฟังก์ชันข้างต้นจะเพิ่มจำนวนการนับและเมื่อผู้ใช้เข้าชมเพจ สมมติว่าฟังก์ชันที่กำหนดถูกกำหนดไว้ใน“default.py”ตัวควบคุมแอปพลิเคชัน web2py สามารถขอเพจได้ด้วย URL ต่อไปนี้ -http://127.0.0.1:8000/app/default/count
web2py สามารถแสดงหน้าข้างบนในโปรโตคอลที่แตกต่างกันและโดยการเพิ่มส่วนขยายให้กับ URL เช่น -
http://127.0.0.1:8000/app/default/count.html
http://127.0.0.1:8000/app/default/count.xml
http://127.0.0.1:8000/app/default/count.json
พจนานุกรมที่ส่งคืนโดยการดำเนินการข้างต้นจะแสดงผลใน HTML, XML และ JSON
การเรียกขั้นตอนระยะไกล
web2py framework มีกลไกที่แปลงฟังก์ชันเป็นบริการบนเว็บ กลไกที่อธิบายไว้ที่นี่แตกต่างจากกลไกที่อธิบายไว้ก่อนหน้านี้เนื่องจาก -
- การรวมอาร์กิวเมนต์ในฟังก์ชัน
- ต้องกำหนดฟังก์ชันในแบบจำลอง
- มันบังคับใช้หลักการตั้งชื่อ URL ที่เข้มงวดมากขึ้น
- ใช้งานได้กับชุดโปรโตคอลคงที่และสามารถขยายได้ง่าย
- ในการใช้คุณสมบัตินี้จำเป็นต้องอิมพอร์ตและเริ่มต้นเซอร์วิสอ็อบเจ็กต์
ในการใช้กลไกนี้ในตอนแรกคุณต้องอิมพอร์ตและสร้างอินสแตนซ์อ็อบเจ็กต์บริการ
from gluon.tools import Service
service = Service()
สิ่งนี้ถูกนำไปใช้ในไฟล์ "db.py" ไฟล์โมเดลในแอปพลิเคชันนั่งร้าน Db.py model เป็นโมเดลเริ่มต้นใน web2py framework ซึ่งโต้ตอบกับฐานข้อมูลและคอนโทรลเลอร์เพื่อให้ได้ผลลัพธ์ที่ต้องการสำหรับผู้ใช้
หลังจากใช้งานแล้วบริการในโมเดลสามารถเข้าถึงได้จากคอนโทรลเลอร์ตามที่ต้องการ
ตัวอย่างต่อไปนี้แสดงการใช้งานการเรียกโพรซีเดอร์ระยะไกลโดยใช้บริการเว็บและอื่น ๆ อีกมากมาย
บริการเว็บ
Web Services สามารถกำหนดเป็นวิธีมาตรฐานในการรวมแอปพลิเคชันบนเว็บโดยใช้โปรโตคอลเช่น XML, SOAP, WSDL และ UDDI
web2py รองรับส่วนใหญ่ แต่การผสานรวมจะค่อนข้างยุ่งยาก
การใช้บริการ web2py JSON ด้วย jQuery
มีหลายวิธีในการส่งคืน JSON ในรูปแบบ web2py แต่ในที่นี้เราจะพิจารณากรณีของบริการ JSON ตัวอย่างเช่น -
def consumer():return dict()@service.json
def get_days():return ["Sun", "Mon", "Tues", "Wed", "Thurs", "Fri", "Sat"]
def call():return service()
ที่นี่เราสังเกตว่า -
ฟังก์ชันจะส่งคืนพจนานุกรมว่างเปล่าเพื่อแสดงมุมมองซึ่งจะใช้บริการ
get_days กำหนดบริการและการเรียกใช้ฟังก์ชันจะแสดงบริการที่ลงทะเบียนทั้งหมด
get_days ไม่จำเป็นต้องอยู่ในคอนโทรลเลอร์และสามารถอยู่ในโมเดลได้
call จะอยู่ในตัวควบคุมนั่งร้าน default.py เสมอ
ดูด้วยการกระทำของผู้บริโภคมีดังนี้ -
{{extend 'layout.html'}}
<div id = "target"></div>
<script>
jQuery.getJSON("{{= URL('call',args = ['json','get_days'])}}",
function(msg){
jQuery.each(msg, function(){ jQuery("#target").
append(this + "<br />"); } )
}
);
</script>
อาร์กิวเมนต์แรกของ jQuery.getJSON คือ URL ของบริการต่อไปนี้ - http://127.0.0.1:8000/app/default/call/json/get_days
สิ่งนี้เป็นไปตามรูปแบบเสมอ -
http://<domain>/<app>/<controller>/call/<type>/<service>
URL อยู่ระหว่าง {{...}}เนื่องจากได้รับการแก้ไขที่ฝั่งเซิร์ฟเวอร์ในขณะที่ทุกอย่างถูกดำเนินการที่ฝั่งไคลเอ็นต์ อาร์กิวเมนต์ที่สองของjQuery.getJSON คือการโทรกลับซึ่งจะส่งผ่านการตอบสนอง JSON
ในกรณีนี้การเรียกกลับจะวนซ้ำในแต่ละรายการในการตอบกลับ (รายการวันในสัปดาห์เป็นสตริง) และต่อท้ายแต่ละสตริงตามด้วย <br/> ไปที่ <div id = "target">.
ด้วยวิธีนี้ web2py จะจัดการการใช้งานบริการเว็บโดยใช้ jQuery.getJSON.
ในบทนี้เราจะพูดถึงตัวอย่างการรวมของ jQuery ปลั๊กอินกับ web2py. ปลั๊กอินเหล่านี้ช่วยในการสร้างแบบฟอร์มและตารางมากขึ้นและเป็นมิตรกับผู้ใช้ซึ่งจะช่วยปรับปรุงการใช้งานแอปพลิเคชันของคุณ
โดยเฉพาะอย่างยิ่งเราจะได้เรียนรู้
วิธีปรับปรุงเมนูแบบเลื่อนลงแบบเลือกหลายรายการด้วยปุ่มเพิ่มตัวเลือกแบบโต้ตอบ
วิธีแทนที่ช่องป้อนข้อมูลด้วยแถบเลื่อนและ
วิธีแสดงข้อมูลแบบตารางโดยใช้ jqGrid และ WebGrid.
แม้ว่า web2py จะเป็นส่วนประกอบการพัฒนาฝั่งเซิร์ฟเวอร์ไฟล์ welcome แอพนั่งร้านรวมถึงฐาน jQueryห้องสมุด. แอปพลิเคชัน web2py สำหรับนั่งร้าน "ยินดีต้อนรับ" นี้มีไฟล์ที่เรียกว่าviews/web2py_ajax.html.
เนื้อหาของมุมมองมีดังนี้ -
<script type = "text/javascript"><!--
// These variables are used by the web2py_ajax_init function in web2py_ajax.js
(which is loaded below).
var w2p_ajax_confirm_message = "{{= T('Are you sure you want to delete this object?')}}";
var w2p_ajax_disable_with_message = "{{= T('Working...')}}";
var w2p_ajax_date_format = "{{= T('%Y-%m-%d')}}";
var w2p_ajax_datetime_format = "{{= T('%Y-%m-%d %H:%M:%S')}}";
var ajax_error_500 = '{{=T.M('An error occured, please [[reload %s]] the page') %
URL(args = request.args, vars = request.get_vars) }}'
//--></script>
{{
response.files.insert(0,URL('static','js/jquery.js'))
response.files.insert(1,URL('static','css/calendar.css'))
response.files.insert(2,URL('static','js/calendar.js'))
response.files.insert(3,URL('static','js/web2py.js'))
response.include_meta()
response.include_files()
}}
ไฟล์นี้ประกอบด้วยการนำ JavaScript และ AJAX ไปใช้งาน web2py จะป้องกันไม่ให้ผู้ใช้ใช้ไลบรารี AJAX อื่น ๆ เช่น Prototype, ExtJS เนื่องจากสังเกตอยู่เสมอว่าการใช้ไลบรารีดังกล่าวทำได้ง่ายกว่า
JQuery Effects
การแสดงผลเริ่มต้นของ <select multiple = "true">..</select>ถือว่าไม่ง่ายต่อการใช้งานโดยเฉพาะอย่างยิ่งเมื่อจำเป็นต้องเลือกตัวเลือกที่ไม่ติดกัน สิ่งนี้ไม่สามารถเรียกได้ว่าเป็นข้อบกพร่องของ HTML แต่เป็นการออกแบบที่ไม่ดีของเบราว์เซอร์ส่วนใหญ่ การนำเสนอของการเลือกหลายรายการสามารถเขียนทับได้โดยใช้ JavaScript สามารถใช้งานได้โดยใช้ปลั๊กอิน jQuery ที่เรียกว่าjquery.multiselect.js.
สำหรับสิ่งนี้ผู้ใช้ควรดาวน์โหลดปลั๊กอิน jquery.muliselect.js จาก http://abeautifulsite.net/2008/04/jquery-multiselect, และวางไฟล์ที่เกี่ยวข้องลงใน static/js/jquery.multiselect.js และ static/css/jquery.multiselect.css.
ตัวอย่าง
ควรเพิ่มโค้ดต่อไปนี้ในมุมมองที่เกี่ยวข้องก่อนหน้านี้ {{extend ‘layout.html’}}
{{
response.files.append('https://ajax.googleapis.com/ajax\
/libs/jqueryui/1.8.9/jquery-ui.js')
response.files.append('https://ajax.googleapis.com/ajax\
/libs/jqueryui/1.8.9/themes/ui-darkness/jquery-ui.css')
response.files.append(URL('static','js/jquery.multiSelect.js'))
response.files.append(URL('static','css/jquery.\multiSelect.css'))
}}
วางสิ่งต่อไปนี้ไว้หลัง {{extend 'layout.html'}} -
<script>
jQuery(document).ready(function(){jQuery('[multiple]').multiSelect();});
</script>
สิ่งนี้จะช่วยให้มีสไตล์ multiselect สำหรับแบบฟอร์มที่กำหนด
ตัวควบคุม
def index():
is_fruits = IS_IN_SET(['Apples','Oranges','Bananas','Kiwis','Lemons'], multiple = True)
form = SQLFORM.factory(Field('fruits','list:string', requires = is_fruits))
if form.accepts(request,session):response.flash = 'Yummy!'
return dict(form = form)
การดำเนินการนี้สามารถลองได้ด้วยมุมมองต่อไปนี้ -
{{
response.files.append('https://ajax.googleapis.com/ajax\
/libs/jqueryui/1.8.9/jquery-ui.js')
response.files.append('https://ajax.googleapis.com/ajax\
/libs/jqueryui/1.8.9/themes/ui-darkness/jquery-ui.css')
response.files.append(URL('static','js/jquery.multiSelect.js'))
response.files.append(URL('static','css/jquery.\multiSelect.css'))
}}
{{extend 'layout.html}}
<script>
jQuery(document).ready(function(){jQuery('[multiple]'). multiSelect();});
</script>
{{= form}}
ภาพหน้าจอของผลลัพธ์มีดังนี้ -
เหตุการณ์ Jquery ที่มีประโยชน์บางส่วนแสดงอยู่ในตารางต่อไปนี้ -
ซีเนียร์ | เหตุการณ์และการใช้งาน |
---|---|
1 | onchange จะทำงานเมื่อองค์ประกอบเปลี่ยนไป |
2 | onsubmit จะทำงานเมื่อส่งแบบฟอร์ม |
3 | onselect ที่จะทำงานเมื่อเลือกองค์ประกอบ |
4 | onblur จะทำงานเมื่อองค์ประกอบสูญเสียโฟกัส |
5 | onfocus จะทำงานเมื่อองค์ประกอบได้รับโฟกัส |
JQuery และ Ajax-jqGrid
jqGrid เป็นตัวควบคุม JavaScript ที่เปิดใช้งาน Ajax ที่สร้างขึ้นบน jQuery ซึ่งมีโซลูชันสำหรับการแสดงและจัดการข้อมูลแบบตาราง jqGrid เป็นโซลูชันฝั่งไคลเอ็นต์และโหลดข้อมูลแบบไดนามิกผ่านการเรียกกลับของ Ajax ดังนั้นจึงมีการแบ่งหน้าป๊อปอัปการค้นหาการแก้ไขแบบอินไลน์และอื่น ๆ
jqGrid รวมอยู่ใน PluginWiki แต่ที่นี่เราจะพูดถึงมันเป็นแบบสแตนด์อโลนสำหรับโปรแกรม web2py ที่ไม่ใช้ปลั๊กอิน jqGrid สมควรได้รับหนังสือของตัวเอง แต่ในที่นี้เราจะพูดถึงคุณสมบัติพื้นฐานและการรวมที่ง่ายที่สุดเท่านั้น
ไวยากรณ์ของ jqGrid จะเป็นดังนี้ -
def JQGRID(
table, fieldname = None,
fieldvalue = None, col_widths = [],
colnames = [], _id = None, fields = [],
col_width = 80, width = 700,
height = 300, dbname = 'db'
):
ส่วนประกอบถูกกำหนดให้เป็นส่วนการทำงานของหน้าเว็บซึ่งทำงานได้โดยอัตโนมัติ สามารถประกอบด้วยโมดูลตัวควบคุมและมุมมองซึ่งฝังอยู่ในเว็บเพจ ส่วนประกอบในแอปพลิเคชันต้องเป็นแท็กที่แปลและประสิทธิภาพถือว่าไม่ขึ้นกับโมดูล
ใน web2py โฟกัสหลักคือการใช้คอมโพเนนต์ที่โหลดในเพจและซึ่งสื่อสารกับคอมโพเนนต์คอนโทรลเลอร์ผ่าน AJAX
web2py มีฟังก์ชันซึ่งเรียกว่า LOAD ฟังก์ชันซึ่งทำให้การใช้งานส่วนประกอบเป็นเรื่องง่ายโดยไม่ต้องเขียนโปรแกรม JavaScript หรือ AJAX อย่างชัดเจน
พิจารณาเว็บแอปพลิเคชันง่ายๆคือ“test” ที่ขยายแอปพลิเคชัน web2py ด้วยโมเดลที่กำหนดเองในไฟล์“models/db_comments.py”.
db.define_table(
'comment_post', Field('body','text',
label = 'Your comment'),auth.signature
)
โค้ดด้านบนจะสร้างตาราง“comment_post” ด้วยนิยามตารางที่เหมาะสม การดำเนินการจะดำเนินการด้วยความช่วยเหลือของฟังก์ชันใน“controllers/comments.py”.
def post():
return dict(
form = SQLFORM(db.comment_post).process(),
comments = db(db.comment_post).select()
)
มุมมองที่เกี่ยวข้องจะแสดงเป็น -
{{extend 'layout.html'}}
{{for post in comments:}}
<div class = "post">
On {{= post.created_on}} {{= post.created_by.first_name}}
says <span class = "post_body">{{= post.body}}</span>
</div>
{{pass}}
{{= form}}
หน้านี้สามารถเข้าถึงได้โดยใช้ URL ที่กำหนด - http://127.0.0.1:8000/test/comments/post
วิธีการที่กล่าวถึงข้างต้นเป็นวิธีการเข้าถึงมุมมองแบบดั้งเดิมซึ่งสามารถเปลี่ยนแปลงได้ด้วยการใช้ฟังก์ชัน LOAD
สามารถทำได้โดยการสร้างมุมมองใหม่ด้วยส่วนขยาย ".load" ที่ไม่ขยายเค้าโครง
มุมมองใหม่ที่สร้างขึ้นจะเป็น "views/comments/post.load" -
<div class = "post">
On {{= post.created_on}} {{= post.created_by.first_name}}
says <blockquote class = "post_body">{{= post.body}}</blockquote>
</div>
{{pass}}
{{= form}}
URL ในการเข้าถึงเพจจะเป็น - http://127.0.0.1:8000/test/comments/post.load
ส่วนประกอบ LOAD สามารถฝังลงในหน้าอื่น ๆ ของแอปพลิเคชัน web2py สามารถทำได้โดยใช้คำสั่งต่อไปนี้
{{= LOAD('comments','post.load',ajax = True)}}
ตัวอย่างเช่นไฟล์ Controllers สามารถแก้ไขเป็น -
def index():
return dict()
ใน Viewเราสามารถเพิ่มส่วนประกอบ -
{{extend 'layout.html'}}
{{= LOAD('comments','post.load',ajax = True)}}
หน้านี้สามารถเข้าถึงได้ด้วย URL - http://127.0.0.1:8000/test/default/index
ปลั๊กอินคอมโพเนนต์
ปลั๊กอินคอมโพเนนต์คือปลั๊กอินที่กำหนดโดยเฉพาะ Components. คอมโพเนนต์เข้าถึงฐานข้อมูลโดยตรงด้วยนิยามโมเดล
ดังที่กล่าวไว้ในตัวอย่างก่อนหน้าคอมโพเนนต์ความคิดเห็นในไฟล์ comments_plugin สามารถทำได้ในไฟล์ Models มาตรา -
"models/plugin_comments.py"-
db.define_table(
'plugin_comments_comment',
Field('body','text', label = 'Your comment'),
auth.signature
)
Controller จะรวมปลั๊กอินต่อไปนี้ -
def plugin_comments():
return LOAD('plugin_comments','post',ajax = True)
การติดตั้ง web2py ใน Ubuntu (Linux)
ขั้นตอนต่อไปนี้ใช้สำหรับการติดตั้ง web2py ใน Ubuntu Desktop
Step 1 - ดาวน์โหลด web2py
cd /home
mkdir www-dev
cd www-dev
wget http://www.web2py.com/examples/static/web2py_src.zip
Step 2 - หลังจากดาวน์โหลดเสร็จแล้วให้ทำการแตกไฟล์
unzip -x web2py_src.zip
Step 3 - เลือกที่จะติดตั้งไลบรารี tk สำหรับ Python หากคุณต้องการเข้าถึง GUI
sudo apt-get install python-tk
Step 4 - ในการเริ่ม web2py ให้เข้าไปที่ไดเร็กทอรี web2py และเรียกใช้ web2py
cd web2py
python web2py.py
GUI จะปรากฏดังนี้ -
หลังจากการติดตั้งทุกครั้งที่คุณเรียกใช้ web2py จะขอให้คุณเลือกรหัสผ่าน รหัสผ่านนี้เป็นรหัสผ่านสำหรับผู้ดูแลระบบของคุณ หากรหัสผ่านเว้นว่างไว้อินเทอร์เฟซการดูแลระบบจะปิดใช้งาน
เมื่อเซิร์ฟเวอร์เริ่มทำงาน web2py จะเปลี่ยนเส้นทางไปยังหน้าจอพร้อม URL ดังต่อไปนี้ - http://127.0.0.1:8000/
สิ่งนี้จะสรุปได้ว่า web2py ทำงานได้อย่างสมบูรณ์แบบบนเดสก์ท็อป Ubuntu
การปรับใช้การผลิตใน Ubuntu
Step 1 - การติดตั้งโมดูลทั้งหมดที่จำเป็นในการเรียกใช้ web2py
การติดตั้ง postgreSQL
sudo apt-get install postgresql
Unzip และเปิด ssh-server
sudo apt-get install unzip
sudo apt-get install openssh-server
การติดตั้ง Apache 2 และ mod-wsgi
sudo apt-get install apache2
sudo apt-get install libapache2-mod-wsgi
Step 2 - การติดตั้ง web2py ใน / home / www-data
สิ่งนี้ช่วยสำหรับการปรับใช้ที่เหมาะสมในสภาพแวดล้อมการผลิต
sudo apt-get install unzip
sudo apt-get install openssh-server
cd /home
sudo mkdir www-data
cd www-data
รับแหล่งที่มา web2py จากเว็บไซต์ web2py -
sudo wget http://web2py.com/examples/static/web2py_src.zip
sudo unzip web2py_src.zip
sudo chown -R www-data:www-data web2py
Step 3- สร้างใบรับรองที่ลงนามด้วยตนเอง ใบรับรอง SSL ควรได้รับจากผู้ออกใบรับรองที่เชื่อถือได้ ดูแลโฟลเดอร์ SSL ที่มีใบรับรองอยู่
Step 4 - แก้ไขการกำหนดค่า apache ตามความต้องการของสภาพแวดล้อมการผลิต
Step 5 - รีสตาร์ทเซิร์ฟเวอร์ Apache และตรวจสอบว่าสภาพแวดล้อมการผลิตใช้งานได้กับที่อยู่ IP ที่กำหนดหรือไม่
การติดตั้ง web2py บน Windows
แม้ว่าจะมีการแจกแจงไบนารีสำหรับสภาพแวดล้อม Windows (ไฟล์ปฏิบัติการและไลบรารีมาตรฐาน) แต่ web2py เป็นโอเพ่นซอร์สและสามารถใช้ได้กับการติดตั้ง Python แบบปกติ
วิธีนี้ช่วยให้สามารถทำงานกับ web2py รุ่นล่าสุดและปรับแต่งโมดูล python ที่จะใช้
Step 1 - ดาวน์โหลดแพ็คเกจต้นทางจากเว็บไซต์อย่างเป็นทางการของ web2py - http://www.web2py.com/examples/static/web2py_src.zip และเปิดเครื่องรูด
เนื่องจาก web2py ไม่ต้องการการติดตั้งผู้ใช้จึงสามารถเปิดเครื่องรูดในโฟลเดอร์ใดก็ได้
Step 2 - ในการเริ่มต้นให้ดับเบิลคลิก web2py.py. จากคอนโซล -
cd c:\web2py
c:\python27\python.exe web2py.py
Step 3- สามารถเพิ่มพารามิเตอร์บรรทัดคำสั่งได้ที่นี่ (−a เพื่อตั้งรหัสผ่านผู้ดูแลระบบ, −p เพื่อระบุพอร์ตสำรอง) ตัวเลือกการเริ่มต้นสามารถมองเห็นได้ผ่าน -
C:\web2py>c:\python27\python.exe web2py.py --help
บันทึก
web2py เขียนด้วย Python ซึ่งเป็นภาษาแบบพกพาตีความและไดนามิกที่ไม่ต้องการการคอมไพล์หรือการติดตั้งที่ซับซ้อนในการรัน
มันใช้เครื่องเสมือน (เช่น Java และ. Net) และสามารถคอมไพล์ซอร์สโค้ดไบต์ของคุณอย่างโปร่งใสได้ทันทีเมื่อคุณรันสคริปต์ของคุณ
ฟังก์ชันใน web2py สำหรับฐานข้อมูลและการทดสอบ
เป็นซอฟต์แวร์ที่เรียกว่า SQLDesigner ซึ่งช่วยในการสร้างแบบจำลอง web2py และสร้างรหัสที่เกี่ยวข้อง ด้านล่างนี้เป็นภาพหน้าจอบางส่วน -
SQLDesigner ช่วยในการรักษาความสัมพันธ์ของตารางในลักษณะง่ายๆและสร้างรหัสที่เกี่ยวข้องในแบบจำลองของแอปพลิเคชันที่กำหนด
การทดสอบการทำงาน
การทดสอบการทำงานเกี่ยวข้องกับการทดสอบการทำงานของส่วนประกอบหรือระบบโดยรวม สามารถขึ้นอยู่กับความต้องการและกระบวนการทางธุรกิจ
web2py มาพร้อมกับโมดูล gluon.contrib.webclientซึ่งทำการทดสอบการทำงานในแอปพลิเคชัน web2py ระยะไกลและในพื้นที่ โดยพื้นฐานแล้วได้รับการออกแบบมาเพื่อทำความเข้าใจเซสชัน web2py และ postbacks
สิ่งที่ต้องมีคือการนำเข้าแพ็คเกจเพื่อให้การทดสอบการทำงานถูกนำไปใช้ในโมดูลที่กำหนด
ไวยากรณ์ที่จะนำเข้าแพคเกจมีดังนี้ -
from gluon.contrib.webclient import WebClient
ในบทที่แล้วมีข้อมูลครบถ้วนเกี่ยวกับการนำ web2py ไปใช้กับเครื่องมือต่างๆ ข้อกังวลหลักในการพัฒนาแอปพลิเคชัน web2py รวมถึงความปลอดภัยจากมุมมองของผู้ใช้
คุณสมบัติเฉพาะของ web2py มีดังนี้ -
ผู้ใช้สามารถเรียนรู้การใช้งานได้อย่างง่ายดาย ไม่ต้องมีการติดตั้งและการอ้างอิง
มีความเสถียรตั้งแต่วันที่เปิดตัว
web2py มีน้ำหนักเบาและมีไลบรารีสำหรับ Data Abstraction Layer และภาษาเทมเพลต
ทำงานด้วยความช่วยเหลือของ Web Server Gateway Interface ซึ่งทำหน้าที่สื่อสารระหว่างเว็บเซิร์ฟเวอร์และแอปพลิเคชัน
Open Web Application Security Project (OWASP) คือชุมชนซึ่งแสดงรายการการละเมิดความปลอดภัยของเว็บแอปพลิเคชัน
การละเมิดความปลอดภัย
ในส่วนที่เกี่ยวกับ OWASP ปัญหาที่เกี่ยวข้องกับเว็บแอปพลิเคชันและวิธีที่ web2py เอาชนะปัญหาเหล่านี้จะกล่าวถึงด้านล่าง
การเขียนสคริปต์ข้ามด้าน
เรียกอีกอย่างว่า XSS เกิดขึ้นเมื่อใดก็ตามที่แอปพลิเคชันรับข้อมูลที่ผู้ใช้ให้มาและส่งไปยังเบราว์เซอร์ของผู้ใช้โดยไม่ต้องเข้ารหัสหรือตรวจสอบความถูกต้องของเนื้อหา ผู้โจมตีเรียกใช้สคริปต์เพื่อฉีดเวิร์มและไวรัสโดยใช้สคริปต์ข้ามฝั่ง
web2py ช่วยในการป้องกัน XSS โดยการป้องกันตัวแปรที่แสดงผลทั้งหมดในไฟล์ View.
การรั่วไหลของข้อมูล
บางครั้งแอปพลิเคชันจะรั่วไหลข้อมูลเกี่ยวกับการทำงานภายในความเป็นส่วนตัวและการกำหนดค่า ผู้โจมตีใช้สิ่งนี้เพื่อละเมิดข้อมูลที่ละเอียดอ่อนซึ่งอาจนำไปสู่การโจมตีที่ร้ายแรง
web2py ป้องกันสิ่งนี้โดยระบบตั๋ว บันทึกข้อผิดพลาดทั้งหมดและออกตั๋วให้กับผู้ใช้ที่มีการลงทะเบียนข้อผิดพลาด ข้อผิดพลาดเหล่านี้สามารถเข้าถึงได้โดยผู้ดูแลระบบเท่านั้น
การตรวจสอบสิทธิ์เสีย
ข้อมูลประจำตัวของบัญชีมักไม่ได้รับการปกป้อง ผู้โจมตีประนีประนอมกับรหัสผ่านโทเค็นการตรวจสอบความถูกต้องเพื่อขโมยข้อมูลประจำตัวของผู้ใช้
web2py จัดเตรียมกลไกสำหรับอินเทอร์เฟซการดูแลระบบ นอกจากนี้ยังบังคับให้ใช้เซสชันที่ปลอดภัยเมื่อไคลเอนต์ไม่ใช่“ localhost”
การสื่อสารที่ไม่ปลอดภัย
บางครั้งแอปพลิเคชันไม่สามารถเข้ารหัสการรับส่งข้อมูลเครือข่ายได้ จำเป็นต้องจัดการการรับส่งข้อมูลเพื่อปกป้องการสื่อสารที่ละเอียดอ่อน
web2py จัดเตรียมใบรับรองที่เปิดใช้งาน SSL เพื่อให้การเข้ารหัสการสื่อสาร นอกจากนี้ยังช่วยรักษาการสื่อสารที่ละเอียดอ่อน
ข้อ จำกัด ในการเข้าถึง URL
โดยปกติเว็บแอปพลิเคชันจะปกป้องฟังก์ชันการทำงานที่ละเอียดอ่อนโดยป้องกันไม่ให้แสดงลิงก์และ URL แก่ผู้ใช้บางราย ผู้โจมตีสามารถพยายามละเมิดข้อมูลที่ละเอียดอ่อนบางอย่างโดยการจัดการ URL ด้วยข้อมูลบางอย่าง
ใน wb2py URL จะแมปกับโมดูลและฟังก์ชันแทนที่จะเป็นไฟล์ที่กำหนด นอกจากนี้ยังมีกลไกซึ่งระบุว่าฟังก์ชันใดเป็นสาธารณะและได้รับการดูแลเป็นส่วนตัว ซึ่งจะช่วยในการแก้ไขปัญหา