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 บางส่วนมีการระบุไว้ด้านล่าง

ชื่อ การใช้งาน ตัวอย่าง
ตัวช่วยนี้ใช้เพื่อสร้างลิงก์ สอดคล้องกับแท็กจุดยึด
[
(A('Home', _href = URL('default', 'home')), False, None, []),
...]
ตัวช่วยนี้ช่วยในการทำให้เนื้อหาของข้อความเป็นตัวหนา
B('<hello>', XML('<i>world</i>'), _class = 'test', _id = 0)
ร่างกาย ตัวช่วยนี้ทำให้เนื้อหาของเพจ นอกจากนี้ยังมีตัวดำเนินการคูณเพื่อเพิ่มจำนวนตัวแบ่ง
BR()
รหัส ดำเนินการเน้นไวยากรณ์สำหรับรหัส Python, C, C ++ และ web2py ผู้ช่วยนี้ยังมีความสามารถในการเชื่อมโยงเอกสาร API
CODE('print "hello"', language = 'python').xml()
FIELDSET จะสร้างช่องป้อนข้อมูลร่วมกับป้ายกำกับ
FIELDSET('Height:', INPUT(_name = 'height'), _class = 'test')
ศีรษะ ช่วยในการติดแท็ก <head> แท็กของหน้า HTML
HEAD(TITLE('<hello>'))
IMG ช่วยในการฝังภาพสำหรับหน้า HTML ที่กำหนด
IMG(_src = 'http://example.com/image.png',_alt = 'test')

ผู้ช่วยเหลือที่กำหนดเอง

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