XÂY DỰNG COMPONENT QUẢN LÝ DỰ ÁN PHẦN MỀM CHO WEBSITE JOOMLA

ĐẠI HỌC ĐÀ NẴNG
TRƯỜNG ĐẠI HỌC BÁCH KHOA
KHOA CÔNG NGHỆ THÔNG TIN
Tel. (84-511) 3736 949, Fax. (84-511) 842 771
Website: itf.ud.edu.vn, E-mail:
BÁO CÁO THỰC TẬP TỐT NGHIỆP
NGÀNH CÔNG NGHỆ THÔNG TIN
MÃ NGÀNH : 05115
ĐỀ TÀI : XÂY DỰNG COMPONENT QUẢN LÝ DỰ ÁN PHẦN
MỀM CHO WEBSITE JOOMLA
SINH VIÊN : Nguyễn Thị Thu Thiện
Lê Thị Hồng Thủy
LỚP : 04T4
CBHD : T.S Nguyễn Thanh Bình
Th.S Nguyễn Văn Nguyên
ĐÀ NẴNG, 05/2009
LỜI CẢM ƠN
Tôi chân thành cảm ơn Thầy cô trong khoa Công nghệ thông tin cũng
như các thầy cô giảng dạy trong trường Đại học Bách khoa Đà Nẵng đã
truyền đạt những kiến thức quý báu cho chúng tôi trong những năm học
vừa qua.
Đặc biệt, tôi xin chân thành cảm ơn thầy giáo Nguyễn Thanh Bình và
thầy Nguyễn Văn Nguyên - thuộc khoa Công nghệ thông tin, trường Đại
học Bách khoa Đà Nẵng đã tận tình hướng dẫn, động viên và giúp đỡ tôi
trong suốt thời gian thực hiện đề tài.
Và để có được kết quả như ngày hôm nay, tôi rất biết ơn gia đình đã
động viên, khích lệ, tạo mọi điều kiện thuận lợi nhất trong suốt quá trình
học tập cũng như quá trình thực hiện đề tài tốt nghiệp này.
Xin chân thành cám ơn các bạn trong khoa Công nghệ thông tin – khóa
04, đặc biệt là các bạn lớp 04T4 đã ủng hộ, giúp đỡ, chia sẻ kiến thức, kinh
nghiệm và tài liệu có được cho tôi trong quá trình nghiên cứu và thực hiện

đề tài.
Một lần nữa tôi xin chân thành cảm ơn !
LỜI CAM ĐOAN
Tôi xin cam đoan:
1 Những nội dung trong báo cáo này là do tôi thực hiện dưới sự
hướng dẫn trực tiếp của thầy T.S Nguyễn Thanh Bình và thầy Th.S
Nguyễn Văn Nguyên.
2 Mọi tham khảo dùng trong báo cáo này đều được trích dẫn rõ ràng
tên tác giả, tên công trình, thời gian, địa điểm công bố.
3 Mọi sao chép không hợp lệ, vi phạm quy chế đào tạo, hay gian trá,
tôi xin chịu hoàn toàn trách nhiệm.
Sinh viên,
Ngưyễn Thị Thu Thiện
Lê Thị Hồng Thủy
MỤC LỤC
1 Những nội dung trong báo cáo này là do tôi thực hiện dưới sự hướng dẫn trực tiếp của
thầy T.S Nguyễn Thanh Bình và thầy Th.S Nguyễn Văn Nguyên.....................................iii
2 Mọi tham khảo dùng trong báo cáo này đều được trích dẫn rõ ràng tên tác giả, tên
công trình, thời gian, địa điểm công bố...............................................................................iii
3 Mọi sao chép không hợp lệ, vi phạm quy chế đào tạo, hay gian trá,
tôi xin chịu hoàn toàn trách nhiệm......................................................................................iii
MỞ ĐẦU...........................................................................................................1
.I Đặt vấn đề.......................................................................................................................1
.II Lý do chọn đề tài...........................................................................................................1
.III Hướng nghiên cứu của đề tài.......................................................................................2
.III.1. Về mặt lý thuyết....................................................................................................2
.III.2. Công cụ xây dựng đề tài.......................................................................................2
.IV Dự kiến kết quả đạt được.............................................................................................2
.V Nội dung tóm tắt các chương tiếp theo........................................................................3
CƠ SỞ LÝ THUYẾT.......................................................................................1

.I Giới thiệu về joomla.......................................................................................................1
.I.1. Joomla là gì?............................................................................................................1
.I.2. Các dòng phiên bản của Joomla.............................................................................1
.I.3. Kiến trúc Joomla.....................................................................................................1
.II Một số khái niệm trong Joomla....................................................................................2
.II.1. Front-end và back-end...........................................................................................2
.II.1.1. Front-end............................................................................................................2
.II.1.2. Back-end.............................................................................................................2
.II.2. Template.................................................................................................................2
.II.3. Menu.......................................................................................................................2
.II.4. Các thành phần mở rộng........................................................................................3
.II.4.1. Module................................................................................................................3
.II.4.2. Component.........................................................................................................3
.II.4.3. Mambot (Plug-in)...............................................................................................4
.III Cách xây dựng một component trong Joomla 1.5......................................................4
.III.1. Giới thiệu mô hình MVC.....................................................................................4
.III.2. Cài đặt Joomla MVC............................................................................................5
.III.3. Tạo một component..............................................................................................5
.III.3.1. Tạo một entry point...........................................................................................5
.III.3.2. Tạo Controller..................................................................................................7
.III.3.3. Tạo View............................................................................................................8
.III.3.4. Tạo Template....................................................................................................8
.III.3.5. Đóng gói tất cả- Tạo file hello.xml..................................................................9
.III.4. Bổ sung Model vào component.........................................................................10
.III.4.1. Tạo Model.......................................................................................................10
.III.4.2. Sử sụng Model................................................................................................11
.III.4.3. Bổ sung file vào package ...............................................................................12
.III.5. Sử dụng cơ sở dữ liệu trong component MVC..................................................13
.III.5.1. Lấy dữ liệu......................................................................................................13
.III.5.2. Tạo file SQL trong quá trình cài đặt và gỡ bỏ component...........................15

