-
Notifications
You must be signed in to change notification settings - Fork 0
/
Baker.php
137 lines (127 loc) · 3.93 KB
/
Baker.php
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
<?php
/**
* Class Baker for the exercises of the EWA lecture in SS09
* Demonstrates use of PHP including class and OO.
* Implements Zend coding standards.
* Generate documentation with Doxygen or phpdoc
*
* PHP Version 5
*
* @category File
* @package Pizzaservice
* @author Bernhard Kreling, <b.kreling@fbi.h-da.de>
* @license http://www.h-da.de none
* @Release 1.0
* @link http://www.fbi.h-da.de
*/
require_once './Page.php';
require_once './private/BlockStatus.php';
/**
* This is a template for top level classes, which represent
* a complete web page and which are called directly by the user.
* Usually there will only be a single instance of such a class.
* The name of the template is supposed
* to be replaced by the name of the specific XHTML page e.g. baker.
* The order of methods might correspond to the order of thinking
* during implementation.
* @author Bernhard Kreling, <b.kreling@fbi.h-da.de>
*/
class Baker extends Page
{
/**
* Reference to block BlockStatus
*/
protected $_statusbaker = null;
/**
* Instantiates members (to be defined above).
* Calls the constructor of the parent i.e. page class.
* So the database connection is established.
*
* @return none
*/
protected function __construct()
{
parent::__construct();
$this->_statusbaker = new BlockStatus(
$this->_database,
array('1b', '2o'),
array('1b', '2o', '3f'));
}
/**
* Cleans up what ever is needed.
* Calls the destructor of the parent i.e. page class.
* So the database connection is closed.
*
* @return none
*/
protected function __destruct()
{
parent::__destruct();
}
/**
* Fetch all data that is necessary for later output.
* Data is stored in an easily accessible way e.g. as associative array.
*
* @return none
*/
protected function getViewData()
{
// to do: fetch data for this view from the database
}
/**
* First the necessary data is fetched and then the XHTML is
* assembled for output. i.e. the header is generated, the content
* of the page ("view") is inserted and -if avaialable- the content of
* all views contained is generated.
* Finally the footer is added.
*
* @return none
*/
protected function generateView()
{
$this->getViewData();
$this->generatePageHeader('Bäcker', 'body_onload_Status');
$this->_statusbaker->generateView('BlockStatusBaker');
$this->generatePageFooter();
}
/**
* Processes the data that comes via GET or POST i.e. CGI.
* If this page is supposed to do something with submitted
* data do it here.
* If the page contains blocks do it recursively.
*
* @return none
*/
protected function processReceivedData()
{
parent::processReceivedData();
$this->_statusbaker->processReceivedData();
}
/**
* This main-function has the only purpose to create an instance
* of the class and to get all the things going.
* I.e. the operations of the class are called to produce
* the output of the XHTML-file.
* The name "main" is no keyword for php. It is just used to
* indicate that function as the central starting point.
* To make it simpler this is a static function. That is you can simply
* call it without first creating an instance of the class.
*
* @return none
*/
public static function main()
{
try {
$page = new Baker();
$page->processReceivedData();
$page->generateView();
}
catch (Exception $e) {
header("Content-type: text/plain; charset=ISO-8859-1");
echo $e->getMessage();
}
}
}
// This call is starting the creation of the page.
// That is input is processed and output is created.
Baker::main();