i
Cập nhật file cài đặt...................................................................................................16
.III.6. Tạo giao diện quản trị trong MVC.....................................................................17
.III.6.1. Tạo Framework cơ sở.....................................................................................17
.III.6.2. Model Hellos...................................................................................................18
.III.6.3. View Hellos.....................................................................................................20
.III.6.4. Template hellos...............................................................................................21
PHÂN TÍCH VÀ THIẾT KẾ HỆ THỐNG...................................................23
.I Phân tích hệ thống thông tin........................................................................................23
.I.1. Sơ đồ Use Case......................................................................................................24
.I.1.1. Use Case “Projects Management”..................................................................24
.I.1.2. Use Case “Tasks Management”.......................................................................24
.I.1.3. Use Case “Delivery Management”..................................................................25
.I.1.4. Use Case “Requirements Management”..........................................................25
.I.1.5. Use Case “Design Management”.....................................................................26
.I.1.6. Use Case “Coding Management”....................................................................26
.I.1.7. Use Case “Risks Management”........................................................................27
.I.1.8. Use Case “File Manage”.................................................................................27
.I.1.9. Use Case “Calendar Management”.................................................................28
.I.1.10. Use Case “Board Management”....................................................................28
.I.1.11. Use Case “Profile Management”...................................................................29
.I.1.12. Use Case “User Management”......................................................................29
.I.2. Danh sách Actor, Phân Quyền và Use Case ........................................................29
.I.2.1. Actor...................................................................................................................29
.I.2.2. Use Case............................................................................................................30
.I.3. Đặc tả chi tiết.........................................................................................................33
.I.3.1. Use Case “Login”.............................................................................................33
.I.3.2. Use Case “Projects Management”..................................................................34
.I.3.3. Use Case “Tasks Management”.......................................................................35
.I.3.4. Use Case “Delivery Management”..................................................................37

.I.3.5. Use Case “Requirements Management”..........................................................38
.I.3.6. Use Case “Design Management”.....................................................................40
.I.3.7. Use Case “Coding Management”....................................................................41
.I.3.8. Use Case “Risks Management”........................................................................43
.I.3.9. Use Case “File Manage”.................................................................................44
.I.3.10. Use Case “Calendar Management”...............................................................45
.I.3.11. Use Case “Board Management”....................................................................47
.I.3.12. Use Case “Profile Management”...................................................................48
.I.3.13. Use Case “User Management”......................................................................49
.I.4. Sơ đồ tuần tự..........................................................................................................51
.I.4.1. Chức năng “Login”..........................................................................................51
.I.4.2. Chức năng “Projects Management”................................................................51
.I.4.3. Chức năng “Tasks Management”....................................................................53
.I.4.4. Chức năng “Delivery Management”...............................................................54
.I.4.5. Chức năng “Requirements Management”.......................................................55
.I.4.6. Chức năng “Design Management”.................................................................56
.I.4.7. Chức năng “Coding Management”.................................................................57
.I.4.8. Chức năng “Risks Management”.....................................................................58
.I.4.9. Chức năng “File Manage”..............................................................................59
.I.4.10. Chức năng “Calendar Management”............................................................60
ii
Mục lục iii
.I.4.11. Chức năng “Board Management”.................................................................61
.I.4.12. Chức năng “User Management”....................................................................62
.I.5. Thiết kế hệ thống...................................................................................................63
.I.5.1. Sơ đồ lớp............................................................................................................63
.I.5.2. Tổ chức dữ liệu..................................................................................................63
XÂY DỰNG CHƯƠNG TRÌNH VÀ KẾT QUẢ THỰC HIỆN...................74
.I Công cụ và môi trường phát triển................................................................................74
.II Một số kết quả đạt được..............................................................................................74

.II.1. Màn hình khởi động.............................................................................................74
.II.2. Màn hình “Tasks Management”..........................................................................75
.III Màn hình “Delivery Management”...........................................................................75
.III.1. Màn hình “Requirements Management”...........................................................76
.III.2. Màn hình “Design Management”......................................................................76
.III.3. Mành hình “Coding Management”....................................................................77
.III.4. Màn hình “Risks Management”.........................................................................77
.III.5. Màn hình “Upload File”.....................................................................................78
.III.6. Màn hình “Calendar Management”...................................................................78
.III.7. Màn hình “Update profile”................................................................................79
.III.8. Màn hình “User Management”..........................................................................79
KẾT LUẬN VÀ HƯỚNG PHÁT TRIỂN.....................................................80
[1] Joseph LeBlanc. “Learning Joomla 1.5 Extension development”,258 tr...................i
[2] PHP Cookbook, 2nd Edition By David Sklar, Adam Trachtenberg..........................i
[3] Ebook “Quản lý dự án công nghệ thông tin” ..............................................................i
[4] Trang web: />[5] Trang web: />Mục lục iv
CHƯƠNG 1
MỞ ĐẦU
.I Đặt vấn đề
Ngày nay, các ứng dụng mã nguồn mở hầu như đáp ứng đầy đủ các yêu cầu sử
dụng của doanh nghiệp. Từ việc triển khai các trang web với Joomla, diễn đàn với
PhpBB, hệ thống elearning Moodle cho đến các ứng dụng quản lý khách hàng
SugarCRM, quản lý dự án... Một trong những thuận lợi đầu tiên của việc ứng dụng
mã nguồn mở là tiết kiệm chi phí. Ngoài ra, khi ứng dụng phần mềm chạy trên nền
web người dùng sẽ dễ dàng truy cập và sử dụng bằng các trình duyệt như Firefox hay
IE mà không cần phải cài đặt gì thêm.
Có nhiều chương trình mã nguồn mở khác nhau, chúng tôi chọn tìm hiểu về hệ
thống quản lý tin Joomla CMS vì Joomla được sử dụng ở khắp mọi nơi trên thế giới,
từ những website cá nhân cho tới những hệ thống website doanh nghiệp có tính phức
tạp cao, cung cấp nhiều dịch vụ và ứng dụng. Joomla có thể dễ dàng cài đặt, dễ dàng

quản lý và có độ tin cậy cao. Joomla giúp mọi người có thể phát triển việc kinh
doanh, học tập, giảng dạy, giới thiệu, quảng bá hình ảnh, dịch vụ, sản phẩm của mình,
của công ty, của trường mình một cách tốt nhất, hiệu quả nhất với chi phí thấp nhất..
Ngoài ra, chương trình này còn được hỗ trợ bởi một cộng đồng rộng lớn, đáp ứng các
yêu cầu về an toàn và bảo mật thông tin...
Để tìm hiểu mô hình hoạt động và cách xây dựng một ứng dụng trên nền Joomla,
chúng tôi xin giới thiệu đề tài « Xây dựng component quản lý dự án phần mềm cho
website Joomla »
Mặc dù ứng dụng đã triển khai được phần lớn các yêu cầu chính trong việc quản lý
một dự án phần mềm, tuy nhiên việc xây dựng một chương trình quản lý dự án là khá
phức tạp. Do đó ứng dụng này không tránh khỏi những thiếu sót, rất mong nhận được
nhiều ý kiến nhận xét của thầy cô và các bạn để chúng tôi có thể rút kinh nghiệm cho
việc xây dựng những ứng dụng thực tế sau này.
.II Lý do chọn đề tài
Trong thuật ngữ của chuyên ngành Kĩ nghệ phần mềm, Quản lý dự án phần mềm
là các hoạt động trong lập kế hoạch, giám sát và điều khiển tài nguyên dự án, thời
gian thực hiện, các rủi ro trong dự án và cả quy trình thực hiện dự án; nhằm đảm bảo
thành công cho dự án. Khi triển khai một dự án phần mềm thì các vấn đề sau thường
xảy ra: thời gian thực hiện quá mức dự kiến, kết quả của dự án không như mong
đợi...Để tránh những vấn đề đó xảy ra đòi hỏi người quản lý phải làm tốt về:
− Quản lý thời gian: lập lịch, kiểm tra đối chiếu quá trình thực hiện dự án với
lịch trình, điều chỉnh lịch trình khi cần thiết
Tên tác giả, LỚP XXX 1
− Quản lý nhân lực: xác định, điều phối nhân lực cho hợp lý
− Quản lý sản phẩm: thêm, bớt các chức năng phù hợp với yêu cầu của khách
hàng
− Quản lý rủi ro: xác định, phân tích rủi ro và đề xuất giải pháp khắc phục.
Xuất phát từ những yêu cầu trên, chúng tôi đã chọn đề tài « Xây dựng component
quản lý dự án phần mềm cho website Joomla » làm đề tài tốt nghiệp. Việc xây dựng
một ứng dụng như vậy nhằm áp dụng những kiến thức mà chúng tôi đã được học ở

trường trong thời gian qua vào thực tiễn với mong muốn sẽ làm cho công việc quản
lý dự án doanh nghiệp phần mềm sẽ thuận tiện hơn. Chương trình được viết trên nền
web nên những người tham gia dự án chỉ cần truy cập vào website của công ty để lấy
những thông tin về dự án, trao đổi về công việc. Hơn nữa người quản lý vẫn có thể
xem xét quá trình làm dự án, trực tiếp quản lý dự án đó khi vắng mặt ở công ty.
.III Hướng nghiên cứu của đề tài
.III.1. Về mặt lý thuyết
• Tìm hiểu về CMS Joomla, ngôn ngữ PHP, MySQL, cách xây dựng
component cho website Joomla.
• Tìm hiểu về các thao thác cơ bản trong việc quản lý dự án nói chung và
quản lý dự án phần mềm nói riêng.
• Đưa ra một số định hướng để phát triển đề tài.
.III.2. Công cụ xây dựng đề tài
• Công cụ nghiên cứu cơ sở lý thuyết: Các tài liêu tham khảo về ngôn ngữ
PHP, MySQL, Joomla, quản lý dự án...
• Công cụ thiết kế phần mềm: trình duyệt Firefox, Internet Explore, Joomla
1.5.9, Jcode studio for Joomla, StarUML...
.IV Dự kiến kết quả đạt được
Xậy dựng component cho website Joomla thực hiện một số công việc cơ bản của
quản lý dự án phần mềm như:
− Hiển thị thông tin các dự án mà công ty đang thực hiện. Chương trình cho
phép admin và trưởng dự án trực tiếp chỉnh sửa, cập nhật thông tin về dự án
trên đó. Nhân viên sau khi xem thông tin về dự án nếu muốn tham gia có thể
gởi yêu cầu và nếu đựợc admin hay trưởng dự án đồng ý thì sẽ trở thành thành
viên của dự án.
− Trưởng dự án có thể chia một dự án ra thành nhiều task nhỏ, mỗi task có
một thời hạn deadline riêng, do một nhân viên trực tiếp chịu trách nhiệm để
tiện cho việc quản lý
Tên tác giả, LỚP XXX 2
Tên đề tài ở đây

− Mỗi dự án phần mềm được chia ra thành những phần cụ thể như :
• Task: Mỗi dự án chia ra thành các công việc nhỏ hơn. Mỗi công việc
có một thời hạn deadline riêng.
• Requirement: đưa ra những yêu cầu của khách hàng về dự án phần
mềm đó
• Design: đưa ra các bản thiết kế cho phần mềm sao cho phù hợp với
requirement, mỗi requirement có thể có nhiều mẫu design khác nhau
• Coding: phần này để quản lý việc coding của dự án, ứng với mỗi design
thì có một hoặc nhiều phần coding khác nhau
• Risks: là nơi đưa ra những rủi ro dự kiến được của dự án, hậu quả và
cách khắc phục...
• Delivery: trưởng dự án đưa ra thông tin về kế hoạch chuyển giao cho
khách hàng ở đây để mọi người tham khảo và điều chỉnh kế hoạch làm việc
của mình cho kịp tiến độ
• Quản lý file: Các thành viên của dự án có thể đưa những tài liệu có liên
quan lên đây cho mọi người. Chương trình cho phép tạo một thư mục mới và
liên kết với task có liên quan.
• Diễn đàn thảo luận nội bộ của các thành viên trong dự án: là nơi để các
thành viên trong dự án đưa lên những ý kiến của mình, những khó khăn khi
thực hiện để trưởng dự các và các thành viên khác xem xét, cân nhắc, đưa ra
ké hoạch làm việc phù hợp.
• Quản lý thành viên: Mỗi nhân viên phải có tài khoản đăng kí trên website
của công ty. Nếu muốn nhân viên đó trở thành thành viên của dự án thì admin
hay trưởng dự án sẽ dùng tên tài khoản mà nhân viên đã đăng kí hoặc địa chỉ
mail của nhân viên để add vào dự án
.V Nội dung tóm tắt các chương tiếp theo
Chương 1: Cơ sở lý thuyết
Chương 2: Phân tích và thiết kế hệ thống
Chương 3: Xây dựng chương trình và kết quả thực hiện
Chương 4: Kết luận

3
CHƯƠNG 2
CƠ SỞ LÝ THUYẾT
Tên tác giả, LỚP XXX 1
.I Giới thiệu về joomla
.I.1. Joomla là gì?
Joomla là một hệ quản trị nội dung mã nguồn mở (Open Source Content
Management Systems).Joomla được viết bằng ngôn ngữ PHP và kết nối tới cơ sở dữ
liệu MySQL , cho phép người sử dụng có thể dễ dàng xuất bản các nội dung của họ
lên Internet hoặc Intranet.
Joomla có các đặc tính cơ bản là: bộ đệm trang (page caching) để tăng tốc độ hiển
thị, lập chỉ mục, đọc tin RSS (RSS feeds), trang dùng để in, bản tin nhanh, blog, diễn
đàn, bình chọn, lịch biểu, tìm kiếm trong Site và hỗ trợ đa ngôn ngữ.
Joomla! được sử dụng rất phổ biến, từ những website cá nhân cho tới những hệ
thống website doanh nghiệp, cung cấp nhiều dịch vụ và ứng dụng. Joomla dễ dàng
cài đặt, quản lý và có độ tin cậy cao.
Joomla có mã nguồn mở do đó việc sử dụng Joomla là hoàn toàn miễn phí.
.I.2. Các dòng phiên bản của Joomla
Joomla có 2 dòng phiên bản chính: Joomla 1.0.x và Joomla 1.5.x
− Dòng phiên bản 1.0.x: Là phiên bản phát hành ổn định. Được sử dụng rộng
rãi, có nhiều thành phần mở rộng (component, module, mambot)...
− Dòng phiên bản 1.5.x: Là phiên bản cải tiến từ Joomla 1.0.x (phần mã được
viết lại hoàn toàn, tuy nhiên vẫn giữ cách hành xử như cũ) . Joomla 1.5 hỗ trợ
đa ngôn ngữ. Joomla 1.5 dùng charset mặc định là UTF-8 (thay vì ISO-8859-1
trong Joomla 1.0.x)
.I.3. Kiến trúc Joomla
Joomla! 1.5 gồm có 3 tầng hệ thống.
− Tầng dưới cùng là mức nền tảng, chứa các thư viện và các plugin (còn được
biết với tên gọi mambot).
− Tầng thứ hai là mức ứng dụng và chứa lớp JApplication. Hiện tại tầng này

gồm 3 lớp con: JInstallation, JAdministrator và JSite.
− Tầng thứ ba là mức mở rộng. Tại tầng này có các thành phần (component),
mô đun (module) và giao diện (template) được thực thi và thể hiện
Hình 1: Kiến trúc Joomla
.II Một số khái niệm trong Joomla
.II.1. Front-end và back-end
.II.1.1. Front-end
Front-end (tiền sảnh), còn được biết với tên gọi Public Front-end: phần giao diện
phía ngoài, nơi tiếp xúc với mọi người sử dụng. Bất cứ ai cũng có thể trông thấy khi
gõ đúng đường dẫn URL vào trình duyệt.
Front-end chứa 1 trang đặc biệt là FrontPage (homepage) - trang chủ.
.II.1.2. Back-end
Back-end, còn được biết với tên gọi Public Back-end, Administrator, Control
Pane: phần dành cho người quản trị. Những người bình thường không biết đường dẫn
để truy cập, hoặc nếu có biết thì cũng phải qua bước kiểm tra tài khoản.
Phần back-end được truy cập thông qua đường dẫn:
http://your_domain/administrator.
.II.2. Template
Là giao diện, khuông dạng, kiểu mẫu, hình thức được thiết kế để trình bày nội
dung của trang Web và có các vị trí định sẵn để tích hợp các bộ phận, thành phần của
trang Web. Joomla! cho phép cài đặt và thay đổi Temp cho Web Site hay cho từng
trang Web khác nhau một cách dễ dàng.
.II.3. Menu
Joomla! có rất nhiều kiểu Menu, mỗi Menu sẽ là một trang hiển thị có nội dung và
cách trình bày theo nhiều kiểu khác nhau.
Các Menu này được quản lý theo mã số ID nên có thể thay đổi tên và vị trí mà ảnh
hưởng đến nội dung, địa chỉ liên kết của chúng.
Joomla! cho phép lựa chọn và quyết định Menu nào làm Trang chủ (Home) là
trang sẽ xuất hiện đầu tiên khi truy cập vào địa chỉ của trang Web.
Tất cả các thành phần, nội dung,... trong Joomla! đều có thể cho phép hiển thị hay

không hiển thị (sử dụng hay không sử dụng) thông qua chức năng Published hay
Unpublish
.II.4. Các thành phần mở rộng
.II.4.1. Module
Module là một trong 3 thành phần mở rộng chính của Joomla! Đó là một đoạn mã
nhỏ thường được dùng để truy vấn các thông tin từ cơ sở dữ liệu và hiển thị các kết
quả tìm được. Nó có thể được nạp vào một vị trí bất kỳ trên template (vị trí left,
right, top, bottom... hoặc vị trí do người dùng định nghĩa); có thể hiện trên tất cả các
trang của Website hay một số trang được ấn định. Khả năng tương tác giữa người sử
dụng và hệ thống thông qua module là hạn chế (chúng ta thường chỉ nhận thông tin
trả về).
Module có tên bắt đầu bằng mod_. Chúng ta có các module thông dụng:
− Lastest News (mod_latestnews): Module hiển thị các tin mới nhất
− Popular News (mod_mostreads): Module hiển thị các bài được quan tâm
nhiều nhất
− Related Items (mod_related_items): Module hiển thị các bài viết liên
quan
− Random Image (mod_random_image): Module hiển thị các ảnh ngẫu
nhiên
− Search Module (mod_search): Module công cụ tìm kiếm
− Login Module (mod_login): Module hiển thị form đăng nhập hệ thống
− Stats Module (mod_stats): Module hiển thị các thông tin thống kê về hệ
thống
− Menu Module (mod_mainmenu): Module hiển thị các menu của website
− Banners Module (mod_banners): Moudule hiển thị các banner quảng cáo
− ...
.II.4.2. Component
Component là một thành phần mở rộng lớn nhất và phức tạp nhất của Joomla
CMS. Các component có thể xem như là các ứng dụng con và nếu joomla là một hệ
điều hành thì các component là các ứng dụng desktop. Ví dụ component nội dung

(com_content) là một ứng dụng mini xử lý tất cả các vấn đề về nội dung được trả lại
như thế nào mỗi khi có yêu cầu duyệt nội dung được đưa ra.
Một component có hai thành phần chính: phần quản trị và phần trên site. Phần trên
site là phần được sử dụng để tải về các trang khi được triệu gọi trong quá trình hoạt
động của một website thông thường. Phần quản trị cung cấp giao diện để cấu hình,
quản lý các khía cạnh khác nhau của component và được truy cập thông qua ứng
dụng quản trị của Joomla
Component có thể có thêm modul để hỗ trợ cho việc hiển thị các chức năng và nội
dung của component
Thông thường sau khi cài đặt joomla có sẵn các component: Banner (quản lý các
bảng quảng cáo), Contact ( quản lý việc liên hệ giữa người dùng với ban quản trị
website), Search (quản lý việc tìm kiếm), Web links (quản lý các liên kết ngoài
website), và các component quản lý nội dung của trang web
.II.4.3. Mambot (Plug-in)
Mambot (plug-in) là chức năng được bổ sung thêm cho component, các mambot
này sẽ can thiệp, bổ sung vào nội dung của trang web trước khi nó được hiển thị.
Mambot được xem như là phương tiện giao tiếp giữa hệ thống joomla với component,
chẳng hạn tìm kiếm thông tin
.III Cách xây dựng một component trong Joomla 1.5
.III.1. Giới thiệu mô hình MVC
Bắt đầu từ phiên bản Joomla 1.5.x hoặc các phiên bản sau này, Joomla đã đưa
vào một framework mới, mang lại những thuận tiên rất lớn cho những người phát
triển. Các đoạn code giờ đây rất dễ dàng để kiểm tra và khá rõ ràng. Framework này
đưa ra một mẫu thiết kế mới, thiết kế MVC (Model-View-Controller) trong Joomla.
Model-View-Controller (gọi tắt là MVC) là một mẫu thiết kế phần mềm được
dùng để tổ chức các đoạn mã theo cách mà việc xử lý dữ liệu và biểu diễn dữ liệu
tách rời nhau. Điều này tạo ra tiền đề cho hướng tiếp cận sau này khi mà việc xử lý
dữ liệu được nhóm vào trong một section, khi đó giao diện hay quá trình tương tác
với người dùng bao quanh dữ liệu có thể được định dạng và tùy biến lại mà không
phải lập trình lại việc xử lý dữ liệu nữa.

Model: là thành phần của component đóng gói dữ liệu cho ứng dụng. Nó thường
cung cấp các thủ tục để quản lý, thao tác dữ liệu trong đó có thêm các thủ tục để lấy
dữ liệu từ model. Có thể là bổ sung (insert), loại bỏ (delete) hay cập nhật (update)
thông tin về một trường nào đó trong cơ sở dữ liệu (CSDL). Theo cách này, nếu một
ứng dụng chuyển đổi sang việc sử dụng một file bình thường để lưu trữ thông tin của
nó thay vì sử dụng CSDL thì chỉ có thành phần Model là thay đổi còn các thành phần
View và Controller là không đổi.
View: là một thành phần của component được sử dụng để trả lại dữ liệu từ model.
Đối với ứng dụng web, view thông thường là các trang HTML để trả lại dữ liệu.
View lấy dữ liệu từ Model (dữ liệu này được chuyển qua View tới Controller). Sau
cùng là đưa dữ liệu vào trong template (dữ liệu này sẽ hiển thị với người dùng). View
không làm thay đổi dữ liệu, nó chỉ hiển thị dữ liệu lấy từ Model mà thôi)
Controller: Controller chịu trách nhiệm phản hồi các hành động của người dùng.
Trong các ứng dụng web, một hành động của người dùng thông thường là một yêu
cầu tải trang. Controller sẽ xác định yêu cầu gì được người dùng đưa ra và phản hồi
thích hợp bằng việc yêu cầu Model tính toán dữ liệu phù hợp và chuyển từ Model vào
View. Controller không thể hiện dữ liệu từ Model, nó kích hoạt các phương thức
trong Model để hiệu chỉnh dữ liệu và sau đó chuyển từ Model sang View để hiển thị
dữ liệu
Trong Joomla, mô hình MVC được hỗ trợ thông qua 3 lớp JModel, JView và
Jcontroller.
.III.2. Cài đặt Joomla MVC
Trong Joomla mấu MVC được thực hiện sử dụng 3 lớp:
− <classname>JModel</classname>
− <classname>JView</classname>
− <classname>JController</classname>
.III.3. Tạo một component
Đối với component cơ sở của chúng ta, chúng ta chỉ cần 5 file:
− hello.php - đây là điểm vào cho component của chúng ta
− controller.php - file này có chứa controler cơ bản

− views/hello/view.html.php - file này nhận các dữ liệu cần thiết và đặt nó
lên
template
− views/hello/tmpl/default.php - file này là temple cho đầu ra
− hello.xml - đây là một file XML nói cho joomla biết cách cài đặt
component
của chúng ta như thế nào
.III.3.1. Tạo một entry point
Joomla luôn luôn được truy cập thông qua một điểm vào đơn: index.php cho các
ứng dụng site và administrator/index.php cho ứng dụng quản trị. Sau đó ứng dụng sẽ
tải các component cần thiết dựa trên giá trị chọn lựa trong URL hoặc trong dữ liệu
POST. Đối với component của chúng ta URL sẽ như sau:index.php?
option=com_hello&view=hello. Việc này sẽ tải file chính của chúng ta và có thể
được xem như một điểm vào đơn cho component của chúng ta:
components/com_hello/hello.php.
<?php
defined( '_JEXEC' ) or die( 'Restricted access' );
require_once( JPATH_COMPONENT.DS.'controller.php' );
if($controller = JRequest::getWord('controller')) {
$path=JPATH_COMPONENT.DS.'controllers'.DS.$controller.'.php';
if (file_exists($path)) {
require_once $path;
} else {
$controller = '';
}
}
$classname = 'HelloController'.$controller;
$controller = new $classname( );
$controller->execute( JRequest::getVar( 'task' ) );
$controller->redirect();

?>
Câu lệnh đầu tiên là câu lệnh kiểm tra bảo mật.
JPATH_COMPONENT là đường dẫn tuyệt đối tới component hiện tại, trong
trường hợp của chúng ta là components/com_hello. Nếu bạn cần xác định site
component hoặc
admin component thì
bạn có thể sử dụng
JPATH_COMPONENT và
JPATH_COMPONENT_ADMINISTRATOR.
DS là dấu phân cách thư mục trong hệ thống của bạn: có thể là “\” hoặc “/”. Điều
này được thiết lập tự động bởi frameword, vì thế developer không phải quan tâm đến
việc phát triển các phiên bản khác nhau cho các hệ điều hành khác nhau. DS sẽ luôn
được sử dụng khi tham chiếu đến các file trên máy chủ cục bộ.
Sau khi tải controler cơ bản, chúng ta sẽ kiểm tra một controler cụ thể cần đến.
Trong component này, controler cơ bản chỉ là một controler nhưng chúng ta đề cập
đến điều này cho các công việc trong tương lai.
<classname>JRequest</classname>:getVar() tìm một biến trong URL hoặc POST dữ
liệu. Bởi vậy nếu URL của chúng ta là: index.php?
option=com_hello>controller=controller_name thì chúng ta có thể nhận được tên
controler của chúng ta trong component bằng sử dụng câu lệnh sau: echo
<classname>JRequest</classname>::getVar(’controller’);
Bây giờ chúng ta đã có controler cơ sở
‘<classname>HelloController</classname>’ trong com_hello/controller.php, và
nếu cần thiết bổ sung thêm các controler dạng như:
‘<classname>HelloControllerController1</classname>’ trong
com_hello/controllers/controller1.php.
Sau khi controler được tạo ra, chúng ta cho controler chạy nhiệm vụ như được chỉ
ra trong URL: index.php?option=com_hello&task=sometask. Nếu không có nhiệm vụ
nào được thiết lập thì nhiệm vụ mặc định ‘display’ sẽ được giả định. Khi ‘display’
được sử dụng, biến ‘view’ sẽ quyết định cái gì sẽ được hiển thị. Các nhiệm vụ khác

như ‘save’, ‘edit’, ‘new’, …
Controler có thể quyết định redirect the page (thực hiện tải lại một trang), thông
thường là sau khi một nhiệm vụ như ‘save’ được hoàn thành. Câu lệnh cuối cùng thực
hiện việc này.
Điểm vào chính (hello.php) về bản chất đã thông qua việc điều khiển controler
thực hiện các nhiệm vụ được đặt ra trong request.
.III.3.2. Tạo Controller
Component của chúng ta chỉ có một nhiệm vụ - greet the world (thể hiện lời chào).
Bởi vậy controler sẽ rất đơn giản. Không cần đến việc tính toán trên dữ liệu. Tất cả
những gì cần thiết phải làm là tải view thích hợp. Chúng ta sẽ chỉ có một phương thức
trong controler là display(). Hầu hết các hàm cần thiết được xây dựng trong lớp
JControler, bởi vậy tất cả những gì chúng ta cần là gọi phương thức
JControler::display(); Code của controler cơ sở như sau:
<?php
defined( '_JEXEC' ) or die( 'Restricted access' );
jimport('joomla.application.component.controller');
class HelloController extends JController
{
function display()
{
parent::display();
}
}
?>
Việc khởi tạo của <classname>JController</classname> sẽ luôn luôn đăng ký một
nhiệm vụ display() khi không có nhiệm vụ cụ thể nào được chỉ ra (bằng việc sử dụng
phương thức registerDefaultTask()), nó sẽ được thiết lập như một nhiệm vụ mặc định.
Phương thức display() này thật sự không cần thiết bởi vì tất cả những gì nó làm là
gọi hàm khởi tạo của cha nó. Tuy nhiên, đó là một cơ sở khá tốt để chỉ ra điều gì cần
phải làm trong controler.

Phương thức <classname>JController</classname>::display() sẽ xác định view và
layout từ request, tải view đó và thiết lập layout. Khi bạn tạo ra một menu item cho
component của bạn, menu manager sẽ cho phép admin lựa chọn view mà họ thích để
thể hiện và trên layout cụ thể. Một view thông thường được xem như một cách hiển
thị của một tập các dữ liệu nào đó (ví dụ, danh sách các car, danh sách các event, một
car đơn, một event đơn, …). Một layout là một cách tổ chức view.
Trong component của chúng ta chúng ta sẽ có một view đơn được gọi là hello, và
một layout đơn (default).
.III.3.3. Tạo View
Nhiệm vụ của view là rất đơn giản: nó nhận dữ liệu được thể hiện và đặt nó lên
template. Dữ liệu được đặt lên template sử dụng phương thức
<classname>JView</classname>::assignRef. Đoạn mã của view như sau:
<?php
defined( '_JEXEC' ) or die( 'Restricted access' );
jimport( 'joomla.application.component.view');
class HelloViewHello extends JView
{
function display($tpl = null)
{
$greeting = "Hello World!";
$this->assignRef( 'greeting', $greeting );
parent::display($tpl);
}
}
?>
.III.3.4. Tạo Template
Joomla template/ layout là các file PHP thông thường, được sử dụng để bố trí,
xếp đặt dữ liệu từ view theo một cách cụ thể nào đó. Các biến được gán bởi phương
thức JView::assignRef có thể được truy cập từ template sử dụng
$this→{propertyname} (xem mã template bên dưới như một ví dụ).

Template của chúng ta rất đơn giản, chúng ta chỉ muốn thể hiện một lời chào hợp
quy cách từ view.
<?php
defined('_JEXEC') or die('Restricted access'); ?>
<h1><?php echo $this->greeting; ?></h1>
.III.3.5. Đóng gói tất cả- Tạo file hello.xml
Có thể cài đặt thủ công một component bằng cách copy tất cả các file bằng FPT
client và hiệu chỉnh CSDL. Nhưng sẽ hiệu quả hơn nếu tạo ra một file được đóng gói
để Joomla! Installer thực hiện điều này cho bạn. File đóng gói này sẽ chứa nhiều dạng
thông tin khác nhau như:
− Các miêu tả chi tiết cơ bản về component của bạn (ví dụ như tên), và tùy ý
một số mô tả thông tin về bản quyền ….
− Một danh sách các file cần copy.
−

Một file PHP thực hiện bổ sung các thao tác cài đặt và gỡ bỏ (file này là
không bắt buộc).
− Một file SQL có chứa các câu truy vấn dữ liệu mà sẽ được thực hiện vào
lúc cài đặt hoặc gỡ bỏ (file này là không bắt buộc).
Định dạng của file XML như dưới đây:
<?xml version="1.0" encoding="utf-8"?>
<!DOCTYPE install SYSTEM " />install.dtd">
<install type="component" version="1.5.0">
<name>Hello</name>
<creationDate>2007 02 22</creationDate>
<author>John Doe</author>
<authorEmail></authorEmail>
<authorUrl></authorUrl>
<copyright>Copyright Info</copyright>
<license>License Info</license>

<version>Component Version String</version>
<description>Description of the component ...</description>
<files folder="site">
<filename>index.html</filename>
<filename>hello.php</filename>
<filename>controller.php</filename>
<filename>views/index.html</filename>
<filename>views/hello/index.html</filename>
<filename>views/hello/view.html.php</filename>
<filename>views/hello/tmpl/index.html</filename>
<filename>views/hello/tmpl/default.php</filename>
</files>
<administration>
<menu>Hello World!</menu>
<files folder="admin">
<filename>index.html</filename>
<filename>admin.hello.php</filename>
</files>
</administration>
</install>
Nếu bạn đã xem xét file này một cách cẩn thận bạn sẽ nhận thấy rằng có một vài
file sẽ được copy mà chúng ta chưa đề cập ở trên. Chúng là các file index.html. Một
file

index.html được đặt trong mỗi thư mục để ngăn cản những người dùng tò mò
trong việc liệt kê một danh sách thư mục. Nếu không có file index.html một vài máy
chủ web sẽ liệt kê danh sách nội dung của thư mục. Điều này thường gây rắc rối. Các
file này có một dòng đơn như sau: (Nó đơn giản là thể hiện một trang trống)
<html><body bgcolor="#FFFFFF"></body></html>
File khác là admin.hello.php, đây là điểm vào cho section quản trị trong

component của chúng ta. Bởi vì chúng ta chưa có section quản trị trong component
vào thời điểm này nên nó sẽ có nội dung tương tự như file index.html.
.III.4. Bổ sung Model vào component
.III.4.1. Tạo Model
Khái niệm model được gọi tên như thế bởi vì lớp này được dùng để mô hình hóa
cho một vài thực thể nào đó. Trong trường hợp của chúng ta, model đầu tiên sẽ đưa
ra một lời chào mừng. Điều này phù hợp với thiết kế hiện tại, bởi vì chúng ta đã có
một view ‘hello’, view đó thể hiện một câu chào mừng tới người dùng.
Cách thông thường để đặt tên cho các model trong Joomla! Frameword là tên lớp
bắt đầu bằng tên của component (trong trường hợp của chúng ta là ‘hello’), tiếp theo
là ‘model’, và cuối cùng là là tên của model. Bởi thế lớp model của chúng ta được
gọi là HelloModelHello.
Ở thời điểm này chúng ta chỉ mô hình hóa cách xử lý của model hello, và nó sẽ trả
lại một lời chào. Chúng ta sẽ có một phương thức được gọi là getGreeting(). Phương
thức này đơn giản là trả lại chuỗi “Hello, World”. Dưới đây là code cho model của
chúng ta:
<?php
defined('_JEXEC') or die();
jimport( 'joomla.application.component.model' );
class HelloModelHello extends JModel
{
function getGreeting()
{
return 'Hello, World!';
}
}
Trong đoạn code trên, chú ý dòng bắt đầu là lệnh jimport. Hàm jimport được sử
dụng để tải các file từ Joomla! frameword cần thiết cho component. Cụ thể câu lệnh
trên sẽ tải file /libraries/joomla/application/component/model.php. Các dấu chấm ‘.’
được sử dụng như các dấu phân cách thư mục, và phần cuối cùng là tên file cần tải.

Tất cả các file được tải từ thư mục libraries. File trong trường hợp trên có chứa định
nghĩa của lớp JModel, điều này là cần thiết vì lớp của chúng ta được kế thừa từ lớp
này.
Bây giờ chúng ta đã tạo ra model của mình. Tiếp theo chúng ta sẽ phải hiệu chính
view để nó có thể lấy được lời chào.
.III.4.2. Sử sụng Model
Joomla! Frameword được thiết lập theo cách controler sẽ tự động tải model có tên
trùng với view và đặt nó vào trong view. Vì view của chúng ta được đặt là ‘hello’,
nên model ‘hello’ của chúng ta sẽ tự động được tải và được đặt vào trong view. Bởi
vậy chúng ta sẽ dễ dàng nhận được một tham chiếu đến model của chúng ta sử dụng
phương thức JView::getModel(). Đoạn mã cho view trước của chúng ta có chứa
dòng:
$greeting = "Hello World!";
Để sử dụng model, chúng ta chuyển đổi dòng trên thành:
$model =& $this->getModel();
$greeting = $model->getGreeting();
Bây giờ, code của view sẽ như sau:
<?php
defined( '_JEXEC' ) or die( 'Restricted access' );
jimport( 'joomla.application.component.view');
class HelloViewHello extends JView
{
function display($tpl = null)
{
$model =& $this->getModel();
$greeting = $model->getGreeting();
$this->assignRef( 'greeting', $greeting );
parent::display($tpl);
}
}

?>
.III.4.3. Bổ sung file vào package
Tất cả những gì còn lại cần phải làm là bổ sung một entry vào file XML để model
mới của chúng ta được copy. Joomla! Frameword sẽ tìm kiếm model của chúng ta
trong thư mục models. Bởi vậy entry cho file này trông như sau:
<filename>models/hello.php</filename>
File hello.xml mới của chúng ta sẽ như sau:
<?xml version="1.0" encoding="utf-8"?>
<!DOCTYPE install SYSTEM " />install.dtd">
<install type="component" version="1.5.0">
<name>Hello</name>
<creationDate>2007 02 22</creationDate>
<author>John Doe</author>
<authorEmail></authorEmail>
<authorUrl></authorUrl>
<copyright>Copyright Info</copyright>
<license>License Info</license>
<version>Component Version String</version>
<description>Description of the component ...</description>
<files folder="site">
<filename>index.html</filename>
<filename>hello.php</filename>
<filename>controller.php</filename>
<filename>views/index.html</filename>
<filename>views/hello/index.html</filename>
<filename>views/hello/view.html.php</filename>
<filename>views/hello/tmpl/index.html</filename>
<filename>views/hello/tmpl/default.php</filename>
<filename>models/index.html</filename>
<filename>models/hello.php</filename>

</files>
<administration>
<menu>Hello World!</menu>
<files folder="admin">
<filename>index.html</filename>
<filename>admin.hello.php</filename>
</files>
</administration>
</install>
.III.5. Sử dụng cơ sở dữ liệu trong component MVC
.III.5.1. Lấy dữ liệu
Model hiện tại của chúng ta có một phương thức getGreeting(). Phương thức này
rất đơn giản, tất cả những gì nó làm là trả về một câu chào được code cố định.
Để làm những điều này thú vị hơn, chúng ta sẽ lấy câu chào từ bảng cơ sở dữ
liệu. Trong phần sau, chúng ta sẽ mô tả làm cách nào để tạo ra một file SQL và bổ
sung các đoạn mã phù hợp vào file XML để tạo ra bảng và bổ sung dữ liệu mẫu vào
bảng khi component được cài đặt. Bây giờ, chúng ta chỉ đơn giản thay thế câu lệnh
trả về trong hàm getGreeting bằng đoạn code lấy lời chào mừng từ CSDL và trả lại
lời chào mừng đó.
Đầu tiên, chúng ta cần lấy được một tham chiếu đến đối tượng CSDL. Vì
joomla sử dụng CSDL cho các thao tác thông thường của nó, nên nó đã có một kết
nối tới CSDL tồn tại, bởi thế không cần thiết phải tạo ra một kết nối CSDL riêng. Có
thể lấy được một tham chiếu tới kết nối bằng cách sử dụng câu lệnh:
$db =& JFactory::getDBO();
JFactory là một lớp static được sử dụng để nhận tham chiếu đến nhiều đối tượng
hệ
thống khác nhau. Các thông tin thêm về lớp này có thể tham khảo trong tài liệu về
API. Tên hàm getDBO là viết tắt cho get DataBase Object, có thể nhớ một cách dễ
dàng và rất quan trọng.
Bây giờ chúng ta đã có một tham chiếu đến đối tượng CSDL, Chúng ta có thể lấy

dữ liệu. Điều này được thực qua hai bước:
− Lưu trữ câu truy vấn của vào đối tượng CSDL
− Tải kết quả về
Code của phương thức getGreeting() bây giờ sẽ như sau:
function getGreeting()
{
$db =& JFactory::getDBO();
$query = 'SELECT greeting FROM #__hello';
$db->setQuery( $query );
$greeting = $db->loadResult();
return $greeting;
}
Trong đoạn mã trên ‘hello’ là tên của bảng trong CSDL mà chúng ta sẽ tạo ra
trong phần sau. Và ‘greeting’ là tên của trường lưu trữ câu chào mừng.
Phương thức $db→loadResult() sẽ chạy câu lệnh truy vấn CSDL đã được lưu trữ
và trả về trường đầu tiên của dòng đầu tiên trong kết quả. Xem JDatabase API
reference để có các thông tin nhiều hơn về các phương thức khác trong lớp
JDatabase